public CompilerParameters ToCompilerParameters(string outputAssembly)
{
CompilerParameters cp = new CompilerParameters
{
GenerateExecutable = false,
GenerateInMemory = false,
WarningLevel = WarningLevel,
TreatWarningsAsErrors = TreatWarningsAsErrors,
IncludeDebugInformation = IncludeDebugInformation,
CompilerOptions = CompilerOptions,
OutputAssembly = outputAssembly,
CoreAssemblyFileName = CoreAssemblyFileName,
Win32Resource = Win32Resource
};
if (LinkedResources != null && LinkedResources.Count > 0)
{
cp.LinkedResources.AddRange(LinkedResources.ToArray());
}
if (EmbeddedResources != null && EmbeddedResources.Count > 0)
{
cp.EmbeddedResources.AddRange(EmbeddedResources.ToArray());
}
if (ReferencedAssemblies != null && ReferencedAssemblies.Count > 0)
{
cp.ReferencedAssemblies.AddRange(ReferencedAssemblies.ToArray());
}
return(cp);
}
/// <summary>
/// Stock implementation of RenderTemplate that doesn't allow for
/// any sort of assembly caching. Instead it creates and re-renders
/// templates read from the reader each time.
///
/// Custom implementations of RenderTemplate should be created that
/// allow for caching by examing a filename or string hash to determine
/// whether a template needs to be re-generated and compiled before
/// rendering.
/// </summary>
/// <param name="reader">TextReader that points at the template to compile</param>
/// <param name="context">Optional context to pass to template</param>
/// <param name="writer">TextReader passed in that receives output</param>
/// <returns></returns>
public bool RenderTemplate(TextReader reader, object context, TextWriter writer)
{
var assemblyId = Engine.ParseAndCompileTemplate(ReferencedAssemblies.ToArray(), reader);
if (assemblyId == null)
{
ErrorMessage = Engine.ErrorMessage;
return(false);
}
return(RenderTemplateFromAssembly(assemblyId, context, writer));
}
/// <summary>
/// Internally tries to retrieve a previously compiled template from cache
/// if not found compiles a template into an assembly
/// always returns an assembly id as a string.
/// </summary>
/// <param name="templateText">The text to parse</param>
/// <returns>assembly id as a string or null on error</returns>
protected virtual CompiledAssemblyItem GetAssemblyFromStringAndCache(string templateText)
{
var hash = templateText.GetHashCode();
CompiledAssemblyItem item;
LoadedAssemblies.TryGetValue(hash, out item);
string assemblyId = null;
// Check for cached instance
if (item != null)
{
assemblyId = item.AssemblyId;
}
else
{
item = new CompiledAssemblyItem();
}
// No cached instance - create assembly and cache
if (assemblyId == null)
{
var safeClassName = GetSafeClassName(null);
using (var reader = new StringReader(templateText))
{
var refAssemblies = ReferencedAssemblies.ToArray();
assemblyId = Engine.ParseAndCompileTemplate(refAssemblies, reader, GeneratedNamespace, safeClassName);
}
if (assemblyId == null)
{
ErrorMessage = Engine.ErrorMessage;
return(null);
}
item.AssemblyId = assemblyId;
item.CompileTimeUtc = DateTime.UtcNow;
item.SafeClassName = safeClassName;
LoadedAssemblies[hash] = item;
}
return(item);
}
public bool Run(string filename, ref ScriptContext context, out CompilerErrorCollection compilationErrors)
{
string sourceCode = File.ReadAllText(filename);
bool compilationSucceeded = true;
compilationErrors = new CompilerErrorCollection( );
CSharpCodeProvider provider = new CSharpCodeProvider( );
// Build the parameters for source compilation.
CompilerParameters cp = new CompilerParameters( );
cp.TreatWarningsAsErrors = false;
// Add assembly references.
cp.ReferencedAssemblies.AddRange(DEFAULT_ASSEMBLIES);
cp.ReferencedAssemblies.AddRange(ReferencedAssemblies.ToArray( ));
cp.GenerateInMemory = true;
// Add using statements.
StringBuilder script = new StringBuilder( );
foreach (var usingNamespace in DEFAULT_NAMESPACES)
{
script.AppendFormat("using {0};\n", usingNamespace);
}
foreach (var additionalUsingNamespace in UsingNamespaces)
{
script.AppendFormat("using {0};\n", additionalUsingNamespace);
}
// Create the script.
script.AppendLine( );
script.AppendLine("namespace BlizzetaZero.Kernel.Scripts");
script.AppendLine("{");
script.AppendLine(sourceCode);
script.AppendLine("}");
// Invoke compilation.
CompilerResults cr = provider.CompileAssemblyFromSource(cp, script.ToString( ));
if (cr.Errors.Count > 0)
{
foreach (CompilerError ce in cr.Errors)
{
#if DEBUG
Console.WriteLine(" {0}", ce.ToString( ));
Console.WriteLine( );
#endif
ce.Line = ce.Line - 13;
compilationErrors.Add(ce);
if (!ce.IsWarning)
{
compilationSucceeded = false;
}
}
}
if (compilationSucceeded)
{
var ass = cr.CompiledAssembly;
var execInstance = ass.CreateInstance("BlizzetaZero.Kernel.Scripts.Script");
var type = execInstance.GetType( );
var methodInfo = type.GetMethod("Load");
// Execute the code.
methodInfo.Invoke(execInstance, new object[] { context });
}
return(compilationSucceeded);
}
public ScriptObjects GetInterface(string filename)
{
if (!filename.EndsWith(".cs"))
{
// Filename != C# Source
return(null);
}
string sourceCode = File.ReadAllText(filename);
bool compilationSucceeded = true;
CSharpCodeProvider provider = new CSharpCodeProvider( );
// Build the parameters for source compilation.
CompilerParameters cp = new CompilerParameters( );
cp.TreatWarningsAsErrors = false;
// Add assembly references.
cp.ReferencedAssemblies.AddRange(DEFAULT_ASSEMBLIES);
cp.ReferencedAssemblies.AddRange(ReferencedAssemblies.ToArray( ));
cp.GenerateInMemory = true;
// Add using statements.
StringBuilder script = new StringBuilder( );
foreach (var usingNamespace in DEFAULT_NAMESPACES)
{
script.AppendFormat("using {0};\n", usingNamespace);
}
foreach (var additionalUsingNamespace in UsingNamespaces)
{
script.AppendFormat("using {0};\n", additionalUsingNamespace);
}
// Create the script.
script.AppendLine("namespace BlizzetaZero.Kernel.Scripts");
script.AppendLine("{");
script.AppendLine(sourceCode);
script.AppendLine("}");
// Invoke compilation.
CompilerResults cr = provider.CompileAssemblyFromSource(cp, script.ToString( ));
if (cr.Errors.Count > 0)
{
foreach (var error in cr.Errors)
{
Console.WriteLine(error);
}
compilationSucceeded = false;
}
if (compilationSucceeded)
{
var ass = cr.CompiledAssembly;
var execInstance = ass.CreateInstance("BlizzetaZero.Kernel.Scripts.Script");
var po = GetProperties(execInstance);
return(new ScriptObjects(
( string )po["get_Name"],
( string )po["get_Usage"],
( string )po["get_Help"],
( string )po["get_More"],
( string )po["get_Version"],
( Permissions )po["get_Permission"],
( bool )po["get_IsPublic"]));
}
return(null);
}
