/// <summary>
/// Creates an Assembly from DynamicAssembly definition
/// </summary>
/// <param name="assemblyDefinition">assembly description</param>
/// <returns>result with assembly or error info</returns>
public static CompileResult CompileDynamicAssembly(DynamicAssembly assemblyDefinition)
{
CodeDomProvider codeDomProvider = CodeDomProvider.CreateProvider("CSharp");
CompilerParameters compilerParameters = new CompilerParameters();
compilerParameters.CompilerOptions = "/t:library /platform:anycpu /lib:" + "\"" +
(String.IsNullOrWhiteSpace(assemblyDefinition.ReferencesPath) ? GetCurrentPath() : assemblyDefinition.ReferencesPath) + "\"";
compilerParameters.IncludeDebugInformation = false;
//compilerParameters.OutputAssembly = assemblyDefinition.Name;
compilerParameters.GenerateInMemory = true;
compilerParameters.GenerateExecutable = false;
foreach (var item in assemblyDefinition.References)
{
compilerParameters.ReferencedAssemblies.Add(item);
}
List <string> codeModules = new List <string>();
foreach (DynamicClass item in assemblyDefinition.Classes)
{
string code = DynamicClass.Template;
code = DynamicClass.AddUsingsToTemplate(item, code);
code = DynamicClass.AddInterfacesToTemplate(item, code);
code = DynamicClass.AddNamespaceToTemplate(String.IsNullOrWhiteSpace(item.Namespace) ? assemblyDefinition.Name : item.Namespace, code);
code = DynamicClass.AddNameToTemplate(item, code);
code = DynamicClass.AddPropertiesToTemplate(item, code);
code = DynamicClass.AddMethodsToTemplate(item, code);
codeModules.Add(code);
}
foreach (DynamicCustomClass item in assemblyDefinition.CustomClasses)
{
codeModules.Add(item.Code);
}
// we dont allow empty class definitions(fun fact: its okay for the c# compiler)
foreach (DynamicCustomClass item in assemblyDefinition.CustomClasses)
{
if (String.IsNullOrWhiteSpace(item.Code))
{
CompilerErrorCollection collection = new CompilerErrorCollection();
CompilerError customError = new CompilerError("CustomClass", 0, 0, "Custom", "Unable to compile an empty code module.");
collection.Add(customError);
return(new CompileResult(codeModules.ToArray(), collection, null));
}
}
CompilerResults compilerResults = codeDomProvider.CompileAssemblyFromSource(compilerParameters, codeModules.ToArray());
codeDomProvider.Dispose();
return(new CompileResult(codeModules.ToArray(), compilerResults.Errors, compilerResults.Errors.Count > 0 ? null : compilerResults.CompiledAssembly));
}
/// <summary>
/// Returns a string that represents the instance
/// </summary>
/// <returns>System.String</returns>
public override string ToString()
{
string code = DynamicClass.Template;
code = DynamicClass.AddUsingsToTemplate(this, code);
code = DynamicClass.AddInterfacesToTemplate(this, code);
code = DynamicClass.AddNamespaceToTemplate(String.IsNullOrWhiteSpace(Namespace) ? Parent.Name : Namespace, code);
code = DynamicClass.AddNameToTemplate(this, code);
code = DynamicClass.AddPropertiesToTemplate(this, code);
code = DynamicClass.AddMethodsToTemplate(this, code);
return(code);
}
/// <summary>
/// Generate all methods from DynamicClass instance in a code template
/// </summary>
/// <param name="dynamicClass">DynamicClass definition</param>
/// <param name="template">Source code template</param>
/// <returns>Updated code template</returns>
internal static string AddMethodsToTemplate(DynamicClass dynamicClass, string template)
{
StringBuilder stringBuilderMethods = new StringBuilder();
foreach (var item in dynamicClass.Methods)
{
string methodTemplate = CreateMethodTemplate(item);
methodTemplate = methodTemplate.Replace("%Code%", item.MethodCode);
stringBuilderMethods.Append(methodTemplate);
}
return(template.Replace("%Methods%", stringBuilderMethods.ToString()));
}
/// <summary>
/// Generate all interface implementations from DynamicClass instance in a code template
/// </summary>
/// <param name="dynamicClass">DynamicClass definition</param>
/// <param name="template">Source code template</param>
/// <returns>Updated code template</returns>
internal static string AddInterfacesToTemplate(DynamicClass dynamicClass, string template)
{
if (dynamicClass.Interfaces.Count == 0)
{
return(template.Replace("%Interfaces%", ""));
}
string interfaceString = ":";
foreach (var item in dynamicClass.Interfaces)
{
interfaceString += item.Name + ",";
}
interfaceString = interfaceString.Substring(0, interfaceString.Length - 1);
return(template.Replace("%Interfaces%", interfaceString));
}
/// <summary>
/// Generate the name from DynamicClass instance in a code template
/// </summary>
/// <param name="dynamicClass">DynamicClass definition</param>
/// <param name="template">Source code template</param>
/// <returns>Updated code template</returns>
internal static string AddNameToTemplate(DynamicClass dynamicClass, string template)
{
return(template.Replace("%Name%", dynamicClass.Name));
}
/// <summary>
/// Generate all usings from DynamicClass instance in a code template
/// </summary>
/// <param name="dynamicClass">DynamicClass definition</param>
/// <param name="template">Source code template</param>
/// <returns>Updated code template</returns>
internal static string AddUsingsToTemplate(DynamicClass dynamicClass, string template)
{
StringBuilder stringBuilder = new StringBuilder();
foreach (var item in dynamicClass.Usings)
stringBuilder.Append(String.Format("using {0};{1}", item, Environment.NewLine));
return template.Replace("%Usings%", stringBuilder.ToString());
}
/// <summary>
/// Generate all methods from DynamicClass instance in a code template
/// </summary>
/// <param name="dynamicClass">DynamicClass definition</param>
/// <param name="template">Source code template</param>
/// <returns>Updated code template</returns>
internal static string AddMethodsToTemplate(DynamicClass dynamicClass, string template)
{
StringBuilder stringBuilderMethods = new StringBuilder();
foreach (var item in dynamicClass.Methods)
{
string methodTemplate = CreateMethodTemplate(item);
methodTemplate = methodTemplate.Replace("%Code%", item.MethodCode);
stringBuilderMethods.Append(methodTemplate);
}
return template.Replace("%Methods%", stringBuilderMethods.ToString());
}
/// <summary>
/// Generate all properties from DynamicClass instance in a code template
/// </summary>
/// <param name="dynamicClass">DynamicClass definition</param>
/// <param name="template">Source code template</param>
/// <returns>Updated code template</returns>
internal static string AddPropertiesToTemplate(DynamicClass dynamicClass, string template)
{
StringBuilder stringBuilderProperties = new StringBuilder();
StringBuilder stringBuilderParams = new StringBuilder();
StringBuilder stringBuilderSet = new StringBuilder();
StringBuilder stringBuilderSet2 = new StringBuilder();
int i = 0;
foreach (var item in dynamicClass.Properties)
{
if (i > 0)
{
stringBuilderParams.Append(",");
stringBuilderSet2.Append(",");
}
string[] splitArray = item.ToString().Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries);
stringBuilderProperties.Append(String.Format("\t\tinternal {0} {1}{{get; set;}}{2}", splitArray[0], splitArray[1], Environment.NewLine));
stringBuilderParams.Append(String.Format("{0} param{1}", splitArray[0], i));
stringBuilderSet.Append(String.Format("\t\t\t{0}=param{1};{2}", splitArray[1], i, Environment.NewLine));
stringBuilderSet2.Append(String.Format("param{0}", i));
i++;
}
template = template.Replace("%Properties%", stringBuilderProperties.ToString());
template = template.Replace("%InitializeParams%", stringBuilderParams.ToString());
template = template.Replace("%ParamsToProperties%", stringBuilderSet.ToString());
template = template.Replace("%InitializeParams2%", stringBuilderSet2.ToString());
return template;
}
/// <summary>
/// Generate all interface implementations from DynamicClass instance in a code template
/// </summary>
/// <param name="dynamicClass">DynamicClass definition</param>
/// <param name="template">Source code template</param>
/// <returns>Updated code template</returns>
internal static string AddInterfacesToTemplate(DynamicClass dynamicClass, string template)
{
if (dynamicClass.Interfaces.Count == 0)
return template.Replace("%Interfaces%", "");
string interfaceString = ":";
foreach (var item in dynamicClass.Interfaces)
interfaceString += item.Name + ",";
interfaceString = interfaceString.Substring(0, interfaceString.Length - 1);
return template.Replace("%Interfaces%", interfaceString);
}
/// <summary>
/// Generate the name from DynamicClass instance in a code template
/// </summary>
/// <param name="dynamicClass">DynamicClass definition</param>
/// <param name="template">Source code template</param>
/// <returns>Updated code template</returns>
internal static string AddNameToTemplate(DynamicClass dynamicClass, string template)
{
return template.Replace("%Name%", dynamicClass.Name);
}
