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); }