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

379 lines
16 KiB
C#

//------------------------------------------------------------------------------
// <copyright file="CodeDirectoryCompiler.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
namespace System.Web.Compilation {
using System;
using System.IO;
using System.Collections;
using System.CodeDom.Compiler;
using System.Configuration;
using System.Globalization;
using System.Web.Configuration;
using System.Reflection;
using System.Web.Hosting;
using System.Web.Util;
using System.Web.UI;
// The different types of directory that we treat as 'Code' (with minor differences)
internal enum CodeDirectoryType {
MainCode, // The main /code directory
SubCode, // Code subdirectories registered to be compiled separately
AppResources, // The /Resources directory
LocalResources, // A /LocalResources directory (at any level)
WebReferences // The /WebReferences directory
}
internal class CodeDirectoryCompiler {
private VirtualPath _virtualDir;
private CodeDirectoryType _dirType;
private StringSet _excludedSubdirectories;
private BuildProvidersCompiler _bpc;
private BuildProviderSet _buildProviders = new BuildProviderSet();
private bool _onlyBuildLocalizedResources;
static internal BuildResultMainCodeAssembly _mainCodeBuildResult;
internal static bool IsResourceCodeDirectoryType(CodeDirectoryType dirType) {
return dirType == CodeDirectoryType.AppResources || dirType == CodeDirectoryType.LocalResources;
}
internal static Assembly GetCodeDirectoryAssembly(VirtualPath virtualDir,
CodeDirectoryType dirType, string assemblyName,
StringSet excludedSubdirectories, bool isDirectoryAllowed) {
string physicalDir = virtualDir.MapPath();
if (!isDirectoryAllowed) {
// The directory should never exist in a precompiled app
if (Directory.Exists(physicalDir)) {
throw new HttpException(SR.GetString(SR.Bar_dir_in_precompiled_app, virtualDir));
}
}
bool supportLocalization = IsResourceCodeDirectoryType(dirType);
// Determine the proper cache key based on the type of directory we're processing
string cacheKey = assemblyName;
// Try the cache first
BuildResult result = BuildManager.GetBuildResultFromCache(cacheKey);
Assembly resultAssembly = null;
// If it's cached, just return it
if (result != null) {
// It should always be a BuildResultCompiledAssembly, though if there is
// a VirtualPathProvider doing very bad things, it may not (VSWhidbey 341701)
Debug.Assert(result is BuildResultCompiledAssembly);
if (result is BuildResultCompiledAssembly) {
// If it's the main code assembly, keep track of it so we can later call
// the AppInitialize method
if (result is BuildResultMainCodeAssembly) {
Debug.Assert(dirType == CodeDirectoryType.MainCode);
Debug.Assert(_mainCodeBuildResult == null);
_mainCodeBuildResult = (BuildResultMainCodeAssembly) result;
}
resultAssembly = ((BuildResultCompiledAssembly)result).ResultAssembly;
if (!supportLocalization)
return resultAssembly;
// We found a preserved resource assembly. However, we may not be done,
// as the culture specific files may have changed.
// But don't make any further checks if the directory is not allowed (precomp secenario).
// In that case, we should always return the assembly (VSWhidbey 533498)
if (!isDirectoryAllowed)
return resultAssembly;
BuildResultResourceAssembly buildResultResAssembly = (BuildResultResourceAssembly)result;
string newResourcesDependenciesHash = HashCodeCombiner.GetDirectoryHash(virtualDir);
// If the resources hash (which includes satellites) is up to date, we're done
if (newResourcesDependenciesHash == buildResultResAssembly.ResourcesDependenciesHash)
return resultAssembly;
}
}
// If app was precompiled, don't attempt compilation
if (!isDirectoryAllowed)
return null;
// Check whether the virtual dir is mapped to a different application,
// which we don't support (VSWhidbey 218603). But don't do this for LocalResource (VSWhidbey 237935)
if (dirType != CodeDirectoryType.LocalResources && !StringUtil.StringStartsWithIgnoreCase(physicalDir, HttpRuntime.AppDomainAppPathInternal)) {
throw new HttpException(SR.GetString(SR.Virtual_codedir, virtualDir.VirtualPathString));
}
// If the directory doesn't exist, we may be done
if (!Directory.Exists(physicalDir)) {
// We're definitely done if it's not the main code dir
if (dirType != CodeDirectoryType.MainCode)
return null;
// If it is the main code dir, we're only done is there is no profile to compile
// since the profice gets built as part of the main assembly.
if (!ProfileBuildProvider.HasCompilableProfile)
return null;
}
// Otherwise, compile it
BuildManager.ReportDirectoryCompilationProgress(virtualDir);
DateTime utcStart = DateTime.UtcNow;
CodeDirectoryCompiler cdc = new CodeDirectoryCompiler(virtualDir,
dirType, excludedSubdirectories);
string outputAssemblyName = null;
if (resultAssembly != null) {
// If resultAssembly is not null, we are in the case where we just need to build
// the localized resx file in a resources dir (local or global)
Debug.Assert(supportLocalization);
outputAssemblyName = resultAssembly.GetName().Name;
cdc._onlyBuildLocalizedResources = true;
}
else {
outputAssemblyName = BuildManager.GenerateRandomAssemblyName(assemblyName);
}
BuildProvidersCompiler bpc =
new BuildProvidersCompiler(virtualDir, supportLocalization, outputAssemblyName);
cdc._bpc = bpc;
// Find all the build provider we want to compile from the code directory
cdc.FindBuildProviders();
// Give them to the BuildProvidersCompiler
bpc.SetBuildProviders(cdc._buildProviders);
// Compile them into an assembly
CompilerResults results = bpc.PerformBuild();
// Did we just compile something?
if (results != null) {
Debug.Assert(result == null);
Debug.Assert(resultAssembly == null);
// If there is already a loaded module with the same path, try to wait for it to be unloaded.
// Otherwise, we would end up loading this old assembly instead of the new one (VSWhidbey 554697)
DateTime waitLimit = DateTime.UtcNow.AddMilliseconds(3000);
for (;;) {
IntPtr hModule = UnsafeNativeMethods.GetModuleHandle(results.PathToAssembly);
if (hModule == IntPtr.Zero)
break;
Debug.Trace("CodeDirectoryCompiler", results.PathToAssembly + " is already loaded. Waiting a bit");
System.Threading.Thread.Sleep(250);
// Stop trying if the timeout was reached
if (DateTime.UtcNow > waitLimit) {
Debug.Trace("CodeDirectoryCompiler", "Timeout waiting for old assembly to unload: " + results.PathToAssembly);
throw new HttpException(SR.GetString(SR.Assembly_already_loaded, results.PathToAssembly));
}
}
resultAssembly = results.CompiledAssembly;
}
// It is possible that there was nothing to compile (and we're not in the
// satellite resources case)
if (resultAssembly == null)
return null;
// For the main code directory, use a special BuildResult that takes care of
// calling AppInitialize if it finds one
if (dirType == CodeDirectoryType.MainCode) {
// Keep track of it so we can later call the AppInitialize method
_mainCodeBuildResult = new BuildResultMainCodeAssembly(resultAssembly);
result = _mainCodeBuildResult;
}
else if (supportLocalization) {
result = new BuildResultResourceAssembly(resultAssembly);
}
else {
result = new BuildResultCompiledAssembly(resultAssembly);
}
result.VirtualPath = virtualDir;
// If compilations are optimized, we need to include the right dependencies, since we can no longer
// rely on everything getting wiped out when something in App_Code changes.
// But don't do this for local resources, since they have their own special way of
// dealing with dependencies (in BuildResultResourceAssembly.ComputeSourceDependenciesHashCode).
// It's crucial *not* to do it as it triggers a tricky infinite recursion due to the fact
// that GetBuildResultFromCacheInternal calls EnsureFirstTimeDirectoryInitForDependencies if
// there is at least one dependency
if (BuildManager.OptimizeCompilations && dirType != CodeDirectoryType.LocalResources) {
result.AddVirtualPathDependencies(new SingleObjectCollection(virtualDir.AppRelativeVirtualPathString));
}
// Top level assembly should not be cached to memory. But LocalResources are *not*
// top level files, and do benefit from memory caching
if (dirType != CodeDirectoryType.LocalResources)
result.CacheToMemory = false;
// Cache it for next time
BuildManager.CacheBuildResult(cacheKey, result, utcStart);
return resultAssembly;
}
// Call the AppInitialize method in the Code assembly if there is one
internal static void CallAppInitializeMethod() {
if (_mainCodeBuildResult != null)
_mainCodeBuildResult.CallAppInitializeMethod();
}
internal const string sourcesDirectoryPrefix = "Sources_";
internal static void GetCodeDirectoryInformation(
VirtualPath virtualDir, CodeDirectoryType dirType, StringSet excludedSubdirectories, int index,
out Type codeDomProviderType, out CompilerParameters compilerParameters,
out string generatedFilesDir) {
// Compute the full path to the directory we'll use to generate all
// the code files
generatedFilesDir = HttpRuntime.CodegenDirInternal + "\\" +
sourcesDirectoryPrefix + virtualDir.FileName;
bool supportLocalization = IsResourceCodeDirectoryType(dirType);
// the index is used to retrieve the correct referenced assemblies
BuildProvidersCompiler bpc = new BuildProvidersCompiler(virtualDir, supportLocalization,
generatedFilesDir, index);
CodeDirectoryCompiler cdc = new CodeDirectoryCompiler(virtualDir,
dirType, excludedSubdirectories);
cdc._bpc = bpc;
// Find all the build provider we want to compile from the code directory
cdc.FindBuildProviders();
// Give them to the BuildProvidersCompiler
bpc.SetBuildProviders(cdc._buildProviders);
// Generate all the sources into the directory generatedFilesDir
bpc.GenerateSources(out codeDomProviderType, out compilerParameters);
}
private CodeDirectoryCompiler(VirtualPath virtualDir, CodeDirectoryType dirType,
StringSet excludedSubdirectories) {
_virtualDir = virtualDir;
_dirType = dirType;
_excludedSubdirectories = excludedSubdirectories;
}
private void FindBuildProviders() {
// If we need to build the profile, add its build provider
if (_dirType == CodeDirectoryType.MainCode && ProfileBuildProvider.HasCompilableProfile) {
_buildProviders.Add(ProfileBuildProvider.Create());
}
VirtualDirectory vdir = HostingEnvironment.VirtualPathProvider.GetDirectory(_virtualDir);
ProcessDirectoryRecursive(vdir, true /*topLevel*/);
}
private void AddFolderLevelBuildProviders(VirtualDirectory vdir, FolderLevelBuildProviderAppliesTo appliesTo) {
BuildManager.AddFolderLevelBuildProviders(_buildProviders, vdir.VirtualPathObject,
appliesTo, _bpc.CompConfig, _bpc.ReferencedAssemblies);
}
private void ProcessDirectoryRecursive(VirtualDirectory vdir, bool topLevel) {
// If it's a WebReferences directory, handle it using a single WebReferencesBuildProvider
// instead of creating a different BuildProvider for each file.
if (_dirType == CodeDirectoryType.WebReferences) {
// Create a build provider for the current directory
BuildProvider buildProvider = new WebReferencesBuildProvider(vdir);
buildProvider.SetVirtualPath(vdir.VirtualPathObject);
_buildProviders.Add(buildProvider);
AddFolderLevelBuildProviders(vdir, FolderLevelBuildProviderAppliesTo.WebReferences);
}
else if (_dirType == CodeDirectoryType.AppResources) {
AddFolderLevelBuildProviders(vdir, FolderLevelBuildProviderAppliesTo.GlobalResources);
}
else if (_dirType == CodeDirectoryType.LocalResources) {
AddFolderLevelBuildProviders(vdir, FolderLevelBuildProviderAppliesTo.LocalResources);
}
else if (_dirType == CodeDirectoryType.MainCode || _dirType == CodeDirectoryType.SubCode) {
AddFolderLevelBuildProviders(vdir, FolderLevelBuildProviderAppliesTo.Code);
}
// Go through all the files in the directory
foreach (VirtualFileBase child in vdir.Children) {
if (child.IsDirectory) {
// If we are at the top level of this code directory, and the current
// subdirectory is in the exclude list, skip it
if (topLevel && _excludedSubdirectories != null &&
_excludedSubdirectories.Contains(child.Name)) {
continue;
}
// Exclude the special FrontPage directory (VSWhidbey 116727)
if (child.Name == "_vti_cnf")
continue;
ProcessDirectoryRecursive(child as VirtualDirectory, false /*topLevel*/);
continue;
}
// Don't look at individual files for WebReferences directories
if (_dirType == CodeDirectoryType.WebReferences)
continue;
// Skip neutral files if _onlyBuildLocalizedResources is true
if (IsResourceCodeDirectoryType(_dirType)) {
if (_onlyBuildLocalizedResources && System.Web.UI.Util.GetCultureName(child.VirtualPath) == null) {
continue;
}
}
BuildProvider buildProvider = BuildManager.CreateBuildProvider(child.VirtualPathObject,
(IsResourceCodeDirectoryType(_dirType)) ?
BuildProviderAppliesTo.Resources : BuildProviderAppliesTo.Code,
_bpc.CompConfig,
_bpc.ReferencedAssemblies, false /*failIfUnknown*/);
// Non-supported file type
if (buildProvider == null)
continue;
// For Page resources, don't generate a strongly typed class
if (_dirType == CodeDirectoryType.LocalResources && buildProvider is BaseResourcesBuildProvider) {
((BaseResourcesBuildProvider)buildProvider).DontGenerateStronglyTypedClass();
}
_buildProviders.Add(buildProvider);
}
}
}
}