public void Container_should_ignore_specified_assemblies()
{
// Given
var ass = CSharpCodeProvider
.CreateProvider("CSharp")
.CompileAssemblyFromSource(
new CompilerParameters
{
GenerateInMemory = true,
GenerateExecutable = false,
IncludeDebugInformation = false,
OutputAssembly = "TestAssembly.dll"
},
new[]
{
"public interface IWillNotBeResolved { int i { get; set; } }",
"public class WillNotBeResolved : IWillNotBeResolved { public int i { get; set; } }"
})
.CompiledAssembly;
// When
this.bootstrapper.Initialise();
// Then
Assert.Throws <TinyIoCResolutionException>(
() => this.bootstrapper.Container.Resolve(ass.GetType("IWillNotBeResolved")));
}
public void RunMacro(string assemblyName)
{
if (!assemblyName.EndsWith("cs"))
{
System.Windows.Forms.MessageBox.Show("Macros must be written on C# and it have an .cs extension. ");
return;
}
StreamReader reader = new StreamReader(assemblyName, Encoding.Default);
string macroCode = reader.ReadToEnd();
reader.Close();
var csProv = CSharpCodeProvider.CreateProvider("CSharp");
CompilerParameters csParams = new CompilerParameters();
csParams.ReferencedAssemblies.Add("system.dll");
csParams.GenerateExecutable = true;
csParams.GenerateInMemory = false;
csParams.OutputAssembly = "output.exe";
CompilerResults compResults = csProv.CompileAssemblyFromSource(csParams, macroCode);
if (compResults.Errors.Count > 0)
{
foreach (var er in compResults.Errors)
{
System.Windows.Forms.MessageBox.Show(er.ToString());
}
}
else
{
Process.Start("output.exe", "-command");
}
}
Assembly CompileRuleProxy()
{
var assembly = Assembly.GetExecutingAssembly();
var csharpCodeProvider = CSharpCodeProvider.CreateProvider("CSharp");
var compilerParameters = new CompilerParameters {
GenerateInMemory = true,
GenerateExecutable = false,
IncludeDebugInformation = false,
ReferencedAssemblies = { assembly.Location }
};
string source = string.Format(GetRuleProxySource(assembly), ruleProxyPartial);
var compilerResults = csharpCodeProvider.CompileAssemblyFromSource(compilerParameters, source);
if (compilerResults.Errors.Count > 0)
{
// TODO: Error Handling when compilation fails
return(null);
}
else
{
return(compilerResults.CompiledAssembly);
}
}
//https://support.microsoft.com/en-us/help/304655/how-to-programmatically-compile-code-using-c-compiler
public void CompileCodeProgrammaticallyTest1_BeforeCSharp6()
{
//V0 : avant c# 6
/* //Obsolete way
* CSharpCodeProvider codeProvider = new CSharpCodeProvider();
* ICodeCompiler icc = codeProvider.CreateCompiler();
*/
CodeDomProvider compiler = CSharpCodeProvider.CreateProvider("CSharp");
CompilerParameters parameters = new CompilerParameters();
//parameters.GenerateExecutable = true;
parameters.OutputAssembly = @"c:\tmp\helloWorld-compiled-programmatically.exe";
parameters.GenerateExecutable = true;
//parameters.CompilerOptions = "-langversion:6";
parameters.IncludeDebugInformation = true;
parameters.GenerateInMemory = false;
parameters.TreatWarningsAsErrors = false;
parameters.WarningLevel = 3;
parameters.ReferencedAssemblies.Add("System.Runtime.dll");
CompilerResults results = compiler.CompileAssemblyFromSource(parameters, SOURCE_STRING_C_SHARP_5);
foreach (CompilerError error in results.Errors)
{
Console.WriteLine(error);
}
Check.That(results.PathToAssembly).IsEqualTo(@"c:\tmp\helloWorld-compiled-programmatically.exe");
Check.That(results.Errors).CountIs(0);
Check.That(results.Errors.HasErrors).IsFalse();
Check.That(results.Errors.HasWarnings).IsFalse();
Check.That(results.NativeCompilerReturnValue).IsEqualTo(0);
}
public IRule CompileAndCreateDebugVisitor()
{
var sourceCode = CreateDebugVisitorSourceCode();
var provider = CSharpCodeProvider.CreateProvider("CSharp");
var compilerParameters = new CompilerParameters();
compilerParameters.GenerateInMemory = true;
compilerParameters.GenerateExecutable = false;
compilerParameters.CompilerOptions = "/optimize";
compilerParameters.IncludeDebugInformation = true;
compilerParameters.ReferencedAssemblies.Add("Microsoft.SqlServer.TransactSql.ScriptDom.dll");
compilerParameters.ReferencedAssemblies.Add("TransactSqlAnalyzer.Rules.Common.dll");
var compileResult = provider.CompileAssemblyFromSource(compilerParameters, sourceCode);
if (compileResult.Errors.HasErrors)
{
var errorMessage = new StringBuilder();
foreach (var error in compileResult.Errors)
{
errorMessage.AppendLine(error.ToString());
}
throw new InvalidOperationException(errorMessage.ToString());
}
//var module = assembly.CompiledAssembly.GetModules()[0];
var debugVisitorType = compileResult.CompiledAssembly.GetType("TransactSqlAnalyzer.Rules.Common.Utils.GeneratedDebugVisitorRule");
var debugVisitorInstance = debugVisitorType.GetConstructor(Type.EmptyTypes).Invoke(null);
IRule debugvisitor = (IRule)debugVisitorInstance;
return(debugvisitor);
}
public override double Process(string input)
{
string expr = null;
if (!ValidExpression(input, out expr))
{
return(0);
}
CompilerParameters parms = new CompilerParameters()
{
GenerateExecutable = false,
GenerateInMemory = true,
IncludeDebugInformation = false
};
CodeDomProvider compiler = CSharpCodeProvider.CreateProvider("CSharp");
CompilerResults res = compiler.CompileAssemblyFromSource(parms, @"public static class Func { public static double Process() { return " + expr + ";} }");
if (res.Errors.HasErrors)
{
throw new InvalidOperationException("Expression has a syntax error.");
}
Assembly assembly = res.CompiledAssembly;
MethodInfo mi = assembly.GetType("Func").GetMethod("Process");
return((double)mi.Invoke(null, null));
}
private static Type Compile(string code)
{
var param = new CompilerParameters();
param.GenerateExecutable = false;
param.GenerateInMemory = true;
param.IncludeDebugInformation = false;
param.ReferencedAssemblies.Add("StructureMap.AutoMocking.dll");
param.ReferencedAssemblies.Add("StructureMap.dll");
param.ReferencedAssemblies.Add("System.Xml.Linq.dll");
param.ReferencedAssemblies.Add("System.Core.dll");
var compiler = CSharpCodeProvider.CreateProvider("CSharp");
var result = compiler.CompileAssemblyFromSource(param, code);
if (result.Errors.Count != 0)
{
throw new Exception("Could not compile");
}
var assembly = result.CompiledAssembly;
var assembledType =
assembly.GetTypes().FirstOrDefault(
x => x.ContainsGenericParameters && x.Name.Contains("NSubstituteAutoMocker"));
return(assembledType);
}
private Func <string, string> CompileMethod(string method)
{
CodeDomProvider provider = CSharpCodeProvider.CreateProvider("c#");
CompilerParameters options = new CompilerParameters();
options.GenerateInMemory = true;
options.CompilerOptions = "/optimize";
string assemblyContainingNotDynamicClass = Assembly.GetExecutingAssembly().Location;
options.ReferencedAssemblies.Add(assemblyContainingNotDynamicClass);
CompilerResults results = provider.CompileAssemblyFromSource(options, new[] { method });
Assembly assembly = null;
if (!results.Errors.HasErrors)
{
assembly = results.CompiledAssembly;
}
else
{
string errorMessage = string.Format("Error generating method: {0}" + Environment.NewLine + "Error message: {1}", method, results.Errors[0].ErrorText);
throw new Exception(errorMessage);
}
Type type = assembly.GetType("DynamicClass");
MethodInfo methodInfo = type.GetMethod("EvaluateDynamic");
return((Func <string, string>)Delegate.CreateDelegate(typeof(Func <string, string>), methodInfo));
}
public override int CompileCode(string dataFolder)
{
string methodBody = File.ReadAllText(dataFolder + ArcDirectoryName + FileName);
string executableCode =
@"
using System;
using System.IO;
using MultiArc_Compiler;
public class DynamicClass" + name + @"
{
" + methodBody + @"
}";
var provider = CSharpCodeProvider.CreateProvider("c#");
var options = new CompilerParameters();
var assemblyContainingNotDynamicClass = Path.GetFileName(Assembly.GetExecutingAssembly().Location);
options.ReferencedAssemblies.Add(assemblyContainingNotDynamicClass);
var assemblyContaningForms = Assembly.GetAssembly(typeof(System.Windows.Forms.Control)).Location;
options.ReferencedAssemblies.Add(assemblyContaningForms);
var assemblyContainingComponent = Assembly.GetAssembly(typeof(System.ComponentModel.Component)).Location;
options.ReferencedAssemblies.Add(assemblyContainingComponent);
results = provider.CompileAssemblyFromSource(options, new[] { executableCode });
if (results.Errors.Count > 0)
{
foreach (CompilerError error in results.Errors)
{
Form1.Instance.AddToOutput(DateTime.Now.ToString() + "Error in " + FileName + ": " + error.ErrorText + " in line " + (error.Line - 8) + ".\n");
}
}
return(results.Errors.Count);
}
private MethodInfo CompileCode(string source)
{
if (null == currentProblem)
{
return(null);
}
richTextBox1.Clear();
richTextBox1.Text = "Compiling code ... ";
Stopwatch sw = new Stopwatch();
sw.Start();
var provider = CSharpCodeProvider.CreateProvider("c#");
var options = new CompilerParameters();
var assemblyContainingClass = Path.GetFileName(Assembly.GetExecutingAssembly().Location);
options.ReferencedAssemblies.Add(assemblyContainingClass);
options.ReferencedAssemblies.Add("System.dll");
var results = provider.CompileAssemblyFromSource(options, new[] { source });
if (results.Errors.Count > 0)
{
foreach (var error in results.Errors)
{
richTextBox1.AppendText("\n");
richTextBox1.AppendText(error.ToString(), Color.Red, true);
}
richTextBox1.AppendText(string.Format("\n{0} errors encountered. Compile time {1} seconds.", results.Errors.Count, (double)sw.ElapsedMilliseconds / 1000), Color.Red, true);
return(null);
}
sw.Stop();
richTextBox1.AppendText(string.Format("compilation done in {0} seconds.", (double)sw.ElapsedMilliseconds / 1000));
var t = results.CompiledAssembly.GetType("MySolution");
var method = null != t?t.GetMethod(currentProblem.ProblemName) : null;
if (null == method)
{
richTextBox1.AppendText("\n");
richTextBox1.AppendText(string.Format("Error: No method MySolution::{0} found! Your solution must be a public static method named {0} in a class named MySolution.", currentProblem.ProblemName), Color.Red, true);
return(null);
}
var parama = method.GetParameters();
var retval = method.ReturnType;
if (parama.Count() != 1 || parama[0].ParameterType != currentProblem.inputParameter ||
retval != currentProblem.outputParameter)
{
richTextBox1.AppendText("\n");
richTextBox1.AppendText(string.Format("Error: MySolution::{0} has incorrect method signature! Method must accept one parameter of type {1} and return {2}.", currentProblem.ProblemName, currentProblem.inputParameter.ToString(), currentProblem.outputParameter.ToString()), Color.Red, true);
return(null);
}
return(method);
}
/// <summary>
/// Generates the compiled type.
/// </summary>
private static IGenerator GenerateType(ProcessedResult result)
{
// Create the code using the template file.
string template = null;
using (var reader = new StreamReader("Compiler/CompiledLayerTemplate.cs"))
template = reader.ReadToEnd();
var final = template
.Replace("/****** %CODE% ******/", result.ProcessedCode)
.Replace("/****** %RETURN% ******/", "return " + result.OutputVariableName + ";")
.Replace("/****** %DECLS% ******/", result.Declarations)
.Replace("/****** %USING% ******/",
result.UsingStatements
.Where(v => v != "System" && v != "Tychaia.ProceduralGeneration")
.Select(v => "using " + v + ";")
.DefaultIfEmpty("")
.Aggregate((a, b) => a + "\n" + b));
// Create the type.
var parameters = new CompilerParameters(new string[]
{
"Tychaia.ProceduralGeneration.dll",
"System.Core.dll"
});
parameters.GenerateExecutable = false;
parameters.GenerateInMemory = true;
parameters.IncludeDebugInformation = false;
parameters.CompilerOptions = "/optimize";
var compiler = CSharpCodeProvider.CreateProvider("CSharp");
var results = compiler.CompileAssemblyFromSource(parameters, final);
using (var writer = new StreamWriter("code.tmp.cs"))
{
//int i = 1;
foreach (var line in final.Split('\n'))
{
//i++.ToString().PadLeft(4) + ": " +
writer.WriteLine(line);
}
}
if (results.Errors.HasErrors)
{
foreach (var error in results.Errors)
{
Console.WriteLine(error);
}
Console.WriteLine();
throw new InvalidOperationException("Unable to compile code for layer generation. Compiled code contained errors.");
}
var assembly = results.CompiledAssembly;
var newType = assembly.GetType("CompiledLayer");
return(newType.GetConstructor(Type.EmptyTypes).Invoke(null) as IGenerator);
}
private static CompilerResults CompileScript(string source)
{
CompilerParameters parms = new CompilerParameters();
parms.GenerateExecutable = false;
parms.GenerateInMemory = true;
parms.IncludeDebugInformation = false;
CodeDomProvider compiler = CSharpCodeProvider.CreateProvider("CSharp");
return(compiler.CompileAssemblyFromSource(parms, source));
}
private int PrecompileDesignCode()
{
var codeFilePath = string.Format("{0}/Data/{1}/{2}Design.cs", ProjectPath, ArcDirectoryName, name);
string methodBody = File.ReadAllText(codeFilePath);
string executableCode =
@"
using System;
using System.Windows.Forms;
using System.Drawing;
using System.IO;
namespace MultiArc_Compiler {
public class DynamicDesignClass" + name + @"
{
" + methodBody + @"
}
}";
var provider = CSharpCodeProvider.CreateProvider("c#");
var options = new CompilerParameters();
var executingAssembly = Assembly.GetExecutingAssembly();
var assemblyContainingNotDynamicClass = Path.GetFileName(executingAssembly.Location);
options.ReferencedAssemblies.Add(assemblyContainingNotDynamicClass);
//options.ReferencedAssemblies.AddRange(executingAssembly.GetReferencedAssemblies().Select(a => a.Name).ToArray());
var assemblyContaningForms = Assembly.GetAssembly(typeof(System.Windows.Forms.Control)).Location;
options.ReferencedAssemblies.Add(assemblyContaningForms);
var assemblyContainingComponent = Assembly.GetAssembly(typeof(System.ComponentModel.Component)).Location;
options.ReferencedAssemblies.Add(assemblyContainingComponent);
var assemblyContainingDrawing = Assembly.GetAssembly(typeof(System.Drawing.Graphics)).Location;
options.ReferencedAssemblies.Add(assemblyContainingDrawing);
DesignCompileResults = provider.CompileAssemblyFromSource(options, new[] { executableCode });
if (DesignCompileResults.Errors.Count > 0)
{
foreach (CompilerError error in DesignCompileResults.Errors)
{
Form1.Instance.AddToOutput(DateTime.Now.ToString() + "Error in " + FileName + ": " + error.ErrorText + " in line " + (error.Line - 8) + ".\n");
}
}
return(DesignCompileResults.Errors.Count);
}
/// <summary>
/// Compiles a source file with the given parameters and source
/// </summary>
/// <param name="parms"></param>
/// <param name="source"></param>
/// <returns></returns>
private static CompilerResults Compile(CompilerParameters parameters, string source)
{
foreach (Assembly asm in AppDomain.CurrentDomain.GetAssemblies())
{
if (asm.Location.Contains("Microsoft.Xna") || asm.Location.Contains("Gibbo.Library") ||
asm.Location.Contains("System"))
{
parameters.ReferencedAssemblies.Add(asm.Location);
}
}
//parameters.ReferencedAssemblies.Add(@"C:\Users\Inspire\Documents\Gibbo\scripts_sds\DefaultGameScripts.dll");
CodeDomProvider compiler = CSharpCodeProvider.CreateProvider("CSharp");
return(compiler.CompileAssemblyFromSource(parameters, source));
}
public CompilerResults CompileCode(string source)
{
CompilerParameters parms = new CompilerParameters();
parms.GenerateExecutable = false;
parms.GenerateInMemory = true;
parms.IncludeDebugInformation = false;
parms.ReferencedAssemblies.Add(@"C:\Windows\Microsoft.NET\Framework\v4.0.30319\System.ComponentModel.DataAnnotations.dll");
parms.ReferencedAssemblies.Add(@"System.dll");
parms.ReferencedAssemblies.Add(@"System.Core.dll");
CodeDomProvider compiler = CSharpCodeProvider.CreateProvider("CSharp", new Dictionary <String, String> {
{ "CompilerVersion", "v3.5" }
});
return(compiler.CompileAssemblyFromSource(parms, source));
}
public static ValidationResult IsValidNamespace(string name)
{
if (string.IsNullOrWhiteSpace(name))
{
return(new ValidationResult("The namepace is required."));
}
if (Regex.IsMatch(name, "\\.\\."))
{
return(new ValidationResult("'..' is not allowed in namespace."));
}
foreach (var part in name.Split('.'))
{
if (!CSharpCodeProvider.CreateProvider("CSharp").IsValidIdentifier(part))
{
return(new ValidationResult("This value is not a valid namespace identifier."));
}
}
return(ValidationResult.Success);
}
public static string CSharpName(this string name)
{
bool isValid = CSharpCodeProvider.CreateProvider("C#").IsValidIdentifier(name);
if (!isValid)
{
// name contains invalid chars, remove them
Regex regex = new Regex(@"[^\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Nl}\p{Mn}\p{Mc}\p{Cf}\p{Pc}\p{Lm}]");
name = regex.Replace(name, "");
// name doesn't begin with a letter, insert an underscore
if (!char.IsLetter(name, 0))
{
name = name.Insert(0, "_");
}
}
return(name.Replace(" ", "_"));
}
public Object BuildObjectInstance(String xmlFile)
{
XDocument xDoc = XDocument.Load(xmlFile);
var builder = new StringBuilder();
var className = xDoc.Root.Name.LocalName;
builder.AppendFormat(" using System; public class ").Append(className).Append(" { ");
foreach (XElement n_ in xDoc.Descendants().Skip(1))
{
if (n_ != null)
{
if (n_.Elements().Any())
{
//do nothing for now...
}
else
{
builder.AppendFormat("string _")
.Append(n_.Name.LocalName)
.Append(" = \"")
.Append(n_.Value).Append("\"; public string ")
.Append(n_.Name.LocalName).Append(" { get { return _")
.Append(n_.Name.LocalName).Append(" ; } set { _")
.Append(n_.Name.LocalName).Append(" = value; } } ");
}
}
}
builder.Append(" } ");
var compilerParams = new CompilerParameters();
compilerParams.GenerateExecutable = false;
compilerParams.GenerateInMemory = true;
var cCompiler = CSharpCodeProvider.CreateProvider("CSharp");
var compilerResult = cCompiler.CompileAssemblyFromSource(compilerParams, builder.ToString());
if (compilerResult.Errors.HasErrors)
{
throw new Exception("An Error has occurred while building type");
}
return(compilerResult.CompiledAssembly.CreateInstance(className, true));
}
private CompilerResults CompileFiles(List <Assembly> additionalAssemblys, params string[] filepath)
{
string language = CSharpCodeProvider.GetLanguageFromExtension(Path.GetExtension(filepath.First()));//XXX: Might miss-interpret .py-files
CodeDomProvider codeDomProvider = CSharpCodeProvider.CreateProvider(language);
CompilerParameters compilerParams = new CompilerParameters();
compilerParams.GenerateExecutable = false;
compilerParams.GenerateInMemory = true;
#if DEBUG
compilerParams.IncludeDebugInformation = true;
#else
compilerParams.IncludeDebugInformation = false;
#endif
//compilerParams.ReferencedAssemblies.Add(Assembly.GetCallingAssembly().Location);
//compilerParams.ReferencedAssemblies.Add("mscorlib.dll");
//compilerParams.ReferencedAssemblies.Add("System.dll");
//compilerParams.ReferencedAssemblies.Add("System.Drawing.dll");
//compilerParams.ReferencedAssemblies.Add("System.Core.dll");
//compilerParams.ReferencedAssemblies.Add("System.dll");
//compilerParams.ReferencedAssemblies.Add("System.Xml.dll");
//compilerParams.ReferencedAssemblies.Add("System.Xml.Linq.dll");
//compilerParams.ReferencedAssemblies.Add(@"C:\Program Files (x86)\Microsoft XNA\XNA Game Studio\v4.0\References\Windows\x86\Microsoft.Xna.Framework.dll");//XXX: Path to XNA dlls is static
//compilerParams.ReferencedAssemblies.Add(@"C:\Program Files (x86)\Microsoft XNA\XNA Game Studio\v4.0\References\Windows\x86\Microsoft.Xna.Framework.Graphics.dll");
//compilerParams.ReferencedAssemblies.Add(@"C:\Program Files (x86)\Microsoft XNA\XNA Game Studio\v4.0\References\Windows\x86\Microsoft.Xna.Framework.Game.dll");
////compilerParams.ReferencedAssemblies.Add("Microsoft.Xna.Framework.Graphics.dll");
//compilerParams.ReferencedAssemblies.Add("X45Game.dll");
var assemblies = AppDomain.CurrentDomain
.GetAssemblies()
.Where(a => !a.IsDynamic)
.Select(a => a.Location)
.ToArray();
compilerParams.ReferencedAssemblies.AddRange(assemblies);//XXX: might not include all assemblies
if (additionalAssemblys != null && additionalAssemblys.Count > 0)
{
compilerParams.ReferencedAssemblies.AddRange(additionalAssemblys.Select(p => p.FullName).ToArray());//XXX: Might not work at all
}
return(codeDomProvider.CompileAssemblyFromFile(compilerParams, filepath));
}
/// <summary>
/// Compiles C# source code.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="name">The assembly name.</param>
/// <returns>Compiler results.</returns>
public static CompilerResults Compile(string source, string name)
{
//
// Compile the test source file
//
CodeDomProvider provider = CSharpCodeProvider.CreateProvider("CSharp");
CompilerParameters parameters = new CompilerParameters();
parameters.GenerateInMemory = true;
parameters.GenerateExecutable = false;
parameters.CompilerOptions = "/unsafe";
parameters.ReferencedAssemblies.Add("mscorlib.dll");
parameters.ReferencedAssemblies.Add("System.dll");
parameters.ReferencedAssemblies.Add("System.Data.dll");
parameters.ReferencedAssemblies.Add("System.Xml.dll");
CompilerResults results = provider.CompileAssemblyFromSource(parameters, source);
return(results);
}
public bool ValidateName(List <string> errors)
{
errors.Clear();
if (string.IsNullOrEmpty(ServiceName))
{
errors.Add("Name cannot be empty.");
return(false);
}
if (!ServiceName.EndsWith("Service"))
{
errors.Add("Name must end with 'Service' suffix.");
}
if (!CSharpCodeProvider.CreateProvider("C#").IsValidIdentifier(ServiceName))
{
errors.Add("Name must not contain illegal characters.");
}
return(errors.Count == 0);
}
////////////////////////////////////////////////////////////////
// Constructors
////////////////////////////////////////////////////////////////
public SourceUnitCompiler(string tempDir, SourceUnitSpecification sourceSpec)
{
this.sourceSpec = sourceSpec;
this.tempDir = tempDir;
if (!Directory.Exists(tempDir))
{
Directory.CreateDirectory(tempDir);
}
this.tempDir2 = tempDir;
if (!this.tempDir2.EndsWith("" + Path.DirectorySeparatorChar))
{
this.tempDir2 += Path.DirectorySeparatorChar;
}
csharpCompiler = CSharpCodeProvider.CreateProvider("cs");
codeGenList = new CodeGenList();
this.AssemblyManager = new AssemblyManager();
}
public void Execute(string program)
{
//Создание класса CSHarpProvider с указанием того, что сборка генерируется в памяти
var CSHarpProvider = CSharpCodeProvider.CreateProvider("CSharp");
CompilerParameters compilerParams = new CompilerParameters()
{
GenerateExecutable = false,
GenerateInMemory = true,
};
//Добавление сборок для компиляции
compilerParams.ReferencedAssemblies.AddRange(refferences.ToArray());
//Компиляция
var compilerResult = CSHarpProvider.CompileAssemblyFromSource(compilerParams, program);
if (compilerResult.Errors.Count == 0)
{
OnExecute(string.Concat("Executing...", Environment.NewLine));
try
{
//Вызов метода ScriptMethod в сборке которая скомпилировалась
compilerResult.CompiledAssembly.GetType("CScript.Script").GetMethod("ScriptMethod").Invoke(null, null);
OnExecute(string.Empty);
OnExecute("Done.");
}
catch (Exception e)
{
OnExecute(e.InnerException.Message + "rn" + e.InnerException.StackTrace);
}
}
else
{
foreach (var oline in compilerResult.Output)
{
OnExecute(oline);
}
}
}
/// <summary>
/// Compiles execution code of this addressing mode.
/// </summary>
/// <param name="output">
/// Output where compile errors will be written.
/// </param>
/// <returns>
/// Bool value indicating whether compile was successful or not.
/// </returns>
public bool CompileCode(TextBoxBase output)
{
executionCode = File.ReadAllText(fileName);
var provider = CSharpCodeProvider.CreateProvider("c#");
var options = new CompilerParameters();
var assemblyContainingNotDynamicClass = Path.GetFileName(Assembly.GetExecutingAssembly().Location);
options.ReferencedAssemblies.Add(assemblyContainingNotDynamicClass);
var assemblyContaningForms = Assembly.GetAssembly(typeof(System.Windows.Forms.Control)).Location;
options.ReferencedAssemblies.Add(assemblyContaningForms);
var assemblyContainingComponent = Assembly.GetAssembly(typeof(System.ComponentModel.Component)).Location;
options.ReferencedAssemblies.Add(assemblyContainingComponent);
string code = @"
using System;
using System.IO;
using MultiArc_Compiler;
public class DynamicClass" + name + @"
{
";
code += executionCode;
code += "}";
results = provider.CompileAssemblyFromSource(options, new[] { code });
if (results.Errors.Count > 0)
{
foreach (CompilerError error in results.Errors)
{
output.AppendText(DateTime.Now.ToString() + " Error in " + fileName + ": " + error.ErrorText + " in line " + (error.Line - 8) + ".\n");
}
return(false);
}
return(true);
}
public string Execute(string program, string text, string param, Mode mode)
{
//Создание класса CSHarpProvider с указанием того, что сборка генерируется в памяти
var CSHarpProvider = CSharpCodeProvider.CreateProvider("CSharp");
CompilerParameters compilerParams = new CompilerParameters()
{
GenerateExecutable = false,
GenerateInMemory = true,
};
//Добавление сборок для компиляции
compilerParams.ReferencedAssemblies.AddRange(refferences.ToArray());
//Компиляция
var compilerResult = CSHarpProvider.CompileAssemblyFromSource(compilerParams, program);
if (compilerResult.Errors.Count == 0)
{
try
{
//Вызов метода ScriptMethod в сборке которая скомпилировалась params
var result = mode == Mode.Encrypt ?
compilerResult.CompiledAssembly.GetType("CScript.Script").GetMethod("Encrypt").Invoke(null, new object[] { text, param })
:
compilerResult.CompiledAssembly.GetType("CScript.Script").GetMethod("Decrypt").Invoke(null, new object[] { text, param });
return((string)result);
}
catch (Exception)
{
return(null);
}
}
else
{
return(null);
}
}
private static IUnitPriceExpression CreateDynamicExpression(string expression, out CompilerErrorCollection errors)
{
errors = new CompilerErrorCollection();
if (String.IsNullOrEmpty(expression))
{
return(null);
}
CompilerParameters parms = new CompilerParameters();
parms.GenerateExecutable = false;
parms.GenerateInMemory = true;
parms.IncludeDebugInformation = false;
string assemblyFileName = Path.GetFileName(Assembly.GetExecutingAssembly().Location);
parms.ReferencedAssemblies.Add("System.dll");
parms.ReferencedAssemblies.Add(assemblyFileName);
CodeDomProvider compiler = CSharpCodeProvider.CreateProvider("CSharp");
string classCode = string.Format(ClassTemplate, typeof(UnitPriceConverter).FullName, expression);
CompilerResults compilerResults = compiler.CompileAssemblyFromSource(parms, classCode);
if (compilerResults.Errors.HasErrors)
{
errors = compilerResults.Errors;
return(null);
}
Assembly assembly = compilerResults.CompiledAssembly;
IUnitPriceExpression unitPriceExpression = assembly.CreateInstance("DynamicUnitPriceExpression") as IUnitPriceExpression;
return(unitPriceExpression);
}
/// <summary>
/// Compiles C# source code.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="targetCSharp6"></param>
/// <returns>Compiler results.</returns>
public static CompilerResults Compile(string source, bool targetCSharp6 = false)
{
//
// Compile the test source file
//
CompilerParameters parameters = new CompilerParameters();
parameters.GenerateInMemory = true;
parameters.GenerateExecutable = false;
parameters.CompilerOptions = "/unsafe";
parameters.ReferencedAssemblies.Add("mscorlib.dll");
parameters.ReferencedAssemblies.Add("System.dll");
parameters.ReferencedAssemblies.Add("System.Data.dll");
parameters.ReferencedAssemblies.Add("System.Xml.dll");
parameters.ReferencedAssemblies.Add("System.Core.dll");
var provider = targetCSharp6 ?
new Microsoft.CodeDom.Providers.DotNetCompilerPlatform.CSharpCodeProvider() :
CSharpCodeProvider.CreateProvider("CSharp");
return(provider.CompileAssemblyFromSource(parameters, source));
}
public bool BuildFilter(string ufilter)
{
string filter = prepareFilterString(ufilter);
if (string.IsNullOrEmpty(filter))
{
_obj = null;
_text = filter;
return(true);
}
CompilerParameters loParameters = new CompilerParameters();
loParameters.ReferencedAssemblies.Add("System.dll");
loParameters.ReferencedAssemblies.Add(WorkingDir + "\\Nemo.Core.dll");
string lcCode =
@"using System;
using System.Collections.Generic;
using Nemo.Core;
using System.Net;
namespace Nemo.Dynamic
{
public class FilterDynamic
{
public bool MatchFilter(Flow flow)
{
try
{
return (" + filter + @");
}
catch{return false;}
}
public Flow[] FilterFlows(List<Flow> flows,
DateTime start, DateTime end)
{
List<Flow> res = new List<Flow>();
foreach(Flow flow in flows)
{
try
{
if((" + filter + @") &&
flow.StartTime.CompareTo(start) >= 0 &&
flow.EndTime.CompareTo(end) < 0)
{
res.Add(flow);
}
}
catch{}
}
return res.ToArray();
}
}
}";
// загружаем код в память
loParameters.GenerateInMemory = true;
loParameters.IncludeDebugInformation = true;
// компилируем код
CompilerResults loCompiled = CSharpCodeProvider.
CreateProvider("CSharp").CompileAssemblyFromSource(loParameters, lcCode);
if (loCompiled.Errors.HasErrors)
{
_errorMsg = "Failed to compile filter";
return(false);
}
Assembly loAssembly = loCompiled.CompiledAssembly;
// получаем скомпилированный готовый объект
_obj = loAssembly.CreateInstance("Nemo.Dynamic.FilterDynamic");
if (_obj == null)
{
_errorMsg = "Couldn't load class.";
return(false);
}
_text = ufilter;
return(true);
}
/// <summary>
/// Compile Calculator Formula Source Code
/// </summary>
public bool CompileSource()
{
try {
// CalcEngine class source code download
string source;
using (Stream stream = Assembly.GetExecutingAssembly()
.GetManifestResourceStream("Scada.Server.Engine.CalcEngine.cs")) {
using (var reader = new StreamReader(stream)) {
source = reader.ReadToEnd();
}
}
// adding members to the CalcEngine class
int todoInd = source.IndexOf("/*TODO*/");
if (todoInd >= 0)
{
var sourceSB = new StringBuilder(source);
sourceSB.Remove(todoInd, "/*TODO*/".Length);
for (int i = exprList.Count - 1; i >= 0; i--)
{
string expr = exprList[i];
sourceSB.Insert(todoInd, expr);
if (i > 0)
{
sourceSB.Insert(todoInd, "\r\n");
}
}
source = sourceSB.ToString();
}
// saving the source code of the CalcEngine class in a file for analysis
string sourceFileName = mainLogic.AppDirs.LogDir + "CalcEngine.cs";
File.WriteAllText(sourceFileName, source, Encoding.UTF8);
// compiling CalcEngine class source code
var compParams = new CompilerParameters {
GenerateExecutable = false,
GenerateInMemory = true,
IncludeDebugInformation = false
};
compParams.ReferencedAssemblies.Add("System.dll");
compParams.ReferencedAssemblies.Add("System.Core.dll");
compParams.ReferencedAssemblies.Add(mainLogic.AppDirs.ExeDir + "ScadaData.dll");
CodeDomProvider compiler = CSharpCodeProvider.CreateProvider("CSharp");
CompilerResults compilerResults = compiler.CompileAssemblyFromSource(compParams, source);
if (compilerResults.Errors.HasErrors)
{
appLog.WriteAction(
Localization.UseRussian
? "Ошибка при компилировании исходного кода формул: "
: "Error compiling the source code of the formulas: ", Log.ActTypes.Error);
foreach (CompilerError error in compilerResults.Errors)
{
appLog.WriteLine(string.Format(
Localization.UseRussian
? "Строка {0}, колонка {1}: error {2}: {3}"
: "Line {0}, column {1}: error {2}: {3}",
error.Line, error.Column, error.ErrorNumber, error.ErrorText));
}
appLog.WriteLine(string.Format(
Localization.UseRussian
? "Для ознакомления с исходным кодом см. файл {0}"
: "See the file {0} with the source code",
sourceFileName));
return(false);
}
else
{
Type calcEngineType = compilerResults.CompiledAssembly.GetType(
"Scada.Server.Engine.CalcEngine", true);
calcEngine = Activator.CreateInstance(calcEngineType,
new Func <int, SrezTableLight.CnlData>(mainLogic.GetProcSrezCnlData),
new Action <int, SrezTableLight.CnlData>(mainLogic.SetProcSrezCnlData));
appLog.WriteAction(
Localization.UseRussian
? "Исходный код формул калькулятора откомпилирован"
: "The formulas source code has been compiled", Log.ActTypes.Action);
return(true);
}
} catch (Exception ex) {
appLog.WriteAction(
(Localization.UseRussian
? "Ошибка при компилировании исходного кода формул: "
: "Error compiling the source code of the formulas: ") + ex.Message,
Log.ActTypes.Exception);
return(false);
}
}
/// <summary>
/// Create an assembly that will provide the get and set methods.
/// </summary>
private Assembly EmitAssembly()
{
PropertyInfo pi = typeof(T).GetProperty(this.mProperty);
bool hasGet = (pi.GetGetMethod() != null), hasSet = (pi.GetSetMethod() != null);
// Create the type
CodeCompileUnit compileUnit = new CodeCompileUnit();
CodeNamespace ns = new CodeNamespace("FastDynamicPropertyAccessor");
CodeTypeDeclaration propertyAccessor = new CodeTypeDeclaration("Property");
propertyAccessor.Attributes |= MemberAttributes.Final | MemberAttributes.Public;
propertyAccessor.BaseTypes.Add(typeof(IGenericPropertyAccessor <T, V>));
//
// Generate Get method
//
CodeMemberMethod get = new CodeMemberMethod();
get.Name = "Get";
get.ReturnType = new CodeTypeReference(typeof(V));
get.Parameters.Add(new CodeParameterDeclarationExpression(typeof(T), "target"));
get.Attributes &= ~MemberAttributes.AccessMask;
get.Attributes |= MemberAttributes.Public;
if (hasGet)
{
get.Statements.Add(new CodeMethodReturnStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("target"), this.mProperty)));
}
else
{
get.Statements.Add(new CodeThrowExceptionStatement(new CodeObjectCreateExpression(typeof(MissingMethodException))));
}
propertyAccessor.Members.Add(get);
//
// Generate Set method
//
CodeMemberMethod set = new CodeMemberMethod();
set.Name = "Set";
set.Parameters.Add(new CodeParameterDeclarationExpression(typeof(T), "target"));
set.Parameters.Add(new CodeParameterDeclarationExpression(typeof(V), "value"));
set.Attributes &= ~MemberAttributes.AccessMask;
set.Attributes |= MemberAttributes.Public;
if (hasSet)
{
set.Statements.Add(new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("target"), this.mProperty), new CodeVariableReferenceExpression("value")));
}
else
{
set.Statements.Add(new CodeThrowExceptionStatement(new CodeObjectCreateExpression(typeof(MissingMethodException))));
}
propertyAccessor.Members.Add(set);
ns.Types.Add(propertyAccessor);
compileUnit.Namespaces.Add(ns);
// Reference assemblies (for the original type, return value and the IGenericPropertyAccessor)
CompilerParameters parameters = new CompilerParameters();
parameters.ReferencedAssemblies.Add(typeof(IGenericPropertyAccessor <T, V>).Assembly.Location);
parameters.ReferencedAssemblies.Add(typeof(T).Assembly.Location);
parameters.ReferencedAssemblies.Add(typeof(V).Assembly.Location);
// Generation in memory means that no temporary file will be created.
parameters.GenerateInMemory = true;
// Compile the assembly
CompilerResults cr = CSharpCodeProvider.CreateProvider("C#").CompileAssemblyFromDom(parameters, compileUnit);
if (cr.Errors.Count > 0)
{
throw new PropertyAccessorException("Errors have been encountered while creating the dynamic assembly.");
}
return(cr.CompiledAssembly);
}
