// Add the referenced assemblies into the compileParameters. Notice that buildProviders do not have
// the correct referenced assemblies and we don't cache them since the assemblies could change
// between appdomains. (removing assemblies from bin, etc)
private void FixupReferencedAssemblies(VirtualPath virtualPath, CompilerParameters compilerParameters)
{
CompilationSection compConfig = MTConfigUtil.GetCompilationConfig(virtualPath);
ICollection referencedAssemblies = BuildManager.GetReferencedAssemblies(compConfig);
Util.AddAssembliesToStringCollection(referencedAssemblies, compilerParameters.ReferencedAssemblies);
}
internal WebDirectoryBatchCompiler(VirtualDirectory vdir)
{
this._vdir = vdir;
this._utcStart = DateTime.UtcNow;
this._compConfig = MTConfigUtil.GetCompilationConfig(this._vdir.VirtualPath);
this._referencedAssemblies = BuildManager.GetReferencedAssemblies(this._compConfig);
}
internal BuildProvidersCompiler(VirtualPath configPath, bool supportLocalization, string generatedFilesDir, int index)
{
this._configPath = configPath;
this._supportLocalization = supportLocalization;
this._compConfig = MTConfigUtil.GetCompilationConfig(this._configPath);
this._referencedAssemblies = BuildManager.GetReferencedAssemblies(this.CompConfig, index);
this._generatedFilesDir = generatedFilesDir;
}
internal BuildProvidersCompiler(VirtualPath configPath, bool supportLocalization, string outputAssemblyName)
{
this._configPath = configPath;
this._supportLocalization = supportLocalization;
this._compConfig = MTConfigUtil.GetCompilationConfig(this._configPath);
this._referencedAssemblies = BuildManager.GetReferencedAssemblies(this.CompConfig);
this._outputAssemblyName = outputAssemblyName;
}
private System.Web.Compilation.BuildProvider GetCompilerParamsAndBuildProvider(VirtualPath virtualPath, out Type codeDomProviderType, out CompilerParameters compilerParameters)
{
virtualPath.CombineWithAppRoot();
CompilationSection compilationConfig = MTConfigUtil.GetCompilationConfig(virtualPath);
ICollection referencedAssemblies = BuildManager.GetReferencedAssemblies(compilationConfig);
System.Web.Compilation.BuildProvider provider = null;
if (StringUtil.EqualsIgnoreCase(virtualPath.VirtualPathString, BuildManager.GlobalAsaxVirtualPath.VirtualPathString))
{
ApplicationBuildProvider provider2 = new ApplicationBuildProvider();
provider2.SetVirtualPath(virtualPath);
provider2.SetReferencedAssemblies(referencedAssemblies);
provider = provider2;
}
else
{
provider = BuildManager.CreateBuildProvider(virtualPath, compilationConfig, referencedAssemblies, true);
}
provider.IgnoreParseErrors = true;
provider.IgnoreControlProperties = true;
provider.ThrowOnFirstParseError = false;
CompilerType codeCompilerType = provider.CodeCompilerType;
if (codeCompilerType == null)
{
codeDomProviderType = null;
compilerParameters = null;
return(null);
}
codeDomProviderType = codeCompilerType.CodeDomProviderType;
compilerParameters = codeCompilerType.CompilerParameters;
IAssemblyDependencyParser assemblyDependencyParser = provider.AssemblyDependencyParser;
if ((assemblyDependencyParser != null) && (assemblyDependencyParser.AssemblyDependencies != null))
{
Util.AddAssembliesToStringCollection(assemblyDependencyParser.AssemblyDependencies, compilerParameters.ReferencedAssemblies);
}
AssemblyBuilder.FixUpCompilerParameters(codeDomProviderType, compilerParameters);
return(provider);
}
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());
var assembliesToReference = new List <Assembly> ();
var moduleGuidCache = new Dictionary <Guid, bool> ();
StringCollection optRefAsm = options.ReferencedAssemblies;
ReferenceAssemblies(moduleGuidCache, assembliesToReference, ReferencedAssemblies);
ReferenceAssemblies(moduleGuidCache, assembliesToReference, optRefAsm);
Type appType = HttpApplicationFactory.AppType;
if (appType != null)
{
ReferenceAssembly(moduleGuidCache, assembliesToReference, appType.Assembly);
}
optRefAsm.Clear();
foreach (Assembly refasm in assembliesToReference)
{
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.Error.WriteLine("********************************************************************");
Console.Error.WriteLine("Compilation failed.");
Console.Error.WriteLine("Output:");
foreach (string s in results.Output)
{
Console.Error.WriteLine(" " + s);
}
Console.Error.WriteLine("\nErrors:");
foreach (CompilerError err in results.Errors)
{
Console.Error.WriteLine(err);
}
if (errors != null && errors.Count > 0)
{
Console.Error.WriteLine("File name: {0}", results.Errors [0].FileName);
}
else
{
Console.Error.WriteLine("File name not available");
}
if (!String.IsNullOrEmpty(fileText))
{
Console.Error.WriteLine("File text:\n{0}\n", fileText);
}
else
{
Console.Error.WriteLine("No file text available");
}
Console.Error.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);
}
private BuildProvider GetCompilerParamsAndBuildProvider(VirtualPath virtualPath,
out Type codeDomProviderType, out CompilerParameters compilerParameters)
{
virtualPath.CombineWithAppRoot();
CompilationSection compConfig = MTConfigUtil.GetCompilationConfig(virtualPath);
ICollection referencedAssemblies = BuildManager.GetReferencedAssemblies(compConfig);
// Create the buildprovider for the passed in virtualPath
BuildProvider buildProvider = null;
// Special case global asax build provider here since we do not want to compile every files with ".asax" extension.
if (StringUtil.EqualsIgnoreCase(virtualPath.VirtualPathString, BuildManager.GlobalAsaxVirtualPath.VirtualPathString))
{
ApplicationBuildProvider provider = new ApplicationBuildProvider();
provider.SetVirtualPath(virtualPath);
provider.SetReferencedAssemblies(referencedAssemblies);
buildProvider = provider;
}
else
{
buildProvider = BuildManager.CreateBuildProvider(virtualPath, compConfig,
referencedAssemblies, true /*failIfUnknown*/);
}
// DevDiv 69017
// The methods restricted to internalBuildProvider have been moved up to BuildProvider
// to allow WCFBuildProvider to support .svc syntax highlighting.
// Ignore parse errors, since they should not break the designer
buildProvider.IgnoreParseErrors = true;
// Ignore all control properties, since we do not generate code for the properties
buildProvider.IgnoreControlProperties = true;
// Process as many errors as possible, do not rethrow on first error
buildProvider.ThrowOnFirstParseError = false;
// Get the language (causes the file to be parsed)
CompilerType compilerType = buildProvider.CodeCompilerType;
// compilerType could be null in the no-compile case (VSWhidbey 221749)
if (compilerType == null)
{
codeDomProviderType = null;
compilerParameters = null;
return(null);
}
// Return the provider type and compiler params
codeDomProviderType = compilerType.CodeDomProviderType;
compilerParameters = compilerType.CompilerParameters;
IAssemblyDependencyParser parser = buildProvider.AssemblyDependencyParser;
// Add all the assemblies that the page depends on (e.g. user controls)
if (parser != null && parser.AssemblyDependencies != null)
{
Util.AddAssembliesToStringCollection(parser.AssemblyDependencies,
compilerParameters.ReferencedAssemblies);
}
// Make any fix up adjustments to the CompilerParameters to work around some issues
AssemblyBuilder.FixUpCompilerParameters(compConfig, codeDomProviderType, compilerParameters);
return(buildProvider);
}
private void FixupReferencedAssemblies(VirtualPath virtualPath, CompilerParameters compilerParameters)
{
Util.AddAssembliesToStringCollection(BuildManager.GetReferencedAssemblies(MTConfigUtil.GetCompilationConfig(virtualPath)), compilerParameters.ReferencedAssemblies);
}
