Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

548 lines
18 KiB
C#

//------------------------------------------------------------------------------
// <copyright file="BuildProvider.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
/*********************************
Class hierarchy
BuildProvider
ProfileBuildProvider
BaseResourcesBuildProvider
ResXBuildProvider
ResourcesBuildProvider
XsdBuildProvider
WsdlBuildProvider
InternalBuildProvider
SourceFileBuildProvider
SimpleHandlerBuildProvider
WebServiceBuildProvider
WebHandlerBuildProvider
ImageGeneratorBuildProvider
BaseTemplateBuildProvider
ApplicationBuildProvider
TemplateControlBuildProvider
PageBuildProvider
UserControlBuildProvider
MasterPageBuildProvider
PageThemeBuildProvider
GlobalPageThemeBuildProvider
**********************************/
namespace System.Web.Compilation {
using System;
using System.Security.Permissions;
using System.IO;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.CodeDom;
using System.CodeDom.Compiler;
using System.Web.Util;
using System.Web.UI;
using System.Web.Hosting;
// Flags returned from BuildProvider.GetResultFlags
[Flags]
public enum BuildProviderResultFlags {
Default = 0,
ShutdownAppDomainOnChange = 1,
}
/// <devdoc>
/// <para>
/// Base class for build providers that want to participate in a compilation.
/// It should be used by build providers that process files based on a virtual path.
/// </para>
/// </devdoc>
public abstract class BuildProvider {
private static Dictionary<string, BuildProviderInfo> s_dynamicallyRegisteredProviders = new Dictionary<string, BuildProviderInfo>();
//
// Public interface
//
/// <devdoc>
/// Returns the CompilerType for the language that this build provider
/// needs to use, or null of it can use any language.
/// </devdoc>
public virtual CompilerType CodeCompilerType { get { return null; } }
/// <devdoc>
/// Asks this build provider to generate any code that it needs, using the various
/// methods on the passed in BuildProvider.
/// </devdoc>
public virtual void GenerateCode(AssemblyBuilder assemblyBuilder) {}
/// <devdoc>
/// Returns the class generated by this buildprovider
/// </devdoc>
public virtual Type GetGeneratedType(CompilerResults results) {
return null;
}
/// <devdoc>
/// Returns a string that the provider wants to have persisted with the compiled assembly.
/// </devdoc>
public virtual string GetCustomString(CompilerResults results) {
return null;
}
/// <devdoc>
/// Returns some flags that drives the behavior of the persisted result.
/// </devdoc>
public virtual BuildProviderResultFlags GetResultFlags(CompilerResults results) {
return BuildProviderResultFlags.Default;
}
/// <devdoc>
/// Give the BuildProvider a chance to look at the compile errors, and possibly tweak them
/// </devdoc>
public virtual void ProcessCompileErrors(CompilerResults results) {
}
/// <devdoc>
/// Returns the list of files (virtual paths) that this provider depends on.
/// Those files need to be built before this BuildProvider. The resulting assemblies
/// are added as references when compiling this BuildProvider.
/// This does not include things like server side includes, which don't directly
/// produce a BuildResult.
/// This is used to implement batching by separating BuildProviders
/// </devdoc>
internal virtual ICollection GetBuildResultVirtualPathDependencies() { return null; }
public virtual ICollection VirtualPathDependencies {
get {
// By default, return the virtual path as its only dependency
return new SingleObjectCollection(VirtualPath);
}
}
/// <devdoc>
/// Returns the virtual path that this build provider handles
/// </devdoc>
protected internal string VirtualPath {
get { return System.Web.VirtualPath.GetVirtualPathString(_virtualPath); }
}
/// <devdoc>
/// Returns the virtual path object that this build provider handles
/// </devdoc>
internal VirtualPath VirtualPathObject {
get { return _virtualPath; }
}
/// <devdoc>
/// Opens a stream for the virtual file handled by this provider
/// </devdoc>
protected Stream OpenStream() {
return OpenStream(VirtualPath);
}
/// <devdoc>
/// Opens a stream for a virtual file
/// </devdoc>
protected Stream OpenStream(string virtualPath) {
return VirtualPathProvider.OpenFile(virtualPath);
}
internal /*protected*/ Stream OpenStream(VirtualPath virtualPath) {
return virtualPath.OpenFile();
}
/// <devdoc>
/// Opens a reader for the virtual file handled by this provider
/// </devdoc>
protected TextReader OpenReader() {
return OpenReader(VirtualPathObject);
}
/// <devdoc>
/// Opens a reader for a virtual file
/// </devdoc>
protected TextReader OpenReader(string virtualPath) {
return OpenReader(System.Web.VirtualPath.Create(virtualPath));
}
internal /*protected*/ TextReader OpenReader(VirtualPath virtualPath) {
Stream stream = OpenStream(virtualPath);
return Util.ReaderFromStream(stream, virtualPath);
}
public static void RegisterBuildProvider(string extension, Type providerType) {
if (String.IsNullOrEmpty(extension)) {
throw ExceptionUtil.ParameterNullOrEmpty("extension");
}
if (providerType == null) {
throw new ArgumentNullException("providerType");
}
if (!typeof(BuildProvider).IsAssignableFrom(providerType)) {
//
throw ExceptionUtil.ParameterInvalid("providerType");
}
BuildManager.ThrowIfPreAppStartNotRunning();
// Last call wins. If a user wants to use a different provider they can always provide an
// override in the app's config.
s_dynamicallyRegisteredProviders[extension] = new CompilationBuildProviderInfo(providerType);
}
internal static BuildProviderInfo GetBuildProviderInfo(System.Web.Configuration.CompilationSection config, string extension) {
Debug.Assert(extension != null);
var entry = config.BuildProviders[extension];
if (entry != null) {
return entry.BuildProviderInfo;
}
BuildProviderInfo info = null;
s_dynamicallyRegisteredProviders.TryGetValue(extension, out info);
return info;
}
/// <devdoc>
/// Returns a collection of assemblies that the build provider will be compiled with.
/// </devdoc>
protected ICollection ReferencedAssemblies {
get { return _referencedAssemblies; }
}
/// <devdoc>
/// Returns the default CompilerType to be used for a specific language
/// </devdoc>
protected CompilerType GetDefaultCompilerTypeForLanguage(string language) {
return CompilationUtil.GetCompilerInfoFromLanguage(VirtualPathObject, language);
}
/// <devdoc>
/// Returns the default CompilerType to be used for the default language
/// </devdoc>
protected CompilerType GetDefaultCompilerType() {
return CompilationUtil.GetDefaultLanguageCompilerInfo(null /*compConfig*/, VirtualPathObject);
}
//
// Internal code
//
#pragma warning disable 0649
internal SimpleBitVector32 flags;
#pragma warning restore 0649
// const masks into the BitVector32
internal const int isDependedOn = 0x00000001;
internal const int noBuildResult = 0x00000002;
internal const int ignoreParseErrors = 0x00000004;
internal const int ignoreControlProperties = 0x00000008;
internal const int dontThrowOnFirstParseError = 0x00000010;
internal const int contributedCode = 0x00000020;
private VirtualPath _virtualPath;
private ICollection _referencedAssemblies;
private BuildProviderSet _buildProviderDependencies;
internal BuildProviderSet BuildProviderDependencies {
get {
return _buildProviderDependencies;
}
}
// Is any other BuildProvider depending on this BuildProvider
internal bool IsDependedOn { get { return flags[isDependedOn]; } }
internal void SetNoBuildResult() {
flags[noBuildResult] = true;
}
// Remember that this BuildProvider has contributed to the compilation
internal void SetContributedCode() {
flags[contributedCode] = true;
}
internal void SetVirtualPath(VirtualPath virtualPath) {
_virtualPath = virtualPath;
}
internal void SetReferencedAssemblies(ICollection referencedAssemblies) {
_referencedAssemblies = referencedAssemblies;
}
internal void AddBuildProviderDependency(BuildProvider dependentBuildProvider) {
if (_buildProviderDependencies == null)
_buildProviderDependencies = new BuildProviderSet();
_buildProviderDependencies.Add(dependentBuildProvider);
dependentBuildProvider.flags[isDependedOn] = true;
}
/*
* Return the culture name for this provider (e.g. "fr" or "fr-fr").
* If no culture applies, return null.
*/
internal string GetCultureName() {
return Util.GetCultureName(VirtualPath);
}
internal BuildResult GetBuildResult(CompilerResults results) {
BuildResult result = CreateBuildResult(results);
if (result == null)
return null;
result.VirtualPath = VirtualPathObject;
SetBuildResultDependencies(result);
return result;
}
internal virtual BuildResult CreateBuildResult(CompilerResults results) {
// If the build provider is not supposed to have a build result, just return
if (flags[noBuildResult])
return null;
// Access the CompiledAssembly property to make sure the assembly gets loaded
// Otherwise, the user code in GetGeneratedType() will fail to load it in medium trust since
// they don't have access to the codegen folder
if (!BuildManagerHost.InClientBuildManager && results != null) {
// The ClientBuildManager runs in full trust, so we skip this statement
// to avoid unnecessary loading of the assembly.
var assembly = results.CompiledAssembly;
}
// Ask the build provider if it wants to persist a Type
Type type = GetGeneratedType(results);
BuildResult result;
if (type != null) {
// Create a BuildResult for it
BuildResultCompiledType resultCompiledType = CreateBuildResult(type);
if (!resultCompiledType.IsDelayLoadType) {
// If the returned type doesn't come from the generated assembly, set a flag
if (results == null || type.Assembly != results.CompiledAssembly)
resultCompiledType.UsesExistingAssembly = true;
}
result = resultCompiledType;
}
else {
// Ask the build provider if it instead wants to persist a custom string
string customString = GetCustomString(results);
// If it does, persist it
if (customString != null) {
// Only preserve an assembly if the BuildProvider has actually contributed code
// to the compilation.
result = new BuildResultCustomString(
flags[contributedCode] ? results.CompiledAssembly : null,
customString);
}
else {
// Nothing was built: nothing to persist
if (results == null)
return null;
// Otherwise, just persist the assembly, if any
result = new BuildResultCompiledAssembly(results.CompiledAssembly);
}
}
// Ask the provider it it wants to set some flags on the result
int resultFlags = (int) GetResultFlags(results);
if (resultFlags != 0) {
// Make sure only the lower bits are set
Debug.Assert((resultFlags & 0xFFFF0000) == 0);
resultFlags &= 0x0000FFFF;
result.Flags |= resultFlags;
}
return result;
}
internal virtual BuildResultCompiledType CreateBuildResult(Type t) {
return new BuildResultCompiledType(t);
}
internal void SetBuildResultDependencies(BuildResult result) {
result.AddVirtualPathDependencies(VirtualPathDependencies);
}
//
// Helper methods
//
internal static CompilerType GetCompilerTypeFromBuildProvider(
BuildProvider buildProvider) {
HttpContext context = null;
if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Infrastructure) && (context = HttpContext.Current) != null)
EtwTrace.Trace(EtwTraceType.ETW_TYPE_PARSE_ENTER, context.WorkerRequest);
try {
CompilerType compilerType = buildProvider.CodeCompilerType;
if (compilerType != null) {
CompilationUtil.CheckCompilerOptionsAllowed(compilerType.CompilerParameters.CompilerOptions,
false /*config*/, null, 0);
}
return compilerType;
}
finally {
if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Infrastructure) && context != null)
EtwTrace.Trace(EtwTraceType.ETW_TYPE_PARSE_LEAVE, context.WorkerRequest);
}
}
//
// Return a 'friendly' string that identifies the build provider
//
internal static string GetDisplayName(BuildProvider buildProvider) {
// If it has a VirtualPath, use it
if (buildProvider.VirtualPath != null) {
return buildProvider.VirtualPath;
}
// Otherwise, the best we can do is the type name
return buildProvider.GetType().Name;
}
internal virtual ICollection GetGeneratedTypeNames() {
return null;
}
#region Methods from InternalBuildProvider
// Protected internal methods: IgnoreParseErrors and GetCodeCompileUnit
// When this is set, we ignore parse errors and keep on processing the page as
// well as possible. This is used for the Venus CBM scenario
internal virtual bool IgnoreParseErrors {
get { return flags[ignoreParseErrors]; }
set { flags[ignoreParseErrors] = value; }
}
// This is used in CBM to instruct the control builders to skip control properties
internal bool IgnoreControlProperties {
get { return flags[ignoreControlProperties]; }
set { flags[ignoreControlProperties] = value; }
}
// Indicates whether the parser should continue processing for more errors.
// This is used in both CBM and aspnet_compiler tool.
internal bool ThrowOnFirstParseError {
get { return !flags[dontThrowOnFirstParseError]; }
set { flags[dontThrowOnFirstParseError] = !value; }
}
// This is used in the CBM scenario only
internal virtual IAssemblyDependencyParser AssemblyDependencyParser {
get { return null; }
}
// This is used in the CBM scenario only
/// <devdoc>
/// Returns the CodeCompileUnit and sets the associated dictionary containing the line pragmas.
/// </devdoc>
protected internal virtual CodeCompileUnit GetCodeCompileUnit(out IDictionary linePragmasTable) {
// Default implementation with code at line 1
string sourceString = Util.StringFromVirtualPath(VirtualPathObject);
CodeSnippetCompileUnit snippetCompileUnit = new CodeSnippetCompileUnit(sourceString);
LinePragmaCodeInfo codeInfo = new LinePragmaCodeInfo(1 /* startLine */, 1 /* startColumn */, 1 /* startGeneratedColumn */, -1 /* codeLength */, false /* isCodeNuggest */);
linePragmasTable = new Hashtable();
linePragmasTable[1] = codeInfo;
return snippetCompileUnit;
}
internal virtual ICollection GetCompileWithDependencies() { return null; }
#endregion Methods from InternalBuildProvider
private class CompilationBuildProviderInfo : BuildProviderInfo {
private readonly Type _type;
public CompilationBuildProviderInfo(Type type) {
Debug.Assert(type != null);
_type = type;
}
internal override Type Type {
get {
return _type;
}
}
}
}
// The InternalBuildProvider class is still retained to internally distinguish between
// buildProviders that actually implement the required methods and those that don't, and
// also to minimize code change where possible.
internal abstract class InternalBuildProvider: BuildProvider {
}
internal abstract class BuildProviderInfo {
// AppliesTo value from the BuildProviderAppliesToAttribute
private BuildProviderAppliesTo _appliesTo;
internal abstract Type Type { get; }
internal BuildProviderAppliesTo AppliesTo {
get {
if (_appliesTo != 0)
return _appliesTo;
// Check whether the control builder's class exposes an AppliesTo attribute
object[] attrs = Type.GetCustomAttributes(
typeof(BuildProviderAppliesToAttribute), /*inherit*/ true);
if ((attrs != null) && (attrs.Length > 0)) {
Debug.Assert(attrs[0] is BuildProviderAppliesToAttribute);
_appliesTo = ((BuildProviderAppliesToAttribute)attrs[0]).AppliesTo;
}
else {
// Default to applying to All
_appliesTo = BuildProviderAppliesTo.All;
}
return _appliesTo;
}
}
}
}