public static string GenerateCode(CodeObject codeObj)
{
var provider = new CSharpCodeProvider();
using (var stream = new MemoryStream())
using (var writer = new StreamWriter(stream))
{
if (codeObj is CodeCompileUnit)
{
provider.GenerateCodeFromCompileUnit(codeObj as CodeCompileUnit, writer, null);
}
else if (codeObj is CodeExpression)
{
provider.GenerateCodeFromExpression(codeObj as CodeExpression, writer, null);
}
else if (codeObj is CodeStatement)
{
provider.GenerateCodeFromStatement(codeObj as CodeStatement, writer, null);
}
else if (codeObj is CodeTypeMember)
{
provider.GenerateCodeFromMember(codeObj as CodeTypeMember, writer, null);
}
else if (codeObj is CodeNamespace)
{
provider.GenerateCodeFromNamespace(codeObj as CodeNamespace, writer, null);
}
else
{
throw new InvalidOperationException();
}
writer.Flush();
stream.Position = 0;
using (var reader = new StreamReader(stream))
{
return reader.ReadToEnd();
}
}
}
string GenerateInitializeComponents(CodeMemberMethod codeMethod, string indentation, string newline)
{
var writer = new StringWriter();
writer.NewLine = newline;
var options = new CodeGeneratorOptions();
options.IndentString = SD.EditorControlService.GlobalOptions.IndentationString;
var codeProvider = new CSharpCodeProvider();
foreach (CodeStatement statement in codeMethod.Statements) {
writer.Write(indentation);
// indentation isn't generated when calling GenerateCodeFromStatement
writer.Write(options.IndentString);
try {
codeProvider.GenerateCodeFromStatement(statement, writer, options);
} catch (Exception e) {
writer.WriteLine("// TODO: Error while generating statement : " + e.Message);
SD.Log.Error(e);
}
}
return writer.ToString();
}
public void CompileExpressions()
{
var csharp = new CSharpCodeProvider();
var w = new StreamWriter(new FileStream("compiled.cs", FileMode.Create));
var c = new CodeCommentStatement("This file is dynamically generated");
csharp.GenerateCodeFromStatement(c, w, null);
var namespc = new CodeNamespace("Melon.Reports");
namespc.Imports.Add(new CodeNamespaceImport("System"));
namespc.Imports.Add(new CodeNamespaceImport("System.Collections.Generic"));
namespc.Imports.Add(new CodeNamespaceImport("Melon.Reports.Objects"));
var ExpressionCalculatorClass = new CodeTypeDeclaration("ExpressionCalculator")
{
IsClass = true,
TypeAttributes = TypeAttributes.Public
};
namespc.Types.Add(ExpressionCalculatorClass);
ExpressionCalculatorClass.BaseTypes.Add("Melon.Reports.AbstractCalculator");
ExpressionCalculatorClass.Members.Add(createConstructor());
foreach (var field in fields)
{
var f = new CodeMemberField(field.Type, field.Name) { Attributes = MemberAttributes.Public };
ExpressionCalculatorClass.Members.Add(f);
}
//especial variables
ExpressionCalculatorClass.Members.Add(new CodeMemberField(typeof (int), "GlobalRecordCount") {Attributes = MemberAttributes.Public});
ExpressionCalculatorClass.Members.Add(new CodeMemberField(typeof (int), "PageNumber") {Attributes = MemberAttributes.Public});
/*
* public object EvaluateVariableExpression(int hashcode){
* .....
* }
*/
var dynaCode = new StringBuilder("Object o = null; \n switch(i){\n");
foreach (var variable in variables.Values)
{
dynaCode.Append(Case(variable));
ExpressionCalculatorClass.Members.Add(createProperty(variable));
}
dynaCode.Append(" }\nreturn o");
ExpressionCalculatorClass.Members.Add(createMethod(dynaCode, "EvaluateVariableExpression"));
/* add expressions using the hash trick
*
* public virtual object EvaluateExpression(int i) {
* Object o = null;
* switch(i){
* case 13:
* o = (System.String)System.DateTime.Today.ToShortDateString();
* break;
* case ........
* ..
* }
* }
*/
dynaCode = new StringBuilder("Object o = null; \n switch(i){\n");
foreach (var ex in expressions)
{
dynaCode.Append(" case " + ex.GetHashCode() + ":\n" +
" o = " + ex.Content + ";\n" +
" break;\n");
}
dynaCode.Append(" }\n return o");
ExpressionCalculatorClass.Members.Add(createMethod2(dynaCode, "EvaluateExpression"));
var cu = new CodeCompileUnit();
cu.Namespaces.Add(namespc);
csharp.GenerateCodeFromNamespace(namespc, w, null);
w.Close();
var thisAsembly = Assembly.GetAssembly(GetType()).Location;
//compilation
var compparams = new CompilerParameters(new[] {"mscorlib.dll", thisAsembly}) {GenerateInMemory = true};
var ErrorMsg = "";
var cscompiler = csharp.CreateCompiler();
var compresult = cscompiler.CompileAssemblyFromDom(compparams, cu);
if (compresult == null || compresult.Errors.Count > 0)
{
if (compresult != null)
if (compresult.Errors.Count > 0)
{
foreach (CompilerError CompErr in compresult.Errors)
{
ErrorMsg = ErrorMsg +
"Line number " + CompErr.Line +
", Error Number: " + CompErr.ErrorNumber +
", '" + CompErr.ErrorText + ";" +
Environment.NewLine + Environment.NewLine;
}
}
throw new Exception(ErrorMsg);
}
object o = compresult.CompiledAssembly.CreateInstance("Melon.Reports.ExpressionCalculator",
true, BindingFlags.CreateInstance, null, new object[] {variables},
null, null);
Console.WriteLine(compresult.CompiledAssembly.Location);
if (o == null)
{
throw new ApplicationException(".NET implementation is broken.");
}
var test = compresult.CompiledAssembly.GetType("Melon.Reports.ExpressionCalculator");
compiledExpressions = o;
compiledType = test;
}
/// <summary>
/// Generates CSharp text from a statement and writes it to a text writer with the given options.
/// </summary>
/// <param name="statement">The statement to generate text from.</param>
/// <param name="writer">The text writer to write to.</param>
/// <param name="options">The generation options.</param>
public static void GenerateCSharpTo(this CodeStatement statement, TextWriter writer, CodeGeneratorOptions options)
{
using (var provider = new CSharpCodeProvider())
{
provider.GenerateCodeFromStatement(statement, writer, options);
}
}
//used for anonymous delegates. No codedom for those. Could change to actual delegates. Not idea but like anonymouse delagates
private string GenerateCodeFromStatement(CodeStatement statement)
{
string code = string.Empty;
using (CSharpCodeProvider csc = new CSharpCodeProvider())
using (StringWriter sw = new StringWriter())
{
csc.GenerateCodeFromStatement(statement, sw, new CodeGeneratorOptions());
code = sw.ToString();
}
return code;
}
