public static System.Reflection.Assembly GenerateCode(ITextTemplatingEngineHost host, ParsedTemplate pt,
TemplateSettings settings, CodeCompileUnit ccu)
{
CompilerParameters pars = new CompilerParameters ();
pars.GenerateExecutable = false;
if (settings.Debug) {
pars.GenerateInMemory = false;
pars.IncludeDebugInformation = true;
pars.TempFiles.KeepFiles = true;
} else {
pars.GenerateInMemory = true;
pars.IncludeDebugInformation = false;
}
//resolve and add assembly references
HashSet<string> assemblies = new HashSet<string> ();
assemblies.UnionWith (settings.Assemblies);
assemblies.UnionWith (host.StandardAssemblyReferences);
foreach (string assem in assemblies) {
string resolvedAssem = host.ResolveAssemblyReference (assem);
if (!String.IsNullOrEmpty (resolvedAssem)) {
pars.ReferencedAssemblies.Add (resolvedAssem);
} else {
pt.LogError ("Could not resolve assembly reference '" + assem + "'");
return null;
}
}
CompilerResults results = settings.Provider.CompileAssemblyFromDom (pars, ccu);
pt.Errors.AddRange (results.Errors);
if (pt.Errors.HasErrors)
return null;
return results.CompiledAssembly;
}
Assembly ResolveReferencedAssemblies(object sender, ResolveEventArgs args)
{
if (loadedAeesmblies.TryGetValue(args.Name, out var assembly))
{
return(assembly);
}
AssemblyName asmName = new AssemblyName(args.Name);
foreach (var asmFile in assemblyFiles)
{
if (asmName.Name == System.IO.Path.GetFileNameWithoutExtension(asmFile))
{
return(Assembly.LoadFrom(asmFile));
}
}
var path = host.ResolveAssemblyReference(asmName.Name + ".dll");
if (System.IO.File.Exists(path))
{
return(Assembly.LoadFrom(path));
}
var currAssemblies = AppDomain.CurrentDomain.GetAssemblies();
assembly = currAssemblies.FirstOrDefault(o => o.GetName().FullName == args.Name);
return(assembly);
}
public static List <Type> GetDefinedTypesOnAllAssemblies(ITextTemplatingEngineHost host)
{
string targetDir = host.ResolveAssemblyReference("$(TargetDir)");
//Directory.SetCurrentDirectory(targetDir);
var list = new List <Type>();
DirectoryInfo d = new DirectoryInfo(targetDir);
Append("*.dll", d, ref list);
Append("*.exe", d, ref list);
return(list);
}
public static List<Type> GetDefinedTypesOnAllAssemblies(ITextTemplatingEngineHost host)
{
string targetDir = host.ResolveAssemblyReference("$(TargetDir)");
//Directory.SetCurrentDirectory(targetDir);
var list = new List<Type>();
DirectoryInfo d = new DirectoryInfo(targetDir);
Append("*.dll", d,ref list);
Append("*.exe", d, ref list);
return list;
}
public static System.Reflection.Assembly GenerateCode(ITextTemplatingEngineHost host, ParsedTemplate pt,
TemplateSettings settings, CodeCompileUnit ccu)
{
CompilerParameters pars = new CompilerParameters();
pars.GenerateExecutable = false;
if (settings.Debug)
{
pars.GenerateInMemory = false;
pars.IncludeDebugInformation = true;
pars.TempFiles.KeepFiles = true;
}
else
{
pars.GenerateInMemory = true;
pars.IncludeDebugInformation = false;
}
//resolve and add assembly references
var assemblies = new Dictionary <string, object>();
UnionWith(assemblies, settings.Assemblies);
UnionWith(assemblies, host.StandardAssemblyReferences);
foreach (string assem in assemblies.Keys)
{
string resolvedAssem = host.ResolveAssemblyReference(assem);
if (!String.IsNullOrEmpty(resolvedAssem))
{
pars.ReferencedAssemblies.Add(resolvedAssem);
}
else
{
pt.LogError("Could not resolve assembly reference '" + assem + "'");
return(null);
}
}
CompilerResults results = settings.Provider.CompileAssemblyFromDom(pars, ccu);
pt.Errors.AddRange(results.Errors);
if (pt.Errors.HasErrors)
{
return(null);
}
return(results.CompiledAssembly);
}
Assembly ResolveReferencedAssemblies(object sender, ResolveEventArgs args)
{
AssemblyName asmName = new AssemblyName(args.Name);
foreach (var asmFile in assemblyFiles)
{
if (asmName.Name == System.IO.Path.GetFileNameWithoutExtension(asmFile))
{
return(Assembly.LoadFrom(asmFile));
}
}
var path = host.ResolveAssemblyReference(asmName.Name + ".dll");
if (System.IO.File.Exists(path))
{
return(Assembly.LoadFrom(path));
}
return(null);
}
protected override Assembly Load(AssemblyName assemblyName)
{
// CodeDom and TextTemplating MUST come from the same context as the host as we need to be able to reflect and cast
// this is an issue with MSBuild which loads tasks in their own load contexts
if (assemblyName.Name == codeDomAsmName.Name)
{
return(typeof(CompilerErrorCollection).Assembly);
}
if (assemblyName.Name == textTemplatingAsmName.Name)
{
return(typeof(TemplateGenerator).Assembly);
}
// the host may be a custom host, and must also be in the same context
if (assemblyName.Name == hostAsmName.Name)
{
return(hostAssembly);
}
foreach (var asmFile in templateAssemblyFiles)
{
if (assemblyName.Name == Path.GetFileNameWithoutExtension(asmFile))
{
return(LoadFromAssemblyPath(asmFile));
}
}
var path = host.ResolveAssemblyReference(assemblyName.Name + ".dll");
if (File.Exists(path))
{
return(LoadFromAssemblyPath(path));
}
return(null);
}
/// <summary>
/// Resolves the full path of the assembly and combines it with the assembly reference.
/// </summary>
public string ResolveAssemblyReference(string assemblyReference)
{
string path = Path.Combine(this.binPath, assemblyReference);
// Check if the DLL exists. Otherwise, override the binPath and let it use the
// current AppDomain information.
if (File.Exists(path))
{
return(path);
}
// No resolution at all.
if (File.Exists(assemblyReference))
{
return(assemblyReference);
}
// Probe public and private asms folders.
path = Path.Combine(
Path.Combine(
AppDomain.CurrentDomain.SetupInformation.ApplicationBase, "PublicAssemblies"),
assemblyReference);
if (File.Exists(path))
{
return(path);
}
path = Path.Combine(
Path.Combine(
AppDomain.CurrentDomain.SetupInformation.ApplicationBase, "PrivateAssemblies"),
assemblyReference);
if (File.Exists(path))
{
return(path);
}
if (String.IsNullOrEmpty(AppDomain.CurrentDomain.SetupInformation.PrivateBinPath) == false)
{
// Look in private probe paths.
string[] privateBins = AppDomain.CurrentDomain.SetupInformation.PrivateBinPath.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
foreach (string privateBin in privateBins)
{
path = Path.Combine(
Path.Combine(
AppDomain.CurrentDomain.SetupInformation.ApplicationBase,
privateBin),
assemblyReference);
if (File.Exists(path))
{
return(path);
}
}
}
if (SysHost != null)
{
return(SysHost.ResolveAssemblyReference(assemblyReference));
}
// Will fail at template compilation time.
return(assemblyReference);
}
