internal void Configure(ClientBuildManager client)
{
this.AddPendingCall();
try
{
this._virtualPathProvider = new ClientVirtualPathProvider();
HostingEnvironment.RegisterVirtualPathProviderInternal(this._virtualPathProvider);
this._client = client;
if (this._client.CBMTypeDescriptionProviderBridge != null)
{
TargetFrameworkUtil.CBMTypeDescriptionProviderBridge = this._client.CBMTypeDescriptionProviderBridge;
}
this._onAppDomainUnload = new EventHandler(this.OnAppDomainUnload);
Thread.GetDomain().DomainUnload += this._onAppDomainUnload;
this._buildManager = BuildManager.TheBuildManager;
HttpRuntime.AppDomainShutdown += new BuildManagerHostUnloadEventHandler(this.OnAppDomainShutdown);
}
finally
{
this.RemovePendingCall();
}
}
void AssignToGroup(BuildProvider buildProvider, List <BuildProviderGroup> groups)
{
if (IsDependencyCycle(buildProvider))
{
throw new HttpException("Dependency cycles are not suppported: " + buildProvider.VirtualPath);
}
BuildProviderGroup myGroup = null;
string bpVirtualPath = buildProvider.VirtualPath;
string bpPath = VirtualPathUtility.GetDirectory(bpVirtualPath);
bool canAdd;
if (BuildManager.HasCachedItemNoLock(buildProvider.VirtualPath))
{
return;
}
StringComparison stringComparison = RuntimeHelpers.StringComparison;
if (buildProvider is ApplicationFileBuildProvider || buildProvider is ThemeDirectoryBuildProvider)
{
// global.asax and theme directory go into their own assemblies
myGroup = new BuildProviderGroup();
myGroup.Standalone = true;
InsertGroup(myGroup, groups);
}
else
{
Type bpCodeDomType = GetBuildProviderCodeDomType(buildProvider);
foreach (BuildProviderGroup group in groups)
{
if (group.Standalone)
{
continue;
}
if (group.Count == 0)
{
myGroup = group;
break;
}
canAdd = true;
foreach (BuildProvider bp in group)
{
if (IsDependency(buildProvider, bp))
{
canAdd = false;
break;
}
// There should be one assembly per virtual dir
if (String.Compare(bpPath, VirtualPathUtility.GetDirectory(bp.VirtualPath), stringComparison) != 0)
{
canAdd = false;
break;
}
// Different languages go to different assemblies
if (bpCodeDomType != null)
{
Type type = GetBuildProviderCodeDomType(bp);
if (type != null)
{
if (type != bpCodeDomType)
{
canAdd = false;
break;
}
}
}
}
if (!canAdd)
{
continue;
}
myGroup = group;
break;
}
if (myGroup == null)
{
myGroup = new BuildProviderGroup();
InsertGroup(myGroup, groups);
}
}
myGroup.AddProvider(buildProvider);
if (String.Compare(bpPath, virtualPathDirectory, stringComparison) == 0)
{
myGroup.Master = true;
}
}
internal void Configure(ClientBuildManager client) {
// Add a pending call to make sure our thread doesn't get killed
AddPendingCall();
try {
_virtualPathProvider = new ClientVirtualPathProvider();
HostingEnvironment.RegisterVirtualPathProviderInternal(_virtualPathProvider);
_client = client;
// Type description provider required for multitargeting compilation support in VS.
if (_client.CBMTypeDescriptionProviderBridge != null) {
TargetFrameworkUtil.CBMTypeDescriptionProviderBridge = _client.CBMTypeDescriptionProviderBridge;
}
// start watching for app domain unloading
_onAppDomainUnload = new EventHandler(OnAppDomainUnload);
Thread.GetDomain().DomainUnload += _onAppDomainUnload;
_buildManager = BuildManager.TheBuildManager;
// Listen to appdomain shutdown.
HttpRuntime.AppDomainShutdown += new BuildManagerHostUnloadEventHandler(this.OnAppDomainShutdown);
}
finally {
RemovePendingCall();
}
}
private void FixupReferencedAssemblies(VirtualPath virtualPath, CompilerParameters compilerParameters)
{
Util.AddAssembliesToStringCollection(BuildManager.GetReferencedAssemblies(MTConfigUtil.GetCompilationConfig(virtualPath)), compilerParameters.ReferencedAssemblies);
}
internal CompilerResults BuildAssembly(VirtualPath virtualPath, CompilerParameters options)
{
if (options == null)
{
throw new ArgumentNullException("options");
}
options.TempFiles = temp_files;
if (options.OutputAssembly == null)
{
options.OutputAssembly = OutputAssemblyName;
}
ProcessPartialTypes();
CompilerResults results;
CodeUnit [] units = GetUnitsAsArray();
// Since we may have some source files and some code
// units, we generate code from all of them and then
// compile the assembly from the set of temporary source
// files. This also facilates possible debugging for the
// end user, since they get the code beforehand.
List <string> files = SourceFiles;
Dictionary <string, string> resources = ResourceFiles;
if (units.Length == 0 && files.Count == 0 && resources.Count == 0 && options.EmbeddedResources.Count == 0)
{
return(null);
}
string compilerOptions = options.CompilerOptions;
if (options.IncludeDebugInformation)
{
if (String.IsNullOrEmpty(compilerOptions))
{
compilerOptions = "/d:DEBUG";
}
else if (compilerOptions.IndexOf("d:DEBUG", StringComparison.OrdinalIgnoreCase) == -1)
{
compilerOptions += " /d:DEBUG";
}
options.CompilerOptions = compilerOptions;
}
if (String.IsNullOrEmpty(compilerOptions))
{
compilerOptions = "/noconfig";
}
else if (compilerOptions.IndexOf("noconfig", StringComparison.OrdinalIgnoreCase) == -1)
{
compilerOptions += " /noconfig";
}
options.CompilerOptions = compilerOptions;
string filename;
StreamWriter sw = null;
foreach (CodeUnit unit in units)
{
filename = GetTempFilePhysicalPath(provider.FileExtension);
try {
sw = new StreamWriter(File.OpenWrite(filename), Encoding.UTF8);
provider.GenerateCodeFromCompileUnit(unit.Unit, sw, null);
files.Add(filename);
} catch {
throw;
} finally {
if (sw != null)
{
sw.Flush();
sw.Close();
}
}
if (unit.BuildProvider != null)
{
AddPathToBuilderMap(filename, unit.BuildProvider);
}
}
foreach (KeyValuePair <string, string> de in resources)
{
options.EmbeddedResources.Add(de.Value);
}
AddAssemblyReference(BuildManager.GetReferencedAssemblies());
List <Assembly> referencedAssemblies = ReferencedAssemblies;
StringCollection optRefAsm = options.ReferencedAssemblies;
Type appType = HttpApplicationFactory.AppType;
if (appType != null && !referencedAssemblies.Contains(appType.Assembly))
{
referencedAssemblies.Add(appType.Assembly);
}
foreach (Assembly refasm in ReferencedAssemblies)
{
string path = new Uri(refasm.CodeBase).LocalPath;
string originalPath = refasm.Location;
if (!optRefAsm.Contains(path) && !optRefAsm.Contains(originalPath))
{
optRefAsm.Add(path);
}
}
results = provider.CompileAssemblyFromFile(options, files.ToArray());
if (results.NativeCompilerReturnValue != 0)
{
string fileText = null;
CompilerErrorCollection errors = results.Errors;
try {
if (errors != null && errors.Count > 0)
{
using (StreamReader sr = File.OpenText(results.Errors [0].FileName))
fileText = sr.ReadToEnd();
}
} catch (Exception) {}
#if DEBUG
Console.WriteLine("********************************************************************");
Console.WriteLine("Compilation failed.");
Console.WriteLine("Output:");
foreach (string s in results.Output)
{
Console.WriteLine(" " + s);
}
Console.WriteLine("\nErrors:");
foreach (CompilerError err in results.Errors)
{
Console.WriteLine(err);
}
if (errors != null && errors.Count > 0)
{
Console.WriteLine("File name: {0}", results.Errors [0].FileName);
}
else
{
Console.WriteLine("File name not available");
}
if (!String.IsNullOrEmpty(fileText))
{
Console.WriteLine("File text:\n{0}\n", fileText);
}
else
{
Console.WriteLine("No file text available");
}
Console.WriteLine("********************************************************************");
#endif
throw new CompilationException(virtualPath != null ? virtualPath.Original : String.Empty, results, fileText);
}
Assembly assembly = results.CompiledAssembly;
if (assembly == null)
{
if (!File.Exists(options.OutputAssembly))
{
results.TempFiles.Delete();
throw new CompilationException(virtualPath != null ? virtualPath.Original : String.Empty, results.Errors,
"No assembly returned after compilation!?");
}
try {
results.CompiledAssembly = Assembly.LoadFrom(options.OutputAssembly);
} catch (Exception ex) {
results.TempFiles.Delete();
throw new HttpException("Unable to load compiled assembly", ex);
}
}
if (!KeepFiles)
{
results.TempFiles.Delete();
}
return(results);
}
internal CodeCompileUnit GenerateCodeCompileUnit(VirtualPath virtualPath, string virtualFileString, out Type codeDomProviderType, out CompilerParameters compilerParameters, out IDictionary linePragmasTable)
{
CodeCompileUnit codeCompileUnit;
this.AddPendingCall();
try
{
BuildManager.SkipTopLevelCompilationExceptions = true;
this._buildManager.EnsureTopLevelFilesCompiled();
if (virtualFileString == null)
{
using (Stream stream = virtualPath.OpenFile())
{
virtualFileString = Util.ReaderFromStream(stream, virtualPath).ReadToEnd();
}
}
this._virtualPathProvider.RegisterVirtualFile(virtualPath, virtualFileString);
string cacheKey = BuildManager.GetCacheKeyFromVirtualPath(virtualPath) + "_CBMResult";
BuildResultCodeCompileUnit buildResultFromCache = (BuildResultCodeCompileUnit)BuildManager.GetBuildResultFromCache(cacheKey, virtualPath);
if (buildResultFromCache == null)
{
lock (this._lock)
{
DateTime utcNow = DateTime.UtcNow;
System.Web.Compilation.BuildProvider provider = this.GetCompilerParamsAndBuildProvider(virtualPath, out codeDomProviderType, out compilerParameters);
if (provider == null)
{
linePragmasTable = null;
return(null);
}
CodeCompileUnit unit2 = provider.GetCodeCompileUnit(out linePragmasTable);
buildResultFromCache = new BuildResultCodeCompileUnit(codeDomProviderType, unit2, compilerParameters, linePragmasTable)
{
VirtualPath = virtualPath
};
buildResultFromCache.SetCacheKey(cacheKey);
this.FixupReferencedAssemblies(virtualPath, compilerParameters);
if (unit2 != null)
{
foreach (string str2 in compilerParameters.ReferencedAssemblies)
{
unit2.ReferencedAssemblies.Add(str2);
}
}
ICollection virtualPathDependencies = provider.VirtualPathDependencies;
if (virtualPathDependencies != null)
{
buildResultFromCache.AddVirtualPathDependencies(virtualPathDependencies);
}
BuildManager.CacheBuildResult(cacheKey, buildResultFromCache, utcNow);
return(unit2);
}
}
codeDomProviderType = buildResultFromCache.CodeDomProviderType;
compilerParameters = buildResultFromCache.CompilerParameters;
linePragmasTable = buildResultFromCache.LinePragmasTable;
this.FixupReferencedAssemblies(virtualPath, compilerParameters);
codeCompileUnit = buildResultFromCache.CodeCompileUnit;
}
finally
{
if (virtualFileString != null)
{
this._virtualPathProvider.RevertVirtualFile(virtualPath);
}
BuildManager.SkipTopLevelCompilationExceptions = false;
this.RemovePendingCall();
}
return(codeCompileUnit);
}
internal bool IsCodeAssembly(string assemblyName)
{
return(BuildManager.GetNormalizedCodeAssemblyName(assemblyName) != null);
}
private static BuildResultCompiledType GetThemeBuildResultType(string themeName)
{
string cacheKey = null;
string str = "Theme_" + Util.MakeValidTypeNameFromString(themeName);
BuildResultCompiledType buildResultFromCache = (BuildResultCompiledType)BuildManager.GetBuildResultFromCache(str);
if (buildResultFromCache == null)
{
cacheKey = "GlobalTheme_" + themeName;
buildResultFromCache = (BuildResultCompiledType)BuildManager.GetBuildResultFromCache(cacheKey);
}
if (buildResultFromCache == null)
{
bool gotLock = false;
try
{
CompilationLock.GetLock(ref gotLock);
buildResultFromCache = (BuildResultCompiledType)BuildManager.GetBuildResultFromCache(str);
if (buildResultFromCache == null)
{
buildResultFromCache = (BuildResultCompiledType)BuildManager.GetBuildResultFromCache(cacheKey);
}
if (buildResultFromCache != null)
{
return(buildResultFromCache);
}
VirtualPath virtualDirPath = null;
VirtualPath appThemeVirtualDir = GetAppThemeVirtualDir(themeName);
PageThemeBuildProvider themeBuildProvider = null;
VirtualPath configPath = appThemeVirtualDir;
string str3 = str;
if (appThemeVirtualDir.DirectoryExists())
{
themeBuildProvider = new PageThemeBuildProvider(appThemeVirtualDir);
}
else
{
virtualDirPath = GetGlobalThemeVirtualDir(themeName);
if (!virtualDirPath.DirectoryExists())
{
throw new HttpException(System.Web.SR.GetString("Page_theme_not_found", new object[] { themeName }));
}
configPath = virtualDirPath;
str3 = cacheKey;
themeBuildProvider = new GlobalPageThemeBuildProvider(virtualDirPath);
}
DateTime utcNow = DateTime.UtcNow;
AddThemeFilesToBuildProvider(configPath.GetDirectory(), themeBuildProvider, true);
BuildProvidersCompiler compiler = new BuildProvidersCompiler(configPath, themeBuildProvider.AssemblyNamePrefix + BuildManager.GenerateRandomAssemblyName(themeName));
compiler.SetBuildProviders(new SingleObjectCollection(themeBuildProvider));
CompilerResults results = compiler.PerformBuild();
buildResultFromCache = (BuildResultCompiledType)themeBuildProvider.GetBuildResult(results);
BuildManager.CacheBuildResult(str3, buildResultFromCache, utcNow);
}
finally
{
if (gotLock)
{
CompilationLock.ReleaseLock();
}
}
}
return(buildResultFromCache);
}
public override void GenerateCode(AssemblyBuilder assemblyBuilder)
{
string str2;
if (!s_triedToGetWebRefType)
{
s_indigoWebRefProviderType = BuildManager.GetType("System.Web.Compilation.WCFBuildProvider", false);
s_triedToGetWebRefType = true;
}
if (s_indigoWebRefProviderType != null)
{
BuildProvider provider = (BuildProvider)HttpRuntime.CreateNonPublicInstance(s_indigoWebRefProviderType);
provider.SetVirtualPath(base.VirtualPathObject);
provider.GenerateCode(assemblyBuilder);
}
VirtualPath webRefDirectoryVirtualPath = HttpRuntime.WebRefDirectoryVirtualPath;
string virtualPath = this._vdir.VirtualPath;
if (webRefDirectoryVirtualPath.VirtualPathString.Length == virtualPath.Length)
{
str2 = string.Empty;
}
else
{
string[] strArray = UrlPath.RemoveSlashFromPathIfNeeded(virtualPath).Substring(webRefDirectoryVirtualPath.VirtualPathString.Length).Split(new char[] { '/' });
for (int i = 0; i < strArray.Length; i++)
{
strArray[i] = Util.MakeValidTypeNameFromString(strArray[i]);
}
str2 = string.Join(".", strArray);
}
CodeNamespace proxyCode = new CodeNamespace(str2);
WebReferenceCollection webReferences = new WebReferenceCollection();
bool flag = false;
foreach (VirtualFile file in this._vdir.Files)
{
if (UrlPath.GetExtension(file.VirtualPath).ToLower(CultureInfo.InvariantCulture) == ".discomap")
{
string topLevelFilename = HostingEnvironment.MapPath(file.VirtualPath);
DiscoveryClientProtocol protocol = new DiscoveryClientProtocol {
AllowAutoRedirect = true,
Credentials = CredentialCache.DefaultCredentials
};
protocol.ReadAll(topLevelFilename);
WebReference reference = new WebReference(protocol.Documents, proxyCode);
string str5 = Path.ChangeExtension(UrlPath.GetFileName(file.VirtualPath), null);
string appSettingUrlKey = str2 + "." + str5;
WebReference webReference = new WebReference(protocol.Documents, proxyCode, reference.ProtocolName, appSettingUrlKey, null);
webReferences.Add(webReference);
flag = true;
}
}
if (flag)
{
CodeCompileUnit codeCompileUnit = new CodeCompileUnit();
codeCompileUnit.Namespaces.Add(proxyCode);
WebReferenceOptions options = new WebReferenceOptions {
CodeGenerationOptions = CodeGenerationOptions.GenerateOldAsync | CodeGenerationOptions.GenerateNewAsync | CodeGenerationOptions.GenerateProperties,
Style = ServiceDescriptionImportStyle.Client,
Verbose = true
};
ServiceDescriptionImporter.GenerateWebReferences(webReferences, assemblyBuilder.CodeDomProvider, codeCompileUnit, options);
assemblyBuilder.AddCodeCompileUnit(this, codeCompileUnit);
}
}
// Cache the various compile errors found during batching
private void CacheCompileErrors(AssemblyBuilder assemblyBuilder, CompilerResults results)
{
BuildProvider previous = null;
// Go through all the compile errors
foreach (CompilerError error in results.Errors)
{
// Skip warnings
if (error.IsWarning)
{
continue;
}
// Try to map the error back to a BuildProvider. If we can't, skip the error.
BuildProvider buildProvider = assemblyBuilder.GetBuildProviderFromLinePragma(error.FileName);
if (buildProvider == null)
{
continue;
}
// Only cache the error for template controls. Otherwise, for file types like
// asmx/ashx, it's too likely that two of them define the same class.
if (!(buildProvider is BaseTemplateBuildProvider))
{
continue;
}
// If the error is for the same page as the previous one, ignore it
if (buildProvider == previous)
{
continue;
}
previous = buildProvider;
// Create a new CompilerResults for this error
CompilerResults newResults = new CompilerResults(null /*tempFiles*/);
// Copy all the output to the new result. Note that this will include all the
// error lines, not just the ones for this BuildProvider. But that's not a big deal,
// and we can't easily filter the output here.
foreach (string s in results.Output)
{
newResults.Output.Add(s);
}
// Copy various other fields to the new CompilerResults object
newResults.PathToAssembly = results.PathToAssembly;
newResults.NativeCompilerReturnValue = results.NativeCompilerReturnValue;
// Add this error. It will be the only one in the CompilerResults object.
newResults.Errors.Add(error);
// Create a new HttpCompileException & BuildResultCompileError to wrap this error
HttpCompileException e = new HttpCompileException(newResults,
assemblyBuilder.GetGeneratedSourceFromBuildProvider(buildProvider));
BuildResult result = new BuildResultCompileError(buildProvider.VirtualPathObject, e);
// Add the dependencies to the compile error build provider, so that
// we will retry compilation when a dependency changes
buildProvider.SetBuildResultDependencies(result);
// Cache it
BuildManager.CacheVPathBuildResult(buildProvider.VirtualPathObject, result, _utcStart);
}
}
private void AddBuildProviders(bool retryIfDeletionHappens)
{
DiskBuildResultCache.ResetAssemblyDeleted();
foreach (VirtualFile vfile in _vdir.Files)
{
// If it's already built and up to date, skip it
BuildResult result = null;
try {
result = BuildManager.GetVPathBuildResultFromCache(vfile.VirtualPathObject);
}
catch {
// Ignore the cached error in batch compilation mode, since we want to compile
// as many files as possible.
// But don't ignore it in CBM or precompile cases, since we always want to try
// to compile everything that had failed before.
if (!BuildManager.PerformingPrecompilation)
{
// Skip it if an exception occurs (e.g. if a compile error was cached for it)
continue;
}
}
if (result != null)
{
continue;
}
BuildProvider buildProvider = BuildManager.CreateBuildProvider(vfile.VirtualPathObject,
_compConfig, _referencedAssemblies, false /*failIfUnknown*/);
// Non-supported file type
if (buildProvider == null)
{
continue;
}
// IgnoreFileBuildProvider's should never be created
Debug.Assert(!(buildProvider is IgnoreFileBuildProvider));
_buildProviders[vfile.VirtualPath] = buildProvider;
}
// If an assembly had to be deleted/renamed as a result of calling GetVPathBuildResultFromCache,
// me way need to run the AddBuildProviders logic again. The reason is that as a result of
// deleting the assembly, we may have invalidated other BuildResult that we had earlier found
// to be up to date (VSWhidbey 269297)
if (DiskBuildResultCache.InUseAssemblyWasDeleted)
{
Debug.Assert(retryIfDeletionHappens);
// Only retry if we're doing precompilation. For standard batching, we can live
// with the fact that not everything will be built after we're done (and we want to
// be done as quickly as possible since the user is waiting).
if (retryIfDeletionHappens && BuildManager.PerformingPrecompilation)
{
Debug.Trace("WebDirectoryBatchCompiler", "Rerunning AddBuildProviders for '" +
_vdir.VirtualPath + "' because an assembly was out of date.");
// Pass false for retryIfDeletionHappens to make sure we don't get in an
// infinite recursion.
AddBuildProviders(false /*retryIfDeletionHappens*/);
}
}
}
protected override void CreateConstructor(CodeStatementCollection localVars,
CodeStatementCollection trueStmt)
{
MainDirectiveAttribute <string> masterPageFile = pageParser.MasterPageFile;
if (masterPageFile != null && !masterPageFile.IsExpression)
{
// This is here just to trigger master page build, so that its type
// is available when compiling the page itself.
BuildManager.GetCompiledType(masterPageFile.Value);
}
MainDirectiveAttribute <string> clientTarget;
clientTarget = pageParser.ClientTarget;
if (clientTarget != null)
{
CodeExpression prop;
prop = new CodePropertyReferenceExpression(thisRef, "ClientTarget");
CodeExpression ct = null;
if (clientTarget.IsExpression)
{
var pi = GetFieldOrProperty(typeof(Page), "ClientTarget") as PropertyInfo;
if (pi != null)
{
ct = CompileExpression(pi, pi.PropertyType, clientTarget.UnparsedValue, false);
}
}
if (ct == null)
{
ct = new CodePrimitiveExpression(clientTarget.Value);
}
if (localVars == null)
{
localVars = new CodeStatementCollection();
}
localVars.Add(new CodeAssignStatement(prop, ct));
}
List <string> deps = pageParser.Dependencies;
int depsCount = deps != null ? deps.Count : 0;
if (depsCount > 0)
{
if (localVars == null)
{
localVars = new CodeStatementCollection();
}
if (trueStmt == null)
{
trueStmt = new CodeStatementCollection();
}
CodeAssignStatement assign;
localVars.Add(
new CodeVariableDeclarationStatement(
typeof(string[]),
"dependencies")
);
CodeVariableReferenceExpression dependencies = new CodeVariableReferenceExpression("dependencies");
trueStmt.Add(
new CodeAssignStatement(dependencies, new CodeArrayCreateExpression(typeof(string), depsCount))
);
CodeArrayIndexerExpression arrayIndex;
object o;
for (int i = 0; i < depsCount; i++)
{
o = deps [i];
arrayIndex = new CodeArrayIndexerExpression(dependencies, new CodeExpression[] { new CodePrimitiveExpression(i) });
assign = new CodeAssignStatement(arrayIndex, new CodePrimitiveExpression(o));
trueStmt.Add(assign);
}
CodeMethodInvokeExpression getDepsCall = new CodeMethodInvokeExpression(
thisRef,
"GetWrappedFileDependencies",
new CodeExpression[] { dependencies }
);
assign = new CodeAssignStatement(GetMainClassFieldReferenceExpression("__fileDependencies"), getDepsCall);
trueStmt.Add(assign);
}
base.CreateConstructor(localVars, trueStmt);
}
