public CSharpScript(String code) { using (var provider = new Microsoft.CSharp.CSharpCodeProvider()) { var builder = new StringBuilder(); builder .AppendLine("using System;") .AppendLine("using System.Collections.Generic;") .AppendLine("using System.Linq;") .AppendLine("using System.Reflection;") .AppendLine("using System.Text;") .AppendLine("using LiveSplit;") .AppendLine("using LiveSplit.Model;") .AppendLine("using LiveSplit.Web;") .AppendLine("using LiveSplit.Web.Share;") .AppendLine("public class CompiledScript") .AppendLine("{") .AppendLine("public void Respond(string message)") .AppendLine("{") .AppendLine("Twitch.Instance.Chat.SendMessage(message);") .AppendLine("}") .AppendLine("public void Execute(LiveSplitState state, TwitchChat.User user, string arguments)") .AppendLine("{") .Append(code) .AppendLine("}") .AppendLine("}"); var parameters = new System.CodeDom.Compiler.CompilerParameters() { GenerateInMemory = true, CompilerOptions = "/optimize", }; parameters.ReferencedAssemblies.Add("System.dll"); parameters.ReferencedAssemblies.Add("System.Core.dll"); parameters.ReferencedAssemblies.Add("LiveSplit.Core.dll"); parameters.ReferencedAssemblies.Add("System.Data.dll"); parameters.ReferencedAssemblies.Add("System.Data.DataSetExtensions.dll"); parameters.ReferencedAssemblies.Add("System.Drawing.dll"); parameters.ReferencedAssemblies.Add("System.Windows.Forms.dll"); parameters.ReferencedAssemblies.Add("System.Xml.dll"); parameters.ReferencedAssemblies.Add("System.Xml.Linq.dll"); parameters.ReferencedAssemblies.Add("Microsoft.CSharp.dll"); var res = provider.CompileAssemblyFromSource(parameters, builder.ToString()); if (res.Errors.HasErrors) { var errorMessage = ""; foreach (var error in res.Errors) { errorMessage += error + "\r\n"; } throw new ArgumentException(errorMessage, "code"); } var type = res.CompiledAssembly.GetType("CompiledScript"); CompiledCode = Activator.CreateInstance(type); } }
public static T Create <T>(string code, string className, params string[] referencedAssemblies) { using (var csharp = new Microsoft.CSharp.CSharpCodeProvider()) { var parameters = new System.CodeDom.Compiler.CompilerParameters() { GenerateInMemory = true, }; if (referencedAssemblies != null) { parameters.ReferencedAssemblies.AddRange(referencedAssemblies); } var assemblyName = typeof(T).Assembly.Location; if (typeof(T).Assembly != Assembly.GetExecutingAssembly() && (referencedAssemblies == null || !referencedAssemblies.Contains(assemblyName))) { parameters.ReferencedAssemblies.Add(assemblyName); } Console.WriteLine(string.Join(", ", parameters.ReferencedAssemblies.Cast <string>())); var res = csharp.CompileAssemblyFromSource(parameters, code); if (res.Errors.HasErrors) { var errors = string.Join("\n", res.Errors.OfType <System.CodeDom.Compiler.CompilerError>().Select(r => r.ToString())); throw new Exception(string.Format("Error compiling:\n{0}", errors)); } return((T)res.CompiledAssembly.CreateInstance(className)); } }
public static string ParseString(string input) { var provider = new Microsoft.CSharp.CSharpCodeProvider(); var parameters = new System.CodeDom.Compiler.CompilerParameters() { GenerateExecutable = false, GenerateInMemory = true, }; var code = @" namespace Tmp { public class TmpClass { public static string GetValue() { return """ + input + @"""; } } }"; var compileResult = provider.CompileAssemblyFromSource(parameters, code); if (compileResult.Errors.HasErrors) { throw new ArgumentException(compileResult.Errors.Cast <System.CodeDom.Compiler.CompilerError>().First(e => !e.IsWarning).ErrorText); } var asmb = compileResult.CompiledAssembly; var method = asmb.GetType("Tmp.TmpClass").GetMethod("GetValue"); return(method.Invoke(null, null) as string); }
public static string ParseString(string input) { var provider = new Microsoft.CSharp.CSharpCodeProvider(); var parameters = new System.CodeDom.Compiler.CompilerParameters() { GenerateExecutable = false, GenerateInMemory = true, }; var code = @" namespace Tmp { public class TmpClass { public static string GetValue() { return """ + input + @"""; } } }"; var compileResult = provider.CompileAssemblyFromSource(parameters, code); if (compileResult.Errors.HasErrors) { return input; //throw new ArgumentException(compileResult.Errors.Cast<System.CodeDom.Compiler.CompilerError>().First(e => !e.IsWarning).ErrorText); } var asmb = compileResult.CompiledAssembly; var method = asmb.GetType("Tmp.TmpClass").GetMethod("GetValue"); return method.Invoke(null, null) as string; }
/// <summary> /// 动态编译 /// </summary> /// <param name="formula">需编译的内容</param> /// <param name="returnType">返回类型</param> /// <param name="obj">参数</param> /// <returns></returns> public static object Calculate(string formula, string returnType, object obj) { try { string paramExp = obj.GetType().ToString() + " obj"; object calculated = null; Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider(); System.CodeDom.Compiler.CompilerParameters parameter = new System.CodeDom.Compiler.CompilerParameters(); parameter.ReferencedAssemblies.Add("System.dll"); parameter.GenerateExecutable = false; //<--不要生成 EXE 文件 parameter.GenerateInMemory = true; //在内存中运行 string codeDom = GenerateCodeBlocks(formula, returnType, paramExp); System.CodeDom.Compiler.CompilerResults result = provider.CompileAssemblyFromSource(parameter,codeDom);//动态编译后的结果 if (result.Errors.Count > 0) { return null; } System.Reflection.MethodInfo newMethod = result.CompiledAssembly.GetType("Maike.Calculation").GetMethod("dowork"); calculated = result.CompiledAssembly.GetType("Maike.Calculation").GetMethod("dowork").Invoke(null, new object[] { obj }); return calculated; } catch { return null; } }
private void CompileApp(int rc, string pathToExe) { Microsoft.CSharp.CSharpCodeProvider csharp = new Microsoft.CSharp.CSharpCodeProvider(); //System.CodeDom.Compiler.ICodeCompiler csharpCompiler = csharp.CreateCompiler(); var cp = new System.CodeDom.Compiler.CompilerParameters(); cp.GenerateInMemory = false; cp.GenerateExecutable = true; cp.IncludeDebugInformation = false; cp.OutputAssembly = pathToExe; // set the return code in the app var cr = csharp.CompileAssemblyFromSource(cp, programCode.Replace("@@XXX@@", rc.ToString())); if (cr == null) { throw new Exception("Errors compiling!"); } foreach (string s in cr.Output) { TestContext.WriteLine(s); } if (cr.Errors.Count != 0) { throw new Exception("Errors compiling!"); } }
private static Type GenerateAccountType(AccountType accountType) { var provider = new Microsoft.CSharp.CSharpCodeProvider(); var parameters = new System.CodeDom.Compiler.CompilerParameters { GenerateInMemory = true, GenerateExecutable = false }; parameters.ReferencedAssemblies.Add("system.dll"); parameters.ReferencedAssemblies.Add(typeof(System.Linq.IQueryable).Assembly.Location); parameters.ReferencedAssemblies.Add(typeof(Entity).Assembly.Location); parameters.ReferencedAssemblies.Add(typeof(AccountType).Assembly.Location); parameters.ReferencedAssemblies.Add(typeof(Account).Assembly.Location); parameters.ReferencedAssemblies.Add(typeof(System.ServiceModel.OperationContext).Assembly.Location); parameters.ReferencedAssemblies.Add(typeof(TransactRules.Calculations.AccrualCalculation).Assembly.Location); var accountTemplate = new AccountClassTemplate { Model = accountType }; var code = accountTemplate.TransformText(); var compilerResults = provider.CompileAssemblyFromSource(parameters, code); if (compilerResults.Errors.Count > 0) { ThrowCompilerException(accountType, compilerResults); } var generatedType = compilerResults.CompiledAssembly.GetType(GetTypeName(accountType)); return(generatedType); }
public void TestCompile() { var model = "Model = new { test = \"object\" };"; using (var CSharpProvider = new CSharpCodeProvider()) { var paramz = new System.CodeDom.Compiler.CompilerParameters() { GenerateInMemory = true }; paramz.ReferencedAssemblies.Add("Newtonsoft.Json.dll"); var res = CSharpProvider.CompileAssemblyFromSource(paramz, @" using Newtonsoft.Json; public class ModelClass { public string Execute() { object Model;" + model + @"return JsonConvert.SerializeObject(Model); } }"); var type = res.CompiledAssembly.GetType("ModelClass"); var obj = Activator.CreateInstance(type); var output = type.GetMethod("Execute").Invoke(obj, new object[] { }); Assert.IsNotNull(JsonConvert.DeserializeObject(output.ToString())); } }
private static void ReferenceAssembliesIfNotExists(System.CodeDom.Compiler.CompilerParameters cp, Type paramType, List <Assembly> assemblies) { var typeAssemblies = new List <Assembly>(); var typeAssembly = paramType.Assembly; if (!assemblies.Contains(typeAssembly)) { typeAssemblies.Add(typeAssembly); } if (paramType.IsGenericType) { var genericArgs = paramType.GetGenericArguments(); typeAssemblies.AddRange(genericArgs.Select(x => x.Assembly)); } foreach (var assembly in typeAssemblies) { assemblies.Add(assembly); if (assembly.IsDynamic()) { continue; } AddAssembly(cp, assembly.Location); } }
public void compile(System.IO.StreamReader stdin) { var cp = new System.CodeDom.Compiler.CompilerParameters() { GenerateExecutable = false, GenerateInMemory = true, }; while (true) { System.String line = stdin.ReadLine(); if (line == "/* ENDASM */") { break; } cp.ReferencedAssemblies.Add(line); } cp.ReferencedAssemblies.Add("System.dll"); cp.ReferencedAssemblies.Add("System.Core.dll"); cp.ReferencedAssemblies.Add("System.Dynamic.dll"); cp.ReferencedAssemblies.Add("Microsoft.CSharp.dll"); var r = new Microsoft.CSharp.CSharpCodeProvider().CompileAssemblyFromSource(cp, StageTwo.ReadUntilLine("/* ENDBLOCK */")); if (r.Errors.HasErrors) { return; } var obj = r.CompiledAssembly.CreateInstance("command"); obj.GetType().GetMethod("main").Invoke(obj, new object[] { }); }
private System.Reflection.Assembly CompileCode(string sourceFile, string language) { string vbSource = ""; string fName = new FileInfo(sourceFile).Name; Logger.MajorVerbose("Compiling " + fName + "..."); try { using (StreamReader SR = new StreamReader(sourceFile)) { while (SR.Peek() > -1) { vbSource += SR.ReadLine() + System.Environment.NewLine; } } } catch (Exception ex) { Logger.MajorError("Exception raised while reading " + fName + System.Environment.NewLine + ex.ToString()); return(null); } System.CodeDom.Compiler.CodeDomProvider prov = null; System.CodeDom.Compiler.CompilerParameters compParams = new System.CodeDom.Compiler.CompilerParameters(); System.CodeDom.Compiler.CompilerResults compResults; string[] refs = { "System.dll", "Microsoft.VisualBasic.dll", "System.XML.dll", "System.Data.dll", Path.GetDirectoryName(Assembly.GetAssembly(typeof(ThalesMain)).CodeBase) + "\\ThalesCore.dll", System.Reflection.Assembly.GetAssembly(typeof(ThalesMain)).Location }; compParams.ReferencedAssemblies.AddRange(refs); try { prov = System.CodeDom.Compiler.CodeDomProvider.CreateProvider(language); compResults = prov.CompileAssemblyFromSource(compParams, vbSource); } catch (Exception ex) { Logger.MajorError("Exception raised during compilation of " + fName + System.Environment.NewLine + ex.ToString()); return(null); } if (compResults.Errors.Count > 0) { Logger.MajorError("Compilation errors of " + fName); foreach (System.CodeDom.Compiler.CompilerError Err in compResults.Errors) { Logger.MajorError("Line: " + Err.Line.ToString() + System.Environment.NewLine + "Column: " + Err.Column.ToString() + System.Environment.NewLine + "Error: " + Err.ErrorText); } return(null); } else { return(System.Reflection.Assembly.LoadFrom(compResults.PathToAssembly)); } }
private Type CompileClass(ClassBuilder classBuilder) { List <string> errorMessages = new List <string>(); string source = classBuilder.ToString(); Microsoft.CSharp.CSharpCodeProvider cp = new Microsoft.CSharp.CSharpCodeProvider(); System.CodeDom.Compiler.ICodeCompiler ic = cp.CreateCompiler(); System.CodeDom.Compiler.CompilerParameters cpar = new System.CodeDom.Compiler.CompilerParameters(); cpar.GenerateInMemory = true; cpar.GenerateExecutable = false; foreach (string reference in References) { cpar.ReferencedAssemblies.Add(reference); } System.CodeDom.Compiler.CompilerResults cr = ic.CompileAssemblyFromSource(cpar, source); foreach (System.CodeDom.Compiler.CompilerError ce in cr.Errors) { errorMessages.Add(ce.ErrorText); } if (cr.Errors.Count == 0 && cr.CompiledAssembly != null) { return(cr.CompiledAssembly.GetType(classBuilder.FullName)); } throw new ApplicationException("Compiler error"); // assemble error messages here }
// http://www.codeproject.com/KB/cs/runtimecompiling.aspx private static System.Reflection.Assembly BuildAssembly(string code) { Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider(); System.CodeDom.Compiler.ICodeCompiler compiler = provider.CreateCompiler(); System.CodeDom.Compiler.CompilerParameters compilerparams = new System.CodeDom.Compiler.CompilerParameters(); string strLocation = System.Reflection.Assembly.GetExecutingAssembly().Location; string strBasePath = System.IO.Path.GetDirectoryName(strLocation); string strSerializationTypes = System.IO.Path.Combine(strBasePath, "SerializationTypes.dll"); string strFileHelpersLocation = System.IO.Path.Combine(strBasePath, "FileHelpers.dll"); compilerparams.ReferencedAssemblies.Add(strSerializationTypes); compilerparams.ReferencedAssemblies.Add(strFileHelpersLocation); compilerparams.GenerateExecutable = false; compilerparams.GenerateInMemory = true; System.CodeDom.Compiler.CompilerResults results = compiler.CompileAssemblyFromSource(compilerparams, code); if (results.Errors.HasErrors) { System.Text.StringBuilder errors = new System.Text.StringBuilder("Compiler Errors :\r\n"); foreach (System.CodeDom.Compiler.CompilerError error in results.Errors) { errors.AppendFormat("Line {0},{1}\t: {2}\n", error.Line, error.Column, error.ErrorText); } throw new Exception(errors.ToString()); } else { return(results.CompiledAssembly); } } // End Function BuildAssembly
public object MathCalculator(string expression) { object retvar = null; Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider(); System.CodeDom.Compiler.CompilerParameters cp = new System.CodeDom.Compiler.CompilerParameters( new string[] { @"System.dll" }); StringBuilder builder = new StringBuilder("using System;class CalcExp{public static object Calc(){ return \"expression\";}}"); builder.Replace("\"expression\"", expression); string code = builder.ToString(); System.CodeDom.Compiler.CompilerResults results; results = provider.CompileAssemblyFromSource(cp, new string[] { code }); if (results.Errors.HasErrors) { retvar = null; } else { System.Reflection.Assembly a = results.CompiledAssembly; Type t = a.GetType("CalcExp"); retvar = t.InvokeMember("Calc", System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.InvokeMethod , System.Type.DefaultBinder, null, null); } return(retvar); }
private static Assembly GenerateLameFacadeAssembly(string lameDllName) { // Get a modified source with proper DLL name // Should be good for .NET Framework 4.5 without any define constants. // Otherwise, add proper define(s) to the compiler options var thisAsm = typeof(Mp3LameAudioEncoder).Assembly; var source = GetLameFacadeAssemblySource(lameDllName, thisAsm); // Compile it to a new in-memory assembly var compiler = new Microsoft.CSharp.CSharpCodeProvider(); var compilerOptions = new System.CodeDom.Compiler.CompilerParameters() { GenerateInMemory = true, GenerateExecutable = false, IncludeDebugInformation = false, CompilerOptions = "/optimize", ReferencedAssemblies = { "mscorlib.dll", thisAsm.Location } }; var compilerResult = compiler.CompileAssemblyFromSource(compilerOptions, source); if (compilerResult.Errors.HasErrors) { throw new Exception("Could not generate LAME facade assembly."); } return(compilerResult.CompiledAssembly); }
private void btnCompiler_Click(object sender, EventArgs e) { string code = this.txtCode.Text; StringBuilder str = new StringBuilder(); Microsoft.CSharp.CSharpCodeProvider codeProvider = new Microsoft.CSharp.CSharpCodeProvider(); System.CodeDom.Compiler.CompilerParameters comparameters = new System.CodeDom.Compiler.CompilerParameters(); comparameters.ReferencedAssemblies.Add("System.dll"); comparameters.ReferencedAssemblies.Add("System.Windows.Forms.dll"); comparameters.GenerateInMemory = true; System.CodeDom.Compiler.CompilerResults res = codeProvider.CompileAssemblyFromSource(comparameters, code); if (res.Errors.HasErrors) { Console.WriteLine("编译错误:"); foreach (System.CodeDom.Compiler.CompilerError err in res.Errors) { str.AppendLine(@"/r/nLine:" + err.ErrorText); // str.AppendLine(err.ErrorText); // Console.WriteLine(err.ErrorText); } } else { object myClass = res.CompiledAssembly.CreateInstance("MyClass"); var result = myClass.GetType().GetMethod("PrintConsole").Invoke(myClass, new object[] { "Hello World" }); str.AppendLine(result.ToString()); } this.txtResult.Text = str.ToString(); //Console.Read(); }
private static string CompileString(string csharpCode, string outFile) { var provider = new Microsoft.CSharp.CSharpCodeProvider(); var parameters = new System.CodeDom.Compiler.CompilerParameters { OutputAssembly = outFile, GenerateExecutable = false, GenerateInMemory = false }; parameters.ReferencedAssemblies.Add(typeof(ExportAttribute).Assembly.Location); parameters.ReferencedAssemblies.Add(typeof(IPythonInterpreterFactoryProvider).Assembly.Location); parameters.ReferencedAssemblies.Add(typeof(InterpreterConfiguration).Assembly.Location); var result = provider.CompileAssemblyFromSource(parameters, csharpCode); if (result.Errors.HasErrors) { foreach (var err in result.Errors) { Console.WriteLine(err); } } if (!File.Exists(outFile)) { Assert.Fail("Failed to compile {0}", outFile); } _tempFiles.Add(outFile); return(outFile); }
public static object UploadData(string url, string @namespace, string classname, string methodname, object[] args, ArrayList al) { try { System.Net.WebClient wc = new System.Net.WebClient(); //System.IO.Stream stream = wc.OpenRead(url + "?WSDL"); System.IO.Stream stream = wc.OpenRead(url); System.Web.Services.Description.ServiceDescription sd = System.Web.Services.Description.ServiceDescription.Read(stream); System.Web.Services.Description.ServiceDescriptionImporter sdi = new System.Web.Services.Description.ServiceDescriptionImporter(); sdi.AddServiceDescription(sd, string.Empty, string.Empty); //将sd描述导入到sdi中 System.CodeDom.CodeNamespace cn = new System.CodeDom.CodeNamespace(@namespace); System.CodeDom.CodeCompileUnit ccu = new System.CodeDom.CodeCompileUnit(); ccu.Namespaces.Add(cn); sdi.Import(cn, ccu); Microsoft.CSharp.CSharpCodeProvider csc = new Microsoft.CSharp.CSharpCodeProvider(); System.CodeDom.Compiler.ICodeCompiler icc = csc.CreateCompiler(); System.CodeDom.Compiler.CompilerParameters cplist = new System.CodeDom.Compiler.CompilerParameters(); cplist.GenerateExecutable = false; cplist.GenerateInMemory = true; cplist.ReferencedAssemblies.Add("System.dll"); cplist.ReferencedAssemblies.Add("System.XML.dll"); cplist.ReferencedAssemblies.Add("System.Web.Services.dll"); cplist.ReferencedAssemblies.Add("System.Data.dll"); System.CodeDom.Compiler.CompilerResults cr = icc.CompileAssemblyFromDom(cplist, ccu); if (cr.Errors.HasErrors) { System.Text.StringBuilder sb = new System.Text.StringBuilder(); foreach (System.CodeDom.Compiler.CompilerError ce in cr.Errors) { sb.Append(ce.ToString()); sb.Append(System.Environment.NewLine); } throw new Exception(sb.ToString()); } System.Reflection.Assembly assembly = cr.CompiledAssembly; Type t = assembly.GetType(@namespace + "." + classname, true, true); object obj = Activator.CreateInstance(t); ParameterModifier[] paramsModifer = new ParameterModifier[1]; paramsModifer[0] = new ParameterModifier(args.Length); //paramsModifer[0][7] = true; object result = t.InvokeMember(methodname, BindingFlags.Default | BindingFlags.InvokeMethod, null, obj, args, paramsModifer, null, null); //al.Add(args[7]); return(result); } catch (Exception ex) { WriteLog(ex.Message, EXCEPTION_LOG_TITLE); return(null); } }
private bool LoadScript(string filename) { var compilerOptions = new System.CodeDom.Compiler.CompilerParameters(); compilerOptions.CompilerOptions = "/optimize"; compilerOptions.GenerateInMemory = true; compilerOptions.IncludeDebugInformation = true; compilerOptions.ReferencedAssemblies.Add("System.dll"); compilerOptions.ReferencedAssemblies.Add("System.Core.dll"); compilerOptions.ReferencedAssemblies.Add("System.Drawing.dll"); compilerOptions.ReferencedAssemblies.Add("System.Windows.Forms.dll"); compilerOptions.ReferencedAssemblies.Add("System.XML.dll"); compilerOptions.ReferencedAssemblies.Add("System.XML.Linq.dll"); compilerOptions.ReferencedAssemblies.Add(typeof(Script).Assembly.Location); string extension = Path.GetExtension(filename); System.CodeDom.Compiler.CodeDomProvider compiler = null; if (extension.Equals(".cs", StringComparison.OrdinalIgnoreCase)) { compiler = new Microsoft.CSharp.CSharpCodeProvider(); compilerOptions.CompilerOptions += " /unsafe"; } else if (extension.Equals(".vb", StringComparison.OrdinalIgnoreCase)) { compiler = new Microsoft.VisualBasic.VBCodeProvider(); } else { return(false); } System.CodeDom.Compiler.CompilerResults compilerResult = compiler.CompileAssemblyFromFile(compilerOptions, filename); if (!compilerResult.Errors.HasErrors) { Log("[INFO]", "Successfully compiled '", Path.GetFileName(filename), "'."); return(LoadAssembly(filename, compilerResult.CompiledAssembly)); } else { var errors = new System.Text.StringBuilder(); foreach (System.CodeDom.Compiler.CompilerError error in compilerResult.Errors) { errors.Append(" at line "); errors.Append(error.Line); errors.Append(": "); errors.Append(error.ErrorText); errors.AppendLine(); } Log("[ERROR]", "Failed to compile '", Path.GetFileName(filename), "' with ", compilerResult.Errors.Count.ToString(), " error(s):", Environment.NewLine, errors.ToString()); return(false); } }
/// <summary>Generates a generic object at runtime (typically delegates).</summary> /// <typeparam name="T">The type of the generic object to create.</typeparam> /// <param name="code">The object to generate.</param> /// <returns>The generated object.</returns> internal static T Compile <T>(string code) { if (code == null) { throw new System.ArgumentNullException("code == null"); } string type_string = Meta.ConvertTypeToCsharpSource(typeof(T)); string full_code = string.Concat( @"using Seven; using Seven.Structures; using Seven.Mathematics; namespace Seven.Generated { public class Generator { public static object Generate() { return (" , type_string, ")(", code, @"); } } }"); System.CodeDom.Compiler.CompilerParameters parameters = new System.CodeDom.Compiler.CompilerParameters(); parameters.ReferencedAssemblies.Add("Seven.dll"); parameters.GenerateInMemory = true; parameters.CompilerOptions = "/optimize"; #if unsafe_code parameters.CompilerOptions = "/unsafe"; #endif System.CodeDom.Compiler.CompilerResults results = new Microsoft.CSharp.CSharpCodeProvider().CompileAssemblyFromSource(parameters, full_code); if (results.Errors.HasErrors) { string error = "Generation Error\nType: " + type_string + "\nObject: " + code + "\n\nCompilation Error:"; Exception[] exceptions = new Exception[results.Errors.Count]; foreach (System.CodeDom.Compiler.CompilerError compiler_error in results.Errors) { error += compiler_error.ErrorText.ToString() + "\n"; } throw new System.FormatException(error); } System.Reflection.MethodInfo generate = results.CompiledAssembly.GetType("Seven.Generated.Generator").GetMethod("Generate"); return((T)generate.Invoke(null, null)); }
static Assembly CompileCode(string cscode) { var files = Directory.GetFiles(Directory.GetParent(Type.GetType("FreeSql.DynamicProxy, FreeSql.DynamicProxy").Assembly.Location).FullName); using (var compiler = System.CodeDom.Compiler.CodeDomProvider.CreateProvider("cs")) { var objCompilerParameters = new System.CodeDom.Compiler.CompilerParameters(); objCompilerParameters.ReferencedAssemblies.Add("System.dll"); objCompilerParameters.ReferencedAssemblies.Add("System.Core.dll"); objCompilerParameters.ReferencedAssemblies.Add("FreeSql.DynamicProxy.dll"); foreach (var dll in files) { if (!dll.EndsWith(".dll", StringComparison.OrdinalIgnoreCase) && !dll.EndsWith(".exe", StringComparison.OrdinalIgnoreCase)) { continue; } Console.WriteLine(dll); var dllName = string.Empty; var idx = dll.LastIndexOf('/'); if (idx != -1) { dllName = dll.Substring(idx + 1); } else { idx = dll.LastIndexOf('\\'); if (idx != -1) { dllName = dll.Substring(idx + 1); } } if (string.IsNullOrEmpty(dllName)) { continue; } try { var ass = Assembly.LoadFile(dll); objCompilerParameters.ReferencedAssemblies.Add(dllName); } catch { } } objCompilerParameters.GenerateExecutable = false; objCompilerParameters.GenerateInMemory = true; var cr = compiler.CompileAssemblyFromSource(objCompilerParameters, cscode); if (cr.Errors.Count > 0) { throw new Exception($"{cr.Errors[0].ErrorText} {cscode}"); } return(cr.CompiledAssembly); } }
/// <summary> /// Compiles and load scripts from a C# or VB.NET source code file. /// </summary> /// <param name="filename">The path to the code file to load.</param> /// <returns><c>true</c> on success, <c>false</c> otherwise</returns> bool LoadScriptsFromSource(string filename) { var compilerOptions = new System.CodeDom.Compiler.CompilerParameters(); compilerOptions.CompilerOptions = "/optimize"; compilerOptions.GenerateInMemory = true; compilerOptions.IncludeDebugInformation = true; compilerOptions.ReferencedAssemblies.Add("System.dll"); compilerOptions.ReferencedAssemblies.Add("System.Core.dll"); compilerOptions.ReferencedAssemblies.Add("System.Drawing.dll"); compilerOptions.ReferencedAssemblies.Add("System.Windows.Forms.dll"); compilerOptions.ReferencedAssemblies.Add("System.XML.dll"); compilerOptions.ReferencedAssemblies.Add("System.XML.Linq.dll"); // Reference the oldest scripting API to stay compatible with existing scripts compilerOptions.ReferencedAssemblies.Add(scriptApis.First().Location); compilerOptions.ReferencedAssemblies.Add(typeof(ScriptDomain).Assembly.Location); string extension = Path.GetExtension(filename); System.CodeDom.Compiler.CodeDomProvider compiler = null; if (extension.Equals(".cs", StringComparison.OrdinalIgnoreCase)) { compiler = new Microsoft.CSharp.CSharpCodeProvider(); compilerOptions.CompilerOptions += " /unsafe"; } else if (extension.Equals(".vb", StringComparison.OrdinalIgnoreCase)) { compiler = new Microsoft.VisualBasic.VBCodeProvider(); } else { return(false); } System.CodeDom.Compiler.CompilerResults compilerResult = compiler.CompileAssemblyFromFile(compilerOptions, filename); if (!compilerResult.Errors.HasErrors) { Log.Message(Log.Level.Debug, "Successfully compiled ", Path.GetFileName(filename), "."); return(LoadScriptsFromAssembly(compilerResult.CompiledAssembly, filename)); } else { var errors = new System.Text.StringBuilder(); foreach (System.CodeDom.Compiler.CompilerError error in compilerResult.Errors) { errors.Append(" at line "); errors.Append(error.Line); errors.Append(": "); errors.Append(error.ErrorText); errors.AppendLine(); } Log.Message(Log.Level.Error, "Failed to compile ", Path.GetFileName(filename), " with ", compilerResult.Errors.Count.ToString(), " error(s):", Environment.NewLine, errors.ToString()); return(false); } }
/// <summary> /// 根据指定的信息,调用远程WebService方法 /// </summary> /// <param name="url">WebService的http形式的地址</param> /// <param name="namespace">欲调用的WebService的命名空间</param> /// <param name="classname">欲调用的WebService的类名(不包括命名空间前缀)</param> /// <param name="methodname">欲调用的WebService的方法名</param> /// <param name="args">参数列表</param> /// <returns>WebService的执行结果</returns> /// <remarks> /// 如果调用失败,将会抛出Exception。请调用的时候,适当截获异常。 /// 异常信息可能会发生在两个地方: /// 1、动态构造WebService的时候,CompileAssembly失败。 /// 2、WebService本身执行失败。 /// </remarks> /// <example> /// <code> /// object obj = InvokeWebService("http://localhost/Service.asmx","method",new object[]{"1"}); /// </code> /// </example> public static object InvokeWebService(string url, string methodname, object[] args) { try { string @namespace = "WebService.DynamicWebCalling"; string[] parts = url.Split('/'); string[] pps = parts[parts.Length - 1].Split('.'); string classname = pps[0]; System.Net.WebClient wc = new System.Net.WebClient(); System.IO.Stream stream = wc.OpenRead(url + "?WSDL"); System.Web.Services.Description.ServiceDescription sd = System.Web.Services.Description.ServiceDescription.Read(stream); System.Web.Services.Description.ServiceDescriptionImporter sdi = new System.Web.Services.Description.ServiceDescriptionImporter(); sdi.AddServiceDescription(sd, "", ""); System.CodeDom.CodeNamespace cn = new System.CodeDom.CodeNamespace(@namespace); System.CodeDom.CodeCompileUnit ccu = new System.CodeDom.CodeCompileUnit(); ccu.Namespaces.Add(cn); sdi.Import(cn, ccu); Microsoft.CSharp.CSharpCodeProvider csc = new Microsoft.CSharp.CSharpCodeProvider(); System.CodeDom.Compiler.ICodeCompiler icc = csc.CreateCompiler(); System.CodeDom.Compiler.CompilerParameters cplist = new System.CodeDom.Compiler.CompilerParameters(); cplist.GenerateExecutable = false; cplist.GenerateInMemory = true; cplist.ReferencedAssemblies.Add("System.dll"); cplist.ReferencedAssemblies.Add("System.XML.dll"); cplist.ReferencedAssemblies.Add("System.Web.Services.dll"); cplist.ReferencedAssemblies.Add("System.Data.dll"); System.CodeDom.Compiler.CompilerResults cr = icc.CompileAssemblyFromDom(cplist, ccu); if (true == cr.Errors.HasErrors) { System.Text.StringBuilder sb = new System.Text.StringBuilder(); foreach (System.CodeDom.Compiler.CompilerError ce in cr.Errors) { sb.Append(ce.ToString()); sb.Append(System.Environment.NewLine); } throw new Exception(sb.ToString()); } System.Reflection.Assembly assembly = cr.CompiledAssembly; Type t = assembly.GetType(@namespace + "." + classname, true, true); object obj = Activator.CreateInstance(t); System.Reflection.MethodInfo mi = t.GetMethod(methodname); return(mi.Invoke(obj, args)); } catch (Exception ex) { StringBuilder str = new StringBuilder(); for (int m = 0; m < args.Length; m++) { str.Append(args[m]); str.Append(","); } LogUtility.DataLog.WriteLog(LogUtility.LogLevel.Info, ex.Message + "--" + ex.Source.ToString() + "--" + url + methodname + "--" + str, new LogUtility.RunningPlace("WebServiceHelper", "InvokeWebService"), "WebService获取数据失败"); return(""); } }
public Compiler() { this.provider = System.CodeDom.Compiler.CodeDomProvider.CreateProvider("CSharp"); this.cpParams = new System.CodeDom.Compiler.CompilerParameters(); this.cpParams.GenerateInMemory = false; this.cpParams.GenerateExecutable = false; // this.cpParams.OutputAssembly = @"C:\" + DateTime.Now.ToString("Mdyyyy") + ".dll"; this.sbCode = new StringBuilder(); }
private object InvokeWebservice(string url, string space, string classname, string methodname, object[] args) { try { System.Net.WebClient wc = new System.Net.WebClient(); System.IO.Stream stream = wc.OpenRead(url + "?WSDL"); System.Web.Services.Description.ServiceDescription sd = System.Web.Services.Description.ServiceDescription.Read(stream); System.Web.Services.Description.ServiceDescriptionImporter sdi = new System.Web.Services.Description.ServiceDescriptionImporter(); sdi.AddServiceDescription(sd, "", ""); System.CodeDom.CodeNamespace cn = new System.CodeDom.CodeNamespace(space); System.CodeDom.CodeCompileUnit ccu = new System.CodeDom.CodeCompileUnit(); ccu.Namespaces.Add(cn); sdi.Import(cn, ccu); Microsoft.CSharp.CSharpCodeProvider csc = new Microsoft.CSharp.CSharpCodeProvider(); System.CodeDom.Compiler.ICodeCompiler icc = csc.CreateCompiler(); System.CodeDom.Compiler.CompilerParameters cplist = new System.CodeDom.Compiler.CompilerParameters(); cplist.GenerateExecutable = false; cplist.GenerateInMemory = true; cplist.ReferencedAssemblies.Add("System.dll"); cplist.ReferencedAssemblies.Add("System.XML.dll"); cplist.ReferencedAssemblies.Add("System.Web.Services.dll"); cplist.ReferencedAssemblies.Add("System.Data.dll"); System.CodeDom.Compiler.CompilerResults cr = icc.CompileAssemblyFromDom(cplist, ccu); if (true == cr.Errors.HasErrors) { System.Text.StringBuilder sb = new System.Text.StringBuilder(); foreach (System.CodeDom.Compiler.CompilerError ce in cr.Errors) { sb.Append(ce.ToString()); sb.Append(System.Environment.NewLine); } throw new Exception(sb.ToString()); } System.Reflection.Assembly assembly = cr.CompiledAssembly; Type t = assembly.GetType(space + "." + classname, true, true); object obj = Activator.CreateInstance(t); //用来解决webservice上面有重载函数的问题 Type[] types = new Type[args.Length]; for (int i = 0; i < args.Length; i++) { types[i] = args[i].GetType(); } System.Reflection.MethodInfo mi = t.GetMethod(methodname, types); if (null == mi) { return(null); } return(mi.Invoke(obj, args)); } catch (Exception ex) { throw new Exception(ex.InnerException.Message, new Exception(ex.InnerException.StackTrace)); } }
private static Assembly Compile(string[] files) { errors = new List <System.CodeDom.Compiler.CompilerError>(); Microsoft.CSharp.CSharpCodeProvider provider; Dictionary <string, string> param = new Dictionary <string, string>(); param.Add("CompilerVersion", "v4.0"); provider = new Microsoft.CSharp.CSharpCodeProvider(param); System.CodeDom.Compiler.CompilerParameters options = new System.CodeDom.Compiler.CompilerParameters(); options.GenerateInMemory = true; options.TreatWarningsAsErrors = false; options.IncludeDebugInformation = true; List <string> refs = new List <string>(); Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies(); for (int i = 0; i < assemblies.Length; i++) { if (!assemblies[i].FullName.Contains("System.") && !assemblies[i].FullName.Contains("Microsoft.")) { refs.Add(System.IO.Path.GetFileName(assemblies[i].Location)); //refs.Add(assemblies[i].Location); } } refs.Add("System.dll"); refs.Add("System.Data.dll"); refs.Add("System.Drawing.dll"); refs.Add("System.Xml.dll"); refs.Add("System.Windows.Forms.dll"); //refs.Add("DatabaseConnector.dll"); refs.Add("System.Core.dll"); refs.Add("MySql.Data.dll"); refs.Add("DataManager.dll"); refs.Add("Server.RDungeons.dll"); refs.Add(System.Windows.Forms.Application.ExecutablePath); options.ReferencedAssemblies.AddRange(refs.ToArray()); System.CodeDom.Compiler.ICodeCompiler compiler = provider.CreateCompiler(); System.CodeDom.Compiler.CompilerResults results = compiler.CompileAssemblyFromFileBatch(options, files); foreach (System.CodeDom.Compiler.CompilerError err in results.Errors) { errors.Add(err); } if (results.Errors.Count == 0) { return(results.CompiledAssembly); } else { return(null); } }
private Assembly CompileWithCodeDom <FType>(string source) where FType : class { var references = new[] { // "Proxem.NumNet.dll" full path typeof(Proxem.NumNet.Random).Assembly.Location, // "Proxem.TheaNet.dll" full path this.GetType().Assembly.Location, // "netstandard.dll" full path (NumNet uses netstandard 2.0) // Assumes that netstandard.dll is in same folder than current assembly. Path.Combine(Path.GetDirectoryName(this.GetType().Assembly.Location), "netstandard.dll") }; var provider = new CSharpCodeProvider(); var cp = new System.CodeDom.Compiler.CompilerParameters(); cp.GenerateExecutable = false; foreach (var reference in references) { cp.ReferencedAssemblies.Add(reference); } System.CodeDom.Compiler.CompilerResults cr; if (Compiler.Debug) { cp.IncludeDebugInformation = true; cp.GenerateInMemory = false; cp.TempFiles = new System.CodeDom.Compiler.TempFileCollection(Environment.GetEnvironmentVariable("TEMP"), true); var path = Path.ChangeExtension(Path.GetTempFileName(), "cs"); //var path = "temp.cs"; File.WriteAllText(path, source); // for debugging purposes cr = provider.CompileAssemblyFromFile(cp, path); } else { cp.GenerateInMemory = true; cp.CompilerOptions = "/optimize"; cr = provider.CompileAssemblyFromSource(cp, source); } if (cr.Errors.HasErrors) { var sb = new StringBuilder(); sb.AppendLine($"Failed to compile method {nameof(FType)}."); foreach (var error in cr.Errors.Cast <System.CodeDom.Compiler.CompilerError>()) { sb.Append("CompilerError: "); sb.AppendLine(error.ToString()); } sb.AppendLine("Source code:"); sb.AppendLine(source); throw new Exception(sb.ToString()); } return(cr.CompiledAssembly); }
private static Assembly CompileCode(Assembly[] existAsms, string dllname, string code) { if (CompileCodeHandler != null) { var ccasm = CompileCodeHandler(existAsms, dllname, code); if (ccasm != null) { return(ccasm); } } //System.CodeDom.Compiler.CodeCompiler cc= System.CodeDom.Compiler.CodeCompiler var cdp = System.CodeDom.Compiler.CodeDomProvider.CreateProvider("cs"); var cp = new System.CodeDom.Compiler.CompilerParameters(); foreach (Assembly asm in existAsms) { cp.ReferencedAssemblies.Add(asm.Location); } cp.GenerateExecutable = false; cp.GenerateInMemory = true; cp.IncludeDebugInformation = true; cp.OutputAssembly = dllname; var cr = cdp.CompileAssemblyFromSource(cp, code); foreach (System.CodeDom.Compiler.CompilerError err in cr.Errors) { string msg = err.ToString(); if (msg.Contains("System.Runtime.CompilerServices.ExtensionAttribute")) { //ignore } else { WriteDebugLine(err.ToString()); } if (err.IsWarning) { continue; } foreach (var asm in existAsms) { Console.WriteLine(asm.FullName); } throw new Exception(err.ToString()); } WriteDebugLine("new assembly compiled : " + cr.CompiledAssembly.FullName); var resasm = cr.CompiledAssembly; return(resasm); }
internal static System.CodeDom.Compiler.CompilerParameters GenerateParameters(string saveToPath) { System.CodeDom.Compiler.CompilerParameters para = new System.CodeDom.Compiler.CompilerParameters(); para.GenerateExecutable = false; para.GenerateInMemory = false; para.OutputAssembly = saveToPath; para.ReferencedAssemblies.Add(System.Windows.Forms.Application.ExecutablePath); para.ReferencedAssemblies.Add("System.Windows.Forms.dll"); para.ReferencedAssemblies.Add("System.dll"); return(para); }
internal static System.CodeDom.Compiler.CompilerParameters GenerateParameters(string saveToPath) { System.CodeDom.Compiler.CompilerParameters para = new System.CodeDom.Compiler.CompilerParameters(); para.GenerateExecutable = false; para.GenerateInMemory = false; para.OutputAssembly = saveToPath; para.ReferencedAssemblies.Add(System.Windows.Forms.Application.ExecutablePath); para.ReferencedAssemblies.Add("System.Windows.Forms.dll"); para.ReferencedAssemblies.Add("System.dll"); return para; }
private static void ReferenceTypesIfNotExist(System.CodeDom.Compiler.CompilerParameters cp, List <Assembly> assemblies, params Type[] paramTypes) { foreach (var paramType in paramTypes) { if (!assemblies.Contains(paramType.Assembly)) { assemblies.Add(paramType.Assembly); AddAssembly(cp, paramType.Assembly.Location); } } }
private static void AddAssembly(System.CodeDom.Compiler.CompilerParameters cp, string location) { //Error if trying to re-add ref to mscorlib or System.Core for .NET 4.0 if (IsVersion4AndUp && (location == typeof(string).Assembly.Location || location == typeof(Expression).Assembly.Location)) { return; } cp.ReferencedAssemblies.Add(location); }
public ASLMethod(String code) { using (var provider = new Microsoft.CSharp.CSharpCodeProvider()) { var builder = new StringBuilder(); builder .AppendLine("using System;") .AppendLine("using System.Collections.Generic;") .AppendLine("using System.Linq;") .AppendLine("using System.Reflection;") .AppendLine("using System.Text;") .AppendLine("public class CompiledScript") .AppendLine("{") .AppendLine("public dynamic Execute(dynamic timer, dynamic old, dynamic current)") .AppendLine("{") .Append(code) .Append("return null;") .AppendLine("}") .AppendLine("}"); var parameters = new System.CodeDom.Compiler.CompilerParameters() { GenerateInMemory = true, CompilerOptions = "/optimize", }; parameters.ReferencedAssemblies.Add("System.dll"); parameters.ReferencedAssemblies.Add("System.Core.dll"); parameters.ReferencedAssemblies.Add("System.Data.dll"); parameters.ReferencedAssemblies.Add("System.Data.DataSetExtensions.dll"); parameters.ReferencedAssemblies.Add("System.Drawing.dll"); parameters.ReferencedAssemblies.Add("System.Windows.Forms.dll"); parameters.ReferencedAssemblies.Add("System.Xml.dll"); parameters.ReferencedAssemblies.Add("System.Xml.Linq.dll"); parameters.ReferencedAssemblies.Add("Microsoft.CSharp.dll"); var res = provider.CompileAssemblyFromSource(parameters, builder.ToString()); if (res.Errors.HasErrors) { var errorMessage = ""; foreach (var error in res.Errors) { errorMessage += error + "\r\n"; } throw new ArgumentException(errorMessage, "code"); } var type = res.CompiledAssembly.GetType("CompiledScript"); CompiledCode = Activator.CreateInstance(type); } }
//public void SendMail(string mailTo, string mailSubject, string content) //{ // object[] methodParams = new object[4]; // methodParams[0] = new object(); // methodParams[1] = new object(); // methodParams[2] = new object(); // methodParams[3] = new object(); // methodParams[0] = mailTo; // methodParams[1] = true; // methodParams[2] = mailSubject; // methodParams[3] = content; // InvokeWebservice(ConfigData.MailURL, "Achievo.MMIP.CommonWebService", "EMail", "SendByAdmin", methodParams); //} /// 根据指定的信息,调用远程WebService方法 /// </summary> /// <param name="url">WebService的http形式的地址</param> /// <param name="namespace">欲调用的WebService的命名空间</param> /// <param name="classname">欲调用的WebService的类名(不包括命名空间前缀)</param> /// <param name="methodname">欲调用的WebService的方法名</param> /// <param name="args">参数列表</param> /// <returns>WebService的执行结果</returns> /// <remarks> /// 如果调用失败,将会抛出Exception。请调用的时候,适当截获异常。 /// 异常信息可能会发生在两个地方: /// 1、动态构造WebService的时候,CompileAssembly失败。 /// 2、WebService本身执行失败。 /// </remarks> /// <example> /// <code> /// object obj = InvokeWebservice("http://localhost/GSP_WorkflowWebservice/common.asmx", /// "Genersoft.Platform.Service.Workflow", /// "Common", /// "GetToolType", /// new object[]{"1"}); /// </code> /// </example> public object InvokeWebservice(string url, string @namespace, string classname, string methodname, object[] args) { try { System.Net.WebClient wc = new System.Net.WebClient(); System.IO.Stream stream = wc.OpenRead(url + "?WSDL"); System.Web.Services.Description.ServiceDescription sd = System.Web.Services.Description.ServiceDescription.Read(stream); System.Web.Services.Description.ServiceDescriptionImporter sdi = new System.Web.Services.Description.ServiceDescriptionImporter(); sdi.AddServiceDescription(sd, "", ""); System.CodeDom.CodeNamespace cn = new System.CodeDom.CodeNamespace(@namespace); System.CodeDom.CodeCompileUnit ccu = new System.CodeDom.CodeCompileUnit(); ccu.Namespaces.Add(cn); sdi.Import(cn, ccu); Microsoft.CSharp.CSharpCodeProvider csc = new Microsoft.CSharp.CSharpCodeProvider(); System.CodeDom.Compiler.ICodeCompiler icc = csc.CreateCompiler(); System.CodeDom.Compiler.CompilerParameters cplist = new System.CodeDom.Compiler.CompilerParameters(); cplist.GenerateExecutable = false; cplist.GenerateInMemory = true; cplist.ReferencedAssemblies.Add("System.dll"); cplist.ReferencedAssemblies.Add("System.XML.dll"); cplist.ReferencedAssemblies.Add("System.Web.Services.dll"); cplist.ReferencedAssemblies.Add("System.Data.dll"); System.CodeDom.Compiler.CompilerResults cr = icc.CompileAssemblyFromDom(cplist, ccu); if (true == cr.Errors.HasErrors) { System.Text.StringBuilder sb = new System.Text.StringBuilder(); foreach (System.CodeDom.Compiler.CompilerError ce in cr.Errors) { sb.Append(ce.ToString()); sb.Append(System.Environment.NewLine); } throw new Exception(sb.ToString()); } System.Reflection.Assembly assembly = cr.CompiledAssembly; Type t = assembly.GetType(@namespace + "." + classname, true, true); object obj = Activator.CreateInstance(t); System.Reflection.MethodInfo mi = t.GetMethod(methodname); return mi.Invoke(obj, args); } catch (Exception ex) { throw new Exception(ex.InnerException.Message, new Exception(ex.InnerException.StackTrace)); } }
public Assembly CompileScriptFiles( String[] fullScriptFilePaths ) { List<String> cSharpFiles = new List<String>(); #region Save as temp CS files foreach( String file in fullScriptFilePaths ) { StreamWriter sw = new StreamWriter( file + ".cs" ); sw.Write( TransformScriptFileToCSharp( file ) ); sw.Close(); cSharpFiles.Add( file + ".cs" ); } #endregion Assembly assembly = null; CSharpCodeProvider codeProvider = new CSharpCodeProvider(); System.CodeDom.Compiler.CompilerParameters compilerParameters = new System.CodeDom.Compiler.CompilerParameters(); compilerParameters.GenerateExecutable = false; compilerParameters.GenerateInMemory = false; System.CodeDom.Compiler.CompilerResults compilerResults = codeProvider.CompileAssemblyFromFile( compilerParameters, cSharpFiles.ToArray() ); foreach( System.CodeDom.Compiler.CompilerError error in compilerResults.Errors ) { NotificationDetails details = new NotificationDetails(); details.FileName = error.FileName; details.Row = error.Column; details.Collumn = error.Line; details.Message = error.ErrorText; if( error.IsWarning ) OnWarningOccured( this, details ); else OnErrorOccured( this, details ); } return assembly; }
public static byte[] GenerateAssembly(string namespaceName, string className, params CodeMemberMethod[] methods) { CodeCompileUnit unit = new CodeCompileUnit(); CodeNamespace space = new CodeNamespace(namespaceName); CodeTypeDeclaration type = new CodeTypeDeclaration(className); type.Attributes = MemberAttributes.Static | MemberAttributes.Public; type.TypeAttributes = System.Reflection.TypeAttributes.Public | System.Reflection.TypeAttributes.Sealed; type.Members.AddRange(methods); space.Types.Add(type); unit.Namespaces.Add(space); Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider(); System.CodeDom.Compiler.CompilerParameters options = new System.CodeDom.Compiler.CompilerParameters(); options.IncludeDebugInformation = false; options.GenerateExecutable = false; options.ReferencedAssemblies.Add(typeof(int).Assembly.Location); options.ReferencedAssemblies.Add(typeof(Vector2).Assembly.Location); System.CodeDom.Compiler.CompilerResults results = provider.CompileAssemblyFromDom(options,unit); System.CodeDom.Compiler.CodeGeneratorOptions ops = new System.CodeDom.Compiler.CodeGeneratorOptions(); ops.IndentString = "\t"; ops.VerbatimOrder = true; ops.BracingStyle = "C"; StringWriter text = new StringWriter(); provider.GenerateCodeFromCompileUnit(unit, text, ops); string code = text.ToString(); if (results.Errors.HasErrors) { string errors = ""; foreach (System.CodeDom.Compiler.CompilerError error in results.Errors) { errors += error.ToString() + Environment.NewLine; } throw new InvalidOperationException(errors); } byte[] data = File.ReadAllBytes(results.PathToAssembly); File.Delete(results.PathToAssembly); return data; }
private static string CompileString(string csharpCode, string outFile) { var provider = new Microsoft.CSharp.CSharpCodeProvider(); var parameters = new System.CodeDom.Compiler.CompilerParameters { OutputAssembly = outFile, GenerateExecutable = false, GenerateInMemory = false }; parameters.ReferencedAssemblies.Add(typeof(ExportAttribute).Assembly.Location); parameters.ReferencedAssemblies.Add(typeof(IPythonInterpreterFactoryProvider).Assembly.Location); var result = provider.CompileAssemblyFromSource(parameters, csharpCode); if (result.Errors.HasErrors) { foreach (var err in result.Errors) { Console.WriteLine(err); } } if (!File.Exists(outFile)) { Assert.Fail("Failed to compile {0}", outFile); } _tempFiles.Add(outFile); return outFile; }
internal static IPageClassFactory GetPageClassFactory() { System.CodeDom.Compiler.CodeDomProvider provider = System.CodeDom.Compiler.CodeDomProvider.CreateProvider("CSharp"); System.CodeDom.Compiler.CompilerParameters cp = new System.CodeDom.Compiler.CompilerParameters(); cp.GenerateExecutable = false; cp.GenerateInMemory = true; cp.TempFiles = new System.CodeDom.Compiler.TempFileCollection(Xy.AppSetting.LogDir); for (int i = 0; i < PageClassLibrary.Assemblys.Count; i++) { cp.ReferencedAssemblies.Add(binFileDir + PageClassLibrary.Assemblys[i] + ".dll"); } StringBuilder code = new StringBuilder(); code.AppendLine("namespace Xy.Runtime.Web {"); code.AppendLine("public class PageClassFacgory : Xy.Runtime.Web.IPageClassFactory {"); code.AppendLine("public Xy.Web.Page.PageAbstract GetPageClass(string key) {"); code.AppendLine("switch (key) {"); for (int i = 0; i < PageClassLibrary.ClassFullNames.Count; i++) { code.AppendLine(string.Format("case \"{0}\": case \"{1}\": return new {1}();", PageClassLibrary.ClassFullNames[i], PageClassLibrary.ClassFullNames[i].Split(',')[1])); } code.AppendLine("default: throw new System.Exception(\"Can not found page class with key: \" + key);"); code.AppendLine("}"); code.AppendLine("} } }"); System.CodeDom.Compiler.CompilerResults cr = provider.CompileAssemblyFromSource(cp, code.ToString()); foreach (System.CodeDom.Compiler.CompilerError _error in cr.Errors) { string[] codes = code.ToString().Split(new string[] { Environment.NewLine, "\n", "\r" }, StringSplitOptions.None); if (_error.Line > 0) { throw new Exception(string.Format("error:\"{0}\" on \"{1}\"", _error.ErrorText, codes[_error.Line - 1])); } else { throw new Exception(string.Format("error:\"{0}\"", _error.ErrorText)); } } return cr.CompiledAssembly.CreateInstance("Xy.Runtime.Web.PageClassFacgory") as IPageClassFactory; }
private System.Reflection.Assembly buildAssembly(string Language, string Expression, string Depend) { System.CodeDom.Compiler.CodeDomProvider provider; switch (Language) { case "CSharp": provider = System.CodeDom.Compiler.CodeDomProvider.CreateProvider("CSharp"); break; case "VisalBasic": provider = System.CodeDom.Compiler.CodeDomProvider.CreateProvider("VisalBasic"); break; default: throw new Exception("Unknow language: " + Language); } System.CodeDom.Compiler.CompilerParameters cp = new System.CodeDom.Compiler.CompilerParameters(); cp.GenerateExecutable = false; cp.GenerateInMemory = true; cp.TempFiles = new System.CodeDom.Compiler.TempFileCollection(Xy.AppSetting.LogDir); //cp.CompilerOptions = "/nooutput"; if (!string.IsNullOrEmpty(Depend)) { string[] _userdepends = Depend.Split(','); List<string> _depends = new List<string>(); _depends.Add("Xy.Data.dll"); _depends.Add("XiaoYang.Installation.dll"); for (int i = 0; i < _userdepends.Length; i++) { if (!_depends.Contains(_userdepends[i]) && checkDependDLL(_userdepends[i])) _depends.Add(_userdepends[i]); } for (int i = 0; i < _depends.Count; i++) { cp.ReferencedAssemblies.Add(binFileDir + _depends[i]); } } StringBuilder code = new StringBuilder(); switch (Language) { case "CSharp": code.AppendLine("namespace XyUpdate {"); code.AppendLine("public class XyUpdate : XiaoYang.Installation.IInstallItem {"); code.AppendLine("public void Update(Xy.Data.DataBase updateDB) {"); code.AppendLine(Expression); code.AppendLine("} } }"); break; case "VisalBasic": code.AppendLine("Namespace XyUpdate"); code.AppendLine("Public Class XyUpdate Implements XiaoYang.Installation.IInstallItem"); code.AppendLine("Public Sub Update(updateDB as Xy.Data.DataBase)"); code.AppendLine(Expression); code.AppendLine("End Function"); code.AppendLine("End Class"); code.AppendLine("End Namespace"); break; default: throw new Exception("Unknow language: " + Language); } System.CodeDom.Compiler.CompilerResults cr = provider.CompileAssemblyFromSource(cp, code.ToString()); foreach (System.CodeDom.Compiler.CompilerError _error in cr.Errors) { string[] codes = code.ToString().Split(new string[] { Environment.NewLine, "\n", "\r" }, StringSplitOptions.None); if (_error.Line > 0) { throw new Exception(string.Format("error:\"{0}\" on \"{1}\"", _error.ErrorText, codes[_error.Line - 1])); } else { throw new Exception(string.Format("error:\"{0}\"", _error.ErrorText)); } } return cr.CompiledAssembly; }
public static object UploadData(string url, string @namespace, string classname, string methodname, object[] args, ArrayList al) { try { System.Net.WebClient wc = new System.Net.WebClient(); //System.IO.Stream stream = wc.OpenRead(url + "?WSDL"); System.IO.Stream stream = wc.OpenRead(url); System.Web.Services.Description.ServiceDescription sd = System.Web.Services.Description.ServiceDescription.Read(stream); System.Web.Services.Description.ServiceDescriptionImporter sdi = new System.Web.Services.Description.ServiceDescriptionImporter(); sdi.AddServiceDescription(sd, string.Empty, string.Empty); //将sd描述导入到sdi中 System.CodeDom.CodeNamespace cn = new System.CodeDom.CodeNamespace(@namespace); System.CodeDom.CodeCompileUnit ccu = new System.CodeDom.CodeCompileUnit(); ccu.Namespaces.Add(cn); sdi.Import(cn, ccu); Microsoft.CSharp.CSharpCodeProvider csc = new Microsoft.CSharp.CSharpCodeProvider(); System.CodeDom.Compiler.ICodeCompiler icc = csc.CreateCompiler(); System.CodeDom.Compiler.CompilerParameters cplist = new System.CodeDom.Compiler.CompilerParameters(); cplist.GenerateExecutable = false; cplist.GenerateInMemory = true; cplist.ReferencedAssemblies.Add("System.dll"); cplist.ReferencedAssemblies.Add("System.XML.dll"); cplist.ReferencedAssemblies.Add("System.Web.Services.dll"); cplist.ReferencedAssemblies.Add("System.Data.dll"); System.CodeDom.Compiler.CompilerResults cr = icc.CompileAssemblyFromDom(cplist, ccu); if (cr.Errors.HasErrors) { System.Text.StringBuilder sb = new System.Text.StringBuilder(); foreach (System.CodeDom.Compiler.CompilerError ce in cr.Errors) { sb.Append(ce.ToString()); sb.Append(System.Environment.NewLine); } throw new Exception(sb.ToString()); } System.Reflection.Assembly assembly = cr.CompiledAssembly; Type t = assembly.GetType(@namespace + "." + classname, true, true); object obj = Activator.CreateInstance(t); ParameterModifier[] paramsModifer = new ParameterModifier[1]; paramsModifer[0] = new ParameterModifier(args.Length); //paramsModifer[0][7] = true; object result = t.InvokeMember(methodname, BindingFlags.Default | BindingFlags.InvokeMethod, null, obj, args, paramsModifer, null, null); //al.Add(args[7]); return result; } catch (Exception ex) { WriteLog(ex.Message, EXCEPTION_LOG_TITLE); return null; } }
private void _SaveSfxStub(string exeToGenerate, SelfExtractorSaveOptions options) { string nameOfIconFile = null; string stubExe = null; string unpackedResourceDir = null; string tmpDir = null; try { if (File.Exists(exeToGenerate)) { if (Verbose) StatusMessageTextWriter.WriteLine("The existing file ({0}) will be overwritten.", exeToGenerate); } if (!exeToGenerate.EndsWith(".exe")) { if (Verbose) StatusMessageTextWriter.WriteLine("Warning: The generated self-extracting file will not have an .exe extension."); } // workitem 10553 tmpDir = TempFileFolder ?? Path.GetDirectoryName(exeToGenerate); stubExe = GenerateTempPathname(tmpDir, "exe"); // get the Ionic.Zip assembly Assembly a1 = typeof(ZipFile).Assembly; using (var csharp = new Microsoft.CSharp.CSharpCodeProvider (new Dictionary<string,string>() { { "CompilerVersion", "v2.0" } })) { // The following is a perfect opportunity for a linq query, but // I cannot use it. DotNetZip needs to run on .NET 2.0, // and using LINQ would break that. Here's what it would look // like: // // var settings = (from x in SettingsList // where x.Flavor == flavor // select x).First(); ExtractorSettings settings = null; foreach (var x in SettingsList) { if (x.Flavor == options.Flavor) { settings = x; break; } } // sanity check; should never happen if (settings == null) throw new BadStateException(String.Format("While saving a Self-Extracting Zip, Cannot find that flavor ({0})?", options.Flavor)); // This is the list of referenced assemblies. Ionic.Zip is // needed here. Also if it is the winforms (gui) extractor, we // need other referenced assemblies, like // System.Windows.Forms.dll, etc. var cp = new System.CodeDom.Compiler.CompilerParameters(); cp.ReferencedAssemblies.Add(a1.Location); if (settings.ReferencedAssemblies != null) foreach (string ra in settings.ReferencedAssemblies) cp.ReferencedAssemblies.Add(ra); cp.GenerateInMemory = false; cp.GenerateExecutable = true; cp.IncludeDebugInformation = false; cp.CompilerOptions = ""; Assembly a2 = Assembly.GetExecutingAssembly(); // Use this to concatenate all the source code resources into a // single module. var sb = new System.Text.StringBuilder(); // In case there are compiler errors later, we allocate a source // file name now. If errors are detected, we'll spool the source // code as well as the errors (in comments) into that filename, // and throw an exception with the filename. Makes it easier to // diagnose. This should be rare; most errors happen only // during devlpmt of DotNetZip itself, but there are rare // occasions when they occur in other cases. string sourceFile = GenerateTempPathname(tmpDir, "cs"); // // debugging: enumerate the resources in this assembly // Console.WriteLine("Resources in this assembly:"); // foreach (string rsrc in a2.GetManifestResourceNames()) // { // Console.WriteLine(rsrc); // } // Console.WriteLine(); // all the source code is embedded in the DLL as a zip file. using (ZipFile zip = ZipFile.Read(a2.GetManifestResourceStream("Ionic.Zip.Resources.ZippedResources.zip"))) { // // debugging: enumerate the files in the embedded zip // Console.WriteLine("Entries in the embbedded zip:"); // foreach (ZipEntry entry in zip) // { // Console.WriteLine(entry.FileName); // } // Console.WriteLine(); unpackedResourceDir = GenerateTempPathname(tmpDir, "tmp"); if (String.IsNullOrEmpty(options.IconFile)) { // Use the ico file that is embedded into the Ionic.Zip // DLL itself. To do this we must unpack the icon to // the filesystem, in order to specify it on the cmdline // of csc.exe. This method will remove the unpacked // file later. System.IO.Directory.CreateDirectory(unpackedResourceDir); ZipEntry e = zip["zippedFile.ico"]; // Must not extract a readonly file - it will be impossible to // delete later. if ((e.Attributes & FileAttributes.ReadOnly) == FileAttributes.ReadOnly) e.Attributes ^= FileAttributes.ReadOnly; e.Extract(unpackedResourceDir); nameOfIconFile = Path.Combine(unpackedResourceDir, "zippedFile.ico"); cp.CompilerOptions += String.Format("/win32icon:\"{0}\"", nameOfIconFile); } else cp.CompilerOptions += String.Format("/win32icon:\"{0}\"", options.IconFile); cp.OutputAssembly = stubExe; if (options.Flavor == SelfExtractorFlavor.WinFormsApplication) cp.CompilerOptions += " /target:winexe"; if (!String.IsNullOrEmpty(options.AdditionalCompilerSwitches)) cp.CompilerOptions += " " + options.AdditionalCompilerSwitches; if (String.IsNullOrEmpty(cp.CompilerOptions)) cp.CompilerOptions = null; if ((settings.CopyThroughResources != null) && (settings.CopyThroughResources.Count != 0)) { if (!Directory.Exists(unpackedResourceDir)) System.IO.Directory.CreateDirectory(unpackedResourceDir); foreach (string re in settings.CopyThroughResources) { string filename = Path.Combine(unpackedResourceDir, re); ExtractResourceToFile(a2, re, filename); // add the file into the target assembly as an embedded resource cp.EmbeddedResources.Add(filename); } } // add the Ionic.Utils.Zip DLL as an embedded resource cp.EmbeddedResources.Add(a1.Location); // file header sb.Append("// " + Path.GetFileName(sourceFile) + "\n") .Append("// --------------------------------------------\n//\n") .Append("// This SFX source file was generated by DotNetZip ") .Append(ZipFile.LibraryVersion.ToString()) .Append("\n// at ") .Append(System.DateTime.Now.ToString("yyyy MMMM dd HH:mm:ss")) .Append("\n//\n// --------------------------------------------\n\n\n"); // assembly attributes if (!String.IsNullOrEmpty(options.Description)) sb.Append("[assembly: System.Reflection.AssemblyTitle(\"" + options.Description.Replace("\"", "") + "\")]\n"); else sb.Append("[assembly: System.Reflection.AssemblyTitle(\"DotNetZip SFX Archive\")]\n"); if (!String.IsNullOrEmpty(options.ProductVersion)) sb.Append("[assembly: System.Reflection.AssemblyInformationalVersion(\"" + options.ProductVersion.Replace("\"", "") + "\")]\n"); // workitem string copyright = (String.IsNullOrEmpty(options.Copyright)) ? "Extractor: Copyright © Dino Chiesa 2008-2011" : options.Copyright.Replace("\"", ""); if (!String.IsNullOrEmpty(options.ProductName)) sb.Append("[assembly: System.Reflection.AssemblyProduct(\"") .Append(options.ProductName.Replace("\"", "")) .Append("\")]\n"); else sb.Append("[assembly: System.Reflection.AssemblyProduct(\"DotNetZip\")]\n"); sb.Append("[assembly: System.Reflection.AssemblyCopyright(\"" + copyright + "\")]\n") .Append(String.Format("[assembly: System.Reflection.AssemblyVersion(\"{0}\")]\n", ZipFile.LibraryVersion.ToString())); if (options.FileVersion != null) sb.Append(String.Format("[assembly: System.Reflection.AssemblyFileVersion(\"{0}\")]\n", options.FileVersion.ToString())); sb.Append("\n\n\n"); // Set the default extract location if it is available string extractLoc = options.DefaultExtractDirectory; if (extractLoc != null) { // remove double-quotes and replace slash with double-slash. // This, because the value is going to be embedded into a // cs file as a quoted string, and it needs to be escaped. extractLoc = extractLoc.Replace("\"", "").Replace("\\", "\\\\"); } string postExCmdLine = options.PostExtractCommandLine; if (postExCmdLine != null) { postExCmdLine = postExCmdLine.Replace("\\", "\\\\"); postExCmdLine = postExCmdLine.Replace("\"", "\\\""); } foreach (string rc in settings.ResourcesToCompile) { using (Stream s = zip[rc].OpenReader()) { if (s == null) throw new ZipException(String.Format("missing resource '{0}'", rc)); using (StreamReader sr = new StreamReader(s)) { while (sr.Peek() >= 0) { string line = sr.ReadLine(); if (extractLoc != null) line = line.Replace("@@EXTRACTLOCATION", extractLoc); line = line.Replace("@@REMOVE_AFTER_EXECUTE", options.RemoveUnpackedFilesAfterExecute.ToString()); line = line.Replace("@@QUIET", options.Quiet.ToString()); if (!String.IsNullOrEmpty(options.SfxExeWindowTitle)) line = line.Replace("@@SFX_EXE_WINDOW_TITLE", options.SfxExeWindowTitle); line = line.Replace("@@EXTRACT_EXISTING_FILE", ((int)options.ExtractExistingFile).ToString()); if (postExCmdLine != null) line = line.Replace("@@POST_UNPACK_CMD_LINE", postExCmdLine); sb.Append(line).Append("\n"); } } sb.Append("\n\n"); } } } string LiteralSource = sb.ToString(); #if DEBUGSFX // for debugging only string sourceModule = GenerateTempPathname(tmpDir, "cs"); using (StreamWriter sw = File.CreateText(sourceModule)) { sw.Write(LiteralSource); } Console.WriteLine("source: {0}", sourceModule); #endif var cr = csharp.CompileAssemblyFromSource(cp, LiteralSource); if (cr == null) throw new SfxGenerationException("Cannot compile the extraction logic!"); if (Verbose) foreach (string output in cr.Output) StatusMessageTextWriter.WriteLine(output); if (cr.Errors.Count != 0) { using (TextWriter tw = new StreamWriter(sourceFile)) { // first, the source we compiled tw.Write(LiteralSource); // now, append the compile errors tw.Write("\n\n\n// ------------------------------------------------------------------\n"); tw.Write("// Errors during compilation: \n//\n"); string p = Path.GetFileName(sourceFile); foreach (System.CodeDom.Compiler.CompilerError error in cr.Errors) { tw.Write(String.Format("// {0}({1},{2}): {3} {4}: {5}\n//\n", p, // 0 error.Line, // 1 error.Column, // 2 error.IsWarning ? "Warning" : "error", // 3 error.ErrorNumber, // 4 error.ErrorText)); // 5 } } throw new SfxGenerationException(String.Format("Errors compiling the extraction logic! {0}", sourceFile)); } OnSaveEvent(ZipProgressEventType.Saving_AfterCompileSelfExtractor); // Now, copy the resulting EXE image to the _writestream. // Because this stub exe is being saved first, the effect will be to // concatenate the exe and the zip data together. using (System.IO.Stream input = System.IO.File.OpenRead(stubExe)) { byte[] buffer = new byte[4000]; int n = 1; while (n != 0) { n = input.Read(buffer, 0, buffer.Length); if (n != 0) WriteStream.Write(buffer, 0, n); } } } OnSaveEvent(ZipProgressEventType.Saving_AfterSaveTempArchive); } finally { try { if (Directory.Exists(unpackedResourceDir)) { try { Directory.Delete(unpackedResourceDir, true); } catch (System.IO.IOException exc1) { StatusMessageTextWriter.WriteLine("Warning: Exception: {0}", exc1); } } if (File.Exists(stubExe)) { try { File.Delete(stubExe); } catch (System.IO.IOException exc1) { StatusMessageTextWriter.WriteLine("Warning: Exception: {0}", exc1); } } } catch (System.IO.IOException) { } } return; }
private bool CompileScripts( ) { if( _assets.ScriptItems.Count != 0 ) { string folder = Path.Combine( Global.World.BuildFolderPath, "Content" ); if( !Directory.Exists( folder ) ) Directory.CreateDirectory( folder ); string[] scripts = new string[_assets.ScriptItems.Count]; int i = 0; foreach( ScriptAssetItem scriptItem in _assets.ScriptItems.Values ) { scripts[i] = scriptItem.FilePath; i++; } string dllPath = Path.Combine( folder, "scripts.dll" ); Microsoft.CSharp.CSharpCodeProvider codeProvider = new Microsoft.CSharp.CSharpCodeProvider( ); System.CodeDom.Compiler.CompilerParameters parameters = new System.CodeDom.Compiler.CompilerParameters( ); parameters.GenerateExecutable = false; parameters.OutputAssembly = dllPath; parameters.ReferencedAssemblies.Add( "mscorlib.dll" ); parameters.ReferencedAssemblies.Add( "LunarEngine.dll" ); parameters.ReferencedAssemblies.Add( "Farseer Physics 3.0.dll" ); parameters.ReferencedAssemblies.Add( Assembly.GetAssembly( typeof( Microsoft.Xna.Framework.Input.Keys ) ).Location ); parameters.ReferencedAssemblies.Add( Assembly.GetAssembly( typeof( Microsoft.Xna.Framework.Game ) ).Location ); if( File.Exists( Global.World.PluginsFilePath ) ) { using( StreamReader file = new StreamReader( File.OpenRead( Global.World.PluginsFilePath ) ) ) { while( !file.EndOfStream ) { string path = Path.Combine( Global.World.WorldFolderPath, file.ReadLine( ) ); if( File.Exists( path ) ) parameters.ReferencedAssemblies.Add( path ); else { MessageBox.Show( Path.GetFileName( path ) + " plugin is missing!" ); return false; } } } } System.CodeDom.Compiler.CompilerResults results = codeProvider.CompileAssemblyFromFile( parameters, scripts ); _scriptEditor.DisplayErrors( results.Errors ); if( results.Errors.HasErrors || results.Errors.HasWarnings ) { _scriptEditor.FocusErrorsDock( ); if( results.Errors.HasErrors ) return false; } } _compiledScripts = true; _itemBuildScripts.Enabled = false; return true; }
private static Assembly GenerateLameFacadeAssembly(string lameDllName) { var thisAsm = typeof(Mp3AudioEncoderLame).Assembly; var compiler = new Microsoft.CSharp.CSharpCodeProvider(); var compilerOptions = new System.CodeDom.Compiler.CompilerParameters() { GenerateInMemory = true, GenerateExecutable = false, IncludeDebugInformation = false, CompilerOptions = "/optimize", ReferencedAssemblies = {"mscorlib.dll", thisAsm.Location} }; var source = GetLameFacadeAssemblySource(lameDllName, thisAsm); var compilerResult = compiler.CompileAssemblyFromSource(compilerOptions, source); if (compilerResult.Errors.HasErrors) { throw new Exception("Could not generate LAME facade assembly."); } return compilerResult.CompiledAssembly; }
public Compilation(Module targetModule, CompilationUnitList compilationUnits, System.CodeDom.Compiler.CompilerParameters compilerParameters, Scope globalScope) : base(NodeType.Compilation) { this.CompilationUnits = compilationUnits; this.TargetModule = targetModule; this.CompilerParameters = compilerParameters; this.GlobalScope = globalScope; }
public void HiddenAssemblyTest() { const string code = @" namespace Foo { public class HiddenAssemblyLogger { public void LogDebug(NLog.Logger logger) { logger.Debug(""msg""); } } } "; var provider = new Microsoft.CSharp.CSharpCodeProvider(); var parameters = new System.CodeDom.Compiler.CompilerParameters(); // reference the NLog dll parameters.ReferencedAssemblies.Add("NLog.dll"); // the assembly should be generated in memory parameters.GenerateInMemory = true; // generate a dll instead of an executable parameters.GenerateExecutable = false; // compile code and generate assembly System.CodeDom.Compiler.CompilerResults results = provider.CompileAssemblyFromSource(parameters, code); Assert.False(results.Errors.HasErrors); // create nlog configuration LogManager.Configuration = CreateConfigurationFromString(@" <nlog> <targets><target name='debug' type='Debug' layout='${callsite} ${message}' /></targets> <rules> <logger name='*' minlevel='Debug' writeTo='debug' /> </rules> </nlog>"); // create logger Logger logger = LogManager.GetLogger("A"); // load HiddenAssemblyLogger type Assembly compiledAssembly = results.CompiledAssembly; Type hiddenAssemblyLoggerType = compiledAssembly.GetType("Foo.HiddenAssemblyLogger"); Assert.NotNull(hiddenAssemblyLoggerType); // load methodinfo MethodInfo logDebugMethod = hiddenAssemblyLoggerType.GetMethod("LogDebug"); Assert.NotNull(logDebugMethod); // instantiate the HiddenAssemblyLogger from previously generated assembly object instance = Activator.CreateInstance(hiddenAssemblyLoggerType); // Add the previously generated assembly to the "blacklist" LogManager.AddHiddenAssembly(compiledAssembly); // call the log method logDebugMethod.Invoke(instance, new object[] { logger }); MethodBase currentMethod = MethodBase.GetCurrentMethod(); AssertDebugLastMessage("debug", currentMethod.DeclaringType.FullName + "." + currentMethod.Name + " msg"); }
private void initDimensional(string expression) { Microsoft.CSharp.CSharpCodeProvider cp = new Microsoft.CSharp.CSharpCodeProvider(); System.CodeDom.Compiler.ICodeCompiler ic = cp.CreateCompiler(); System.CodeDom.Compiler.CompilerParameters cpar = new System.CodeDom.Compiler.CompilerParameters(); cpar.GenerateInMemory = true; cpar.GenerateExecutable = false; cpar.ReferencedAssemblies.Add("system.dll"); cpar.ReferencedAssemblies.Add("ComputingMath.dll"); string src = "using System;" + "class myclass : ComputingMath.Parsing.Function" + "{" + "public myclass(){}" + "public override double evaluate(double[] x)" + "{" + "return " + expression + ";" + "}" + "}"; System.CodeDom.Compiler.CompilerResults cr = ic.CompileAssemblyFromSource(cpar, src); foreach (System.CodeDom.Compiler.CompilerError ce in cr.Errors) { throw new ParsingErrorException(ce.ErrorText); } if ((cr.Errors.Count == 0) && (cr.CompiledAssembly != null)) { Type ObjType = cr.CompiledAssembly.GetType("myclass"); try { if (ObjType != null) { myFunction = (Function)Activator.CreateInstance(ObjType); } } catch (Exception exception) { throw new ParsingErrorException("Unexpected error due to parsing function!", exception); } } else { throw new ParsingErrorException("Error parsing function!"); } }
private static Assembly Compile(string[] files) { errors = new List<System.CodeDom.Compiler.CompilerError>(); Microsoft.CSharp.CSharpCodeProvider provider; Dictionary<string, string> param = new Dictionary<string, string>(); param.Add("CompilerVersion", "v4.0"); provider = new Microsoft.CSharp.CSharpCodeProvider(param); System.CodeDom.Compiler.CompilerParameters options = new System.CodeDom.Compiler.CompilerParameters(); options.GenerateInMemory = true; options.TreatWarningsAsErrors = false; options.IncludeDebugInformation = true; List<string> refs = new List<string>(); Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies(); for (int i = 0; i < assemblies.Length; i++) { if (!assemblies[i].FullName.Contains("System.") && !assemblies[i].FullName.Contains("Microsoft.")) { refs.Add(System.IO.Path.GetFileName(assemblies[i].Location)); //refs.Add(assemblies[i].Location); } } refs.Add("System.dll"); refs.Add("System.Data.dll"); refs.Add("System.Drawing.dll"); refs.Add("System.Xml.dll"); refs.Add("System.Windows.Forms.dll"); //refs.Add("DatabaseConnector.dll"); refs.Add("System.Core.dll"); refs.Add("MySql.Data.dll"); refs.Add("DataManager.dll"); refs.Add("Server.RDungeons.dll"); refs.Add(System.Windows.Forms.Application.ExecutablePath); options.ReferencedAssemblies.AddRange(refs.ToArray()); System.CodeDom.Compiler.ICodeCompiler compiler = provider.CreateCompiler(); System.CodeDom.Compiler.CompilerResults results = compiler.CompileAssemblyFromFileBatch(options, files); foreach (System.CodeDom.Compiler.CompilerError err in results.Errors) { errors.Add(err); } if (results.Errors.Count == 0) { return results.CompiledAssembly; } else { return null; } }
/// <summary> /// Compile a C# var declaration fragment. /// </summary> /// <remarks> /// <para> /// The goal is to determine the types of the local variables, /// so that we can do completion on them. /// </para> /// </remarks> /// <param name='fragment'> /// a comma-separated list of namespaces /// </param> /// <param name='namespaces'> /// a comma-separated list of namespaces /// </param> /// <param name='references'> /// a comma-separated list of assembly references /// </param> /// <param name='classname'> /// name of the class to use. Helpful in satisfying static references. /// </param> /// <param name='arglist'> /// a C# fragment, representing an arglist, suitable for /// framing within parens for the method declaration. /// </param> /// <returns> /// a MethodInfo, if success. Otherwise, an array of Strings containing /// error messages. /// </returns> private static Object CompileFragment(string fragment, String namespaces, String references, string classname, String arglist, String instanceMembers) { string nsname = "N"+Path.GetRandomFileName().Replace(".",""); string methodname = "M"+Path.GetRandomFileName().Replace(".",""); //string classname = Path.GetRandomFileName().Replace(".",""); string usingBlock = (String.IsNullOrEmpty(namespaces)) ? "using System;\n" : GetUsingClauses(namespaces.Split(',')); string literalSource = usingBlock + "\nnamespace " + nsname + " {" + "\n class " + classname + " {" + "\n " + instanceMembers.Replace("; ",";\n ") .Replace("} ","}\n ") .Replace(";}","; }") + "\n void "+ methodname + " (" + arglist + ") {"+ "\n " + fragment.Replace(";",";\n ") + "}\n }\n}\n"; if (Verbose) System.Console.WriteLine("code to compile:\n{0}", literalSource); Tracing.Trace("code to compile:\n{0}", literalSource); try { var csharp = new Microsoft.CSharp.CSharpCodeProvider(new Dictionary<String, String> { { "CompilerVersion", "v3.5" } }); var cp = new System.CodeDom.Compiler.CompilerParameters(); cp.GenerateInMemory = true; cp.GenerateExecutable = false; cp.IncludeDebugInformation = true; if (!String.IsNullOrEmpty(references)) foreach (string ra in references.Split(',')) cp.ReferencedAssemblies.Add(ra); // do I need to worry about duplicates? foreach (string aName in namespaces.Split(',')) { Tracing.Trace("maybe add Ref: {0}", aName); var path = GetAssemblyPathForNamespace(aName); if (path!=null) cp.ReferencedAssemblies.Add(path); } System.CodeDom.Compiler.CompilerResults cr = csharp.CompileAssemblyFromSource(cp,literalSource); if (cr == null) { var e = new List<String>(); Tracing.Trace("CompilerResults == null"); e.Add("CompilerResults == null"); return e.ToArray(); } foreach (string s in cr.Output) { if (Verbose) System.Console.WriteLine(s); Tracing.Trace(s); } if (cr.Errors.Count != 0) { var e = new List<String>(); e.Add(String.Format("Errors.Count = {0}", cr.Errors.Count)); e.Add(cr.Errors[0].ToString()); foreach(var error in cr.Errors) Tracing.Trace(error.ToString()); return e.ToArray(); } var a = cr.CompiledAssembly; MethodInfo mi = a.GetType(nsname + "." + classname) .GetMethod(methodname, BindingFlags.Instance | BindingFlags.NonPublic); return mi; } catch (System.Exception e1) { var e = new List<String>(); e.Add("Exception during compile: " + e1.Message ); Tracing.Trace("{0}", e1.ToString()); return e.ToArray(); } }
private void CompileApp(int rc, string pathToExe) { var csharp = new Microsoft.CSharp.CSharpCodeProvider(); var cp = new System.CodeDom.Compiler.CompilerParameters { GenerateInMemory = false, GenerateExecutable = true, IncludeDebugInformation = false, OutputAssembly = pathToExe }; // set the return code in the app var cr = csharp.CompileAssemblyFromSource (cp, programCode.Replace("@@XXX@@", rc.ToString())); if (cr == null) throw new Exception("Errors compiling post-extract exe!"); foreach (string s in cr.Output) TestContext.WriteLine(s); if (cr.Errors.Count != 0) throw new Exception("Errors compiling post-extract exe!"); }
private int GetSimdRuntimeAccelMode() { try { Assembly.Load("Mono.Simd, Version=2.0.0.0, Culture=neutral, PublicKeyToken=0738eb9f132ed756"); #if true const string code = @" namespace Smdn { public static class SimdRuntimeTest { public static int GetAccelMode() { return (int)Mono.Simd.SimdRuntime.AccelMode; } } }"; using (var provider = new Microsoft.CSharp.CSharpCodeProvider(new System.Collections.Generic.Dictionary<string, string>() {{"CompilerVersion", "v2.0"}})) { var options = new System.CodeDom.Compiler.CompilerParameters(new[] {"Mono.Simd"}); options.GenerateInMemory = true; options.IncludeDebugInformation = false; var result = provider.CompileAssemblyFromSource(options, code); var simdRuntimeType = result.CompiledAssembly.GetType("Smdn.SimdRuntimeTest", true); return (int)simdRuntimeType.GetMethod("GetAccelMode", BindingFlags.Static | BindingFlags.Public).Invoke(null, null); } #else var simdRuntimeType = assm.GetType("Mono.Simd.SimdRuntime", true); // this will not return actual acceleration mode // (Mono does not emit replaced intrinsics, so this returns AccelMode.None always) return (int)simdRuntimeType.GetProperty("AccelMode", BindingFlags.Static | BindingFlags.Public).GetValue(null, null)); #endif } catch { return 0; } }
public void Generate() { var sw = Stopwatch.StartNew(); GenerateResourcesResx(); _performanceLogger.Write(sw, "CaptionsResourceGenerator generated resx"); CompileResourceFile(); _performanceLogger.Write(sw, "CaptionsResourceGenerator compiled resx to resources"); var assemblySource = GenerateResourcesCs(); _performanceLogger.Write(sw, "CaptionsResourceGenerator generated cs"); var compilerParameters = new System.CodeDom.Compiler.CompilerParameters { GenerateExecutable = false, GenerateInMemory = false, OutputAssembly = ResourcesAssemblyDllPath, IncludeDebugInformation = true, CompilerOptions = "" }; compilerParameters.EmbeddedResources.Add(CompiledResourcesFilePath); _assemblyGenerator.Generate(assemblySource, compilerParameters); _performanceLogger.Write(sw, "CaptionsResourceGenerator generated dll"); }
/// <summary> /// 拡張機能をコンパイルして実行するメソッド /// </summary> /// <param name="extension">実行する拡張機能</param> private void ExecExtensionMain( WP7_2012ULV.Setting.ExtensionSetting.Command extension ) { var file = String.Format( "{0}\\{{{1}}}.cs", this.ExtensionsDir, extension.Guid ); if( !System.IO.File.Exists( file ) ) { var message = String.Format( "{0} 拡張機能ファイルが見つかりませんでした", file ); MessageBox.Show( message, "エラー", MessageBoxButtons.OK, MessageBoxIcon.Error ); return ; } if( this.WP7.TransactionWeekNumber != this.WP7.GetCurrentWeekNumber() ) { var message = String.Format( "データ取得時から週が変わっています({0}→{1})\r\n安全のため書き込みは行いません、再取得してください", this.WP7.TransactionWeekNumber, this.WP7.GetCurrentWeekNumber() ); MessageBox.Show( message, "エラー", MessageBoxButtons.OK, MessageBoxIcon.Error ); return; } var compiler_option = new Dictionary< string, string >() { { "CompilerVersion", "v3.5" } }; var compiler = new Microsoft.CSharp.CSharpCodeProvider( compiler_option ); var options = new System.CodeDom.Compiler.CompilerParameters(); options.GenerateInMemory = true; options.WarningLevel = 4; options.TreatWarningsAsErrors = true; options.ReferencedAssemblies.Add("System.dll"); options.ReferencedAssemblies.Add("System.Data.dll"); options.ReferencedAssemblies.Add("System.Windows.Forms.dll"); options.ReferencedAssemblies.Add("System.Drawing.dll"); options.ReferencedAssemblies.Add("KOEI.WP7_2012.dll"); using( var sr = new System.IO.StreamReader( file, Encoding.UTF8 ) ) { var source = sr.ReadToEnd(); var program = compiler.CompileAssemblyFromSource( options, new[]{ source } ); if( program.Errors.Count > 0 ) { var error_string = "コンパイルエラー\r\n"; foreach( var error in program.Errors ) { error_string += ((System.CodeDom.Compiler.CompilerError)error).ErrorText; error_string += "\r\n"; } throw new Exception( error_string ); } Type klass; try { klass = program.CompiledAssembly.GetType( EXTENSION_CLASS_NAME ); } catch( Exception ex ) { throw new Exception( String.Format( "{0}クラスの取得に失敗 - {1}", EXTENSION_CLASS_NAME, ex.Message ) ); } var method = klass.GetMethod( EXTENSION_METHOD_NAME, System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public, null, ExtensionArgTypes, null ); if( method == null ) { throw new Exception( String.Format( "{0}メソッドの取得に失敗", EXTENSION_METHOD_NAME ) ); } this.ExecCSharpExtension( method, extension.Manifest ); } }
private void WriteProject(SolutionNode solution, ProjectNode project) { string solutionDir = Path.Combine(solution.FullPath, Path.Combine("autotools", solution.Name)); string projectDir = Path.Combine(solutionDir, project.Name); string projectVersion = project.Version; bool hasAssemblyConfig = false; chkMkDir(projectDir); List<string> compiledFiles = new List<string>(), contentFiles = new List<string>(), embeddedFiles = new List<string>(), binaryLibs = new List<string>(), pkgLibs = new List<string>(), systemLibs = new List<string>(), runtimeLibs = new List<string>(), extraDistFiles = new List<string>(), localCopyTargets = new List<string>(); // If there exists a .config file for this assembly, copy // it to the project folder // TODO: Support copying .config.osx files // TODO: support processing the .config file for native library deps string projectAssemblyName = project.Name; if (project.AssemblyName != null) projectAssemblyName = project.AssemblyName; if (File.Exists(Path.Combine(project.FullPath, projectAssemblyName) + ".dll.config")) { hasAssemblyConfig = true; System.IO.File.Copy(Path.Combine(project.FullPath, projectAssemblyName + ".dll.config"), Path.Combine(projectDir, projectAssemblyName + ".dll.config"), true); extraDistFiles.Add(project.AssemblyName + ".dll.config"); } foreach (ConfigurationNode conf in project.Configurations) { if (conf.Options.KeyFile != string.Empty) { // Copy snk file into the project's directory // Use the snk from the project directory directly string source = Path.Combine(project.FullPath, conf.Options.KeyFile); string keyFile = conf.Options.KeyFile; Regex re = new Regex(".*/"); keyFile = re.Replace(keyFile, ""); string dest = Path.Combine(projectDir, keyFile); // Tell the user if there's a problem copying the file try { mkdirDashP(System.IO.Path.GetDirectoryName(dest)); System.IO.File.Copy(source, dest, true); } catch (System.IO.IOException e) { Console.WriteLine(e.Message); } } } // Copy compiled, embedded and content files into the project's directory foreach (string filename in project.Files) { string source = Path.Combine(project.FullPath, filename); string dest = Path.Combine(projectDir, filename); if (filename.Contains("AssemblyInfo.cs")) { // If we've got an AssemblyInfo.cs, pull the version number from it string[] sources = { source }; string[] args = { "" }; Microsoft.CSharp.CSharpCodeProvider cscp = new Microsoft.CSharp.CSharpCodeProvider(); string tempAssemblyFile = Path.Combine(Path.GetTempPath(), project.Name + "-temp.dll"); System.CodeDom.Compiler.CompilerParameters cparam = new System.CodeDom.Compiler.CompilerParameters(args, tempAssemblyFile); System.CodeDom.Compiler.CompilerResults cr = cscp.CompileAssemblyFromFile(cparam, sources); foreach (System.CodeDom.Compiler.CompilerError error in cr.Errors) Console.WriteLine("Error! '{0}'", error.ErrorText); try { string projectFullName = cr.CompiledAssembly.FullName; Regex verRegex = new Regex("Version=([\\d\\.]+)"); Match verMatch = verRegex.Match(projectFullName); if (verMatch.Success) projectVersion = verMatch.Groups[1].Value; }catch{ Console.WriteLine("Couldn't compile AssemblyInfo.cs"); } // Clean up the temp file try { if (File.Exists(tempAssemblyFile)) File.Delete(tempAssemblyFile); } catch { Console.WriteLine("Error! '{0}'", e); } } // Tell the user if there's a problem copying the file try { mkdirDashP(System.IO.Path.GetDirectoryName(dest)); System.IO.File.Copy(source, dest, true); } catch (System.IO.IOException e) { Console.WriteLine(e.Message); } switch (project.Files.GetBuildAction(filename)) { case BuildAction.Compile: compiledFiles.Add(filename); break; case BuildAction.Content: contentFiles.Add(filename); extraDistFiles.Add(filename); break; case BuildAction.EmbeddedResource: embeddedFiles.Add(filename); break; } } // Set up references for (int refNum = 0; refNum < project.References.Count; refNum++) { ReferenceNode refr = project.References[refNum]; Assembly refAssembly = Assembly.LoadWithPartialName(refr.Name); /* Determine which pkg-config (.pc) file refers to this assembly */ SystemPackage package = null; if (packagesHash.ContainsKey(refr.Name)) { package = packagesHash[refr.Name]; } else { string assemblyFullName = string.Empty; if (refAssembly != null) assemblyFullName = refAssembly.FullName; string assemblyFileName = string.Empty; if (assemblyFullName != string.Empty && assemblyFullNameToPath.ContainsKey(assemblyFullName) ) assemblyFileName = assemblyFullNameToPath[assemblyFullName]; if (assemblyFileName != string.Empty && assemblyPathToPackage.ContainsKey(assemblyFileName) ) package = assemblyPathToPackage[assemblyFileName]; } /* If we know the .pc file and it is not "mono" (already in the path), add a -pkg: argument */ if (package != null && package.Name != "mono" && !pkgLibs.Contains(package.Name) ) pkgLibs.Add(package.Name); string fileRef = FindFileReference(refr.Name, (ProjectNode)refr.Parent); if (refr.LocalCopy || solution.ProjectsTable.ContainsKey(refr.Name) || fileRef != null || refr.Path != null ) { /* Attempt to copy the referenced lib to the project's directory */ string filename = refr.Name + ".dll"; string source = filename; if (refr.Path != null) source = Path.Combine(refr.Path, source); source = Path.Combine(project.FullPath, source); string dest = Path.Combine(projectDir, filename); /* Since we depend on this binary dll to build, we * will add a compile- time dependency on the * copied dll, and add the dll to the list of * files distributed with this package */ binaryLibs.Add(refr.Name + ".dll"); extraDistFiles.Add(refr.Name + ".dll"); // TODO: Support copying .config.osx files // TODO: Support for determining native dependencies if (File.Exists(source + ".config")) { System.IO.File.Copy(source + ".config", Path.GetDirectoryName(dest), true); extraDistFiles.Add(refr.Name + ".dll.config"); } try { System.IO.File.Copy(source, dest, true); } catch (System.IO.IOException) { if (solution.ProjectsTable.ContainsKey(refr.Name)){ /* If an assembly is referenced, marked for * local copy, in the list of projects for * this solution, but does not exist, put a * target into the Makefile.am to build the * assembly and copy it to this project's * directory */ ProjectNode sourcePrj = ((solution.ProjectsTable[refr.Name])); string target = String.Format("{0}:\n" + "\t$(MAKE) -C ../{1}\n" + "\tln ../{2}/$@ $@\n", filename, sourcePrj.Name, sourcePrj.Name ); localCopyTargets.Add(target); } } } else if( !pkgLibs.Contains(refr.Name) ) { // Else, let's assume it's in the GAC or the lib path string assemName = string.Empty; int index = refr.Name.IndexOf(","); if (index > 0) assemName = refr.Name.Substring(0, index); else assemName = refr.Name; m_Kernel.Log.Write(String.Format( "Warning: Couldn't find an appropriate assembly " + "for reference:\n'{0}'", refr.Name )); systemLibs.Add(assemName); } } const string lineSep = " \\\n\t"; string compiledFilesString = string.Empty; if (compiledFiles.Count > 0) compiledFilesString = lineSep + string.Join(lineSep, compiledFiles.ToArray()); string embeddedFilesString = ""; if (embeddedFiles.Count > 0) embeddedFilesString = lineSep + string.Join(lineSep, embeddedFiles.ToArray()); string contentFilesString = ""; if (contentFiles.Count > 0) contentFilesString = lineSep + string.Join(lineSep, contentFiles.ToArray()); string extraDistFilesString = ""; if (extraDistFiles.Count > 0) extraDistFilesString = lineSep + string.Join(lineSep, extraDistFiles.ToArray()); string pkgLibsString = ""; if (pkgLibs.Count > 0) pkgLibsString = lineSep + string.Join(lineSep, pkgLibs.ToArray()); string binaryLibsString = ""; if (binaryLibs.Count > 0) binaryLibsString = lineSep + string.Join(lineSep, binaryLibs.ToArray()); string systemLibsString = ""; if (systemLibs.Count > 0) systemLibsString = lineSep + string.Join(lineSep, systemLibs.ToArray()); string localCopyTargetsString = ""; if (localCopyTargets.Count > 0) localCopyTargetsString = string.Join("\n", localCopyTargets.ToArray()); string monoPath = ""; foreach (string runtimeLib in runtimeLibs) { monoPath += ":`pkg-config --variable=libdir " + runtimeLib + "`"; } // Add the project name to the list of transformation // parameters XsltArgumentList argList = new XsltArgumentList(); argList.AddParam("projectName", "", project.Name); argList.AddParam("solutionName", "", solution.Name); argList.AddParam("assemblyName", "", projectAssemblyName); argList.AddParam("compiledFiles", "", compiledFilesString); argList.AddParam("embeddedFiles", "", embeddedFilesString); argList.AddParam("contentFiles", "", contentFilesString); argList.AddParam("extraDistFiles", "", extraDistFilesString); argList.AddParam("pkgLibs", "", pkgLibsString); argList.AddParam("binaryLibs", "", binaryLibsString); argList.AddParam("systemLibs", "", systemLibsString); argList.AddParam("monoPath", "", monoPath); argList.AddParam("localCopyTargets", "", localCopyTargetsString); argList.AddParam("projectVersion", "", projectVersion); argList.AddParam("hasAssemblyConfig", "", hasAssemblyConfig ? "true" : ""); // Transform the templates transformToFile(Path.Combine(projectDir, "configure.ac"), argList, "/Autotools/ProjectConfigureAc"); transformToFile(Path.Combine(projectDir, "Makefile.am"), argList, "/Autotools/ProjectMakefileAm"); transformToFile(Path.Combine(projectDir, "autogen.sh"), argList, "/Autotools/ProjectAutogenSh"); if (project.Type == Core.Nodes.ProjectType.Library) transformToFile(Path.Combine(projectDir, project.Name + ".pc.in"), argList, "/Autotools/ProjectPcIn"); if (project.Type == Core.Nodes.ProjectType.Exe || project.Type == Core.Nodes.ProjectType.WinExe) transformToFile(Path.Combine(projectDir, project.Name.ToLower() + ".in"), argList, "/Autotools/ProjectWrapperScriptIn"); }
/// <summary> /// Saves the ZipFile instance to a self-extracting zip archive. /// </summary> /// /// <remarks> /// /// <para> /// The generated exe image will execute on any machine that has the .NET Framework 2.0 /// installed on it. /// </para> /// /// <para> /// There are two "flavors" of self-extracting archive. The <c>WinFormsApplication</c> /// version will pop up a GUI and allow the user to select a target directory into which /// to extract. There's also a checkbox allowing the user to specify to overwrite /// existing files, and another checkbox to allow the user to request that Explorer be /// opened to see the extracted files after extraction. The other flavor is /// <c>ConsoleApplication</c>. A self-extractor generated with that flavor setting will /// run from the command line. It accepts command-line options to set the overwrite /// behavior, and to specify the target extraction directory. /// /// </para> /// <para> /// There are a few temporary files created during the saving to a self-extracting zip. /// These files are normally stored in the directory pointed to by the TEMP environment /// variable, and they are removed upon successful completion of this method. /// </para> /// </remarks> /// /// <example> /// <code> /// string DirectoryPath = "c:\\Documents\\Project7"; /// using (ZipFile zip = new ZipFile()) /// { /// zip.AddDirectory(DirectoryPath, System.IO.Path.GetFileName(DirectoryPath)); /// zip.Comment = "This will be embedded into a self-extracting console-based exe"; /// zip.SaveSelfExtractor("archive.exe", SelfExtractorFlavor.ConsoleApplication); /// } /// </code> /// <code lang="VB"> /// Dim DirectoryPath As String = "c:\Documents\Project7" /// Using zip As New ZipFile() /// zip.AddDirectory(DirectoryPath, System.IO.Path.GetFileName(DirectoryPath)) /// zip.Comment = "This will be embedded into a self-extracting console-based exe" /// zip.SaveSelfExtractor("archive.exe", SelfExtractorFlavor.ConsoleApplication) /// End Using /// </code> /// </example> /// /// <param name="exeToGenerate">a pathname, possibly fully qualified, to be created. Typically it will end in an .exe extension.</param> /// <param name="flavor">Indicates whether a Winforms or Console self-extractor is desired.</param> public void SaveSelfExtractor(string exeToGenerate, SelfExtractorFlavor flavor) { if (File.Exists(exeToGenerate)) { if (Verbose) StatusMessageTextWriter.WriteLine("The existing file ({0}) will be overwritten.", exeToGenerate); } if (!exeToGenerate.EndsWith(".exe")) { if (Verbose) StatusMessageTextWriter.WriteLine("Warning: The generated self-extracting file will not have an .exe extension."); } string TempZipFile = SfxSaveTemporary(); if (TempZipFile == null) return; // cancelled // look for myself (ZipFile will be present in the Zip assembly) Assembly a1 = typeof(ZipFile).Assembly; //Console.WriteLine("DotNetZip assembly loc: {0}", a1.Location); Microsoft.CSharp.CSharpCodeProvider csharp = new Microsoft.CSharp.CSharpCodeProvider(); // I'd like to do linq query, but the resulting image has to run on .NET 2.0!! // var settings = (from x in SettingsList // where x.Flavor == flavor // select x).First(); ExtractorSettings settings = null; foreach (var x in SettingsList) { if (x.Flavor == flavor) { settings = x; break; } } if (settings == null) throw new BadStateException(String.Format("While saving a Self-Extracting Zip, Cannot find that flavor ({0})?", flavor)); // This is the list of referenced assemblies. Zip is needed here. // Also if it is the winforms (gui) extractor, we need other referenced assemblies. System.CodeDom.Compiler.CompilerParameters cp = new System.CodeDom.Compiler.CompilerParameters(); cp.ReferencedAssemblies.Add(a1.Location); if (settings.ReferencedAssemblies != null) foreach (string ra in settings.ReferencedAssemblies) cp.ReferencedAssemblies.Add(ra); cp.GenerateInMemory = false; cp.GenerateExecutable = true; cp.IncludeDebugInformation = false; cp.OutputAssembly = exeToGenerate; Assembly a2 = Assembly.GetExecutingAssembly(); string TempDir = GenerateUniquePathname("tmp", null); if ((settings.CopyThroughResources != null) && (settings.CopyThroughResources.Count != 0)) { System.IO.Directory.CreateDirectory(TempDir); int n = 0; byte[] bytes = new byte[1024]; foreach (string re in settings.CopyThroughResources) { string filename = Path.Combine(TempDir, re); using (Stream instream = a2.GetManifestResourceStream(re)) { using (FileStream outstream = File.OpenWrite(filename)) { do { n = instream.Read(bytes, 0, bytes.Length); outstream.Write(bytes, 0, n); } while (n > 0); } } // add the embedded resource in our own assembly into the target assembly as an embedded resource cp.EmbeddedResources.Add(filename); } } // add the zip file as an embedded resource cp.EmbeddedResources.Add(TempZipFile); // add the Zip DLL as an embedded resource cp.EmbeddedResources.Add(a1.Location); //Console.WriteLine("Resources in this assembly:"); //foreach (string rsrc in a2.GetManifestResourceNames()) //{ // Console.WriteLine(rsrc); //} //Console.WriteLine(); //Console.WriteLine("reading source code resources:"); // concatenate all the source code resources into a single module var sb = new System.Text.StringBuilder(); foreach (string rc in settings.ResourcesToCompile) { //Console.WriteLine(" trying to read stream: ({0})", rc); Stream s = a2.GetManifestResourceStream(rc); using (StreamReader sr = new StreamReader(s)) { while (sr.Peek() >= 0) sb.Append(sr.ReadLine()).Append("\n"); } sb.Append("\n\n"); } string LiteralSource = sb.ToString(); System.CodeDom.Compiler.CompilerResults cr = csharp.CompileAssemblyFromSource(cp, LiteralSource); if (cr == null) throw new SfxGenerationException("Errors compiling the extraction logic!"); foreach (string output in cr.Output) if (Verbose) StatusMessageTextWriter.WriteLine(output); if (cr.Errors.Count != 0) throw new SfxGenerationException("Errors compiling the extraction logic!"); try { if (Directory.Exists(TempDir)) { try { Directory.Delete(TempDir, true); } catch { } } if (File.Exists(TempZipFile)) { try { File.Delete(TempZipFile);} catch { } } } catch { } if (Verbose) StatusMessageTextWriter.WriteLine("Created self-extracting zip file {0}.", cr.PathToAssembly); return; // catch (Exception e1) // { // StatusMessageTextWriter.WriteLine("****Exception: " + e1); // throw; // } // return; }
public ASLMethod(string code) { IsEmpty = string.IsNullOrWhiteSpace(code); code = code.Replace("return;", "return null;"); // hack using (var provider = new Microsoft.CSharp.CSharpCodeProvider(new Dictionary<string, string> { { "CompilerVersion", "v4.0" } })) { string source = $@" using System; using System.Collections.Generic; using System.Diagnostics; using System.Dynamic; using System.IO; using System.Linq; using System.Reflection; using System.Text; using System.Threading; using LiveSplit.ComponentUtil; using LiveSplit.Model; public class CompiledScript {{ public string version; public double refreshRate; void print(string s) {{ Trace.WriteLine(s); }} public dynamic Execute(LiveSplitState timer, dynamic old, dynamic current, dynamic vars, Process game) {{ var memory = game; var modules = game.ModulesWow64Safe(); { code } return null; }} }}"; var parameters = new System.CodeDom.Compiler.CompilerParameters() { GenerateInMemory = true, CompilerOptions = "/optimize /d:TRACE", }; parameters.ReferencedAssemblies.Add("System.dll"); parameters.ReferencedAssemblies.Add("System.Core.dll"); parameters.ReferencedAssemblies.Add("System.Data.dll"); parameters.ReferencedAssemblies.Add("System.Data.DataSetExtensions.dll"); parameters.ReferencedAssemblies.Add("System.Drawing.dll"); parameters.ReferencedAssemblies.Add("System.Windows.Forms.dll"); parameters.ReferencedAssemblies.Add("System.Xml.dll"); parameters.ReferencedAssemblies.Add("System.Xml.Linq.dll"); parameters.ReferencedAssemblies.Add("Microsoft.CSharp.dll"); parameters.ReferencedAssemblies.Add("LiveSplit.Core.dll"); var res = provider.CompileAssemblyFromSource(parameters, source); if (res.Errors.HasErrors) { var errorMessage = ""; foreach (var error in res.Errors) { errorMessage += error + "\r\n"; } throw new ArgumentException(errorMessage, "code"); } var type = res.CompiledAssembly.GetType("CompiledScript"); CompiledCode = Activator.CreateInstance(type); } }
protected internal FixedArrayComboListEnumerator[] GetEnumeratorsWithFullSource(string code, string classname) { System.CodeDom.Compiler.CompilerParameters cp = new System.CodeDom.Compiler.CompilerParameters(new string[] { "IMapReduce.dll" }); #if DEBUG cp.IncludeDebugInformation = true; #endif System.CodeDom.Compiler.CompilerResults cr = null; FixedArrayComboListEnumerator[] result; string reason = ""; for (int rotor = 1; ; rotor++) { /*if (rotor > 10) { throw new System.IO.FileNotFoundException("FixedArrayComboList.GetEnumerators dynamic C# compilation: Unable to create DLL" + reason); }*/ try { cp.OutputAssembly = ".\\temp_" + Guid.NewGuid() + ".dll"; cp.GenerateExecutable = false; // Not exe, but dll. cp.GenerateInMemory = false; cp.CompilerOptions = getcompileropts(); using (new System.Threading.Mutex(true, "DynCmp")) { using (Microsoft.CSharp.CSharpCodeProvider cscp = new Microsoft.CSharp.CSharpCodeProvider()) { cr = cscp.CompileAssemblyFromSource(cp, code); } CleanCompilerFiles(); } if (cr.Errors.HasErrors) { try { lock (typeof(DistObject)) { System.IO.File.WriteAllText("error.cs", code); } } catch { } throw new Exception("GetEnumerators code compile error: " + cr.Errors[0].ToString()); } if (0 != cr.NativeCompilerReturnValue) { LogLine("GetEnumerators code compile did not return 0 (returned " + cr.NativeCompilerReturnValue.ToString() + "): "); for (int i = 0; i < cr.Output.Count; i++) { string ss = cr.Output[i].Trim(); if (0 != ss.Length) { LogLine(" C" + rotor.ToString() + "- " + cr.Output[i]); } } } System.Threading.Thread.Sleep(1000 * rotor); //System.IO.File.WriteAllText("xlib_" + classname + ".xlib", code); // Conflicts with multiple running inline reducers. byte[] dlldata = System.IO.File.ReadAllBytes(cr.PathToAssembly); result = GetEnumerators(dlldata, classname, code); //ArrayComboListEnumerator.SendDllNow() on all enumerators so it can be deleted. for (int i = 0; i != result.Length; i++) { result[i].SendDllNow(); } break; // Good. } catch (System.IO.IOException e) { LogLine("Rotor retry: " + e.ToString()); reason = ": " + e.ToString(); continue; } } try { System.IO.File.Delete(cr.PathToAssembly); #if DEBUG System.IO.File.Delete(cr.PathToAssembly.Replace(".dll", ".pdb")); #endif } catch (Exception eee) { int i23zzz = 23 + 23; } return result; }
public int GenerateTest() { System.CodeDom.Compiler.CompilerParameters parameters = new System.CodeDom.Compiler.CompilerParameters (); parameters.GenerateExecutable = true; parameters.GenerateInMemory = false; parameters.IncludeDebugInformation = false; parameters.MainClass = namespaceName + "." + appName; parameters.OutputAssembly = appName + ".exe"; string code = GetCode (); System.CodeDom.Compiler.ICodeCompiler compiler = new Microsoft.CSharp.CSharpCodeProvider ().CreateCompiler (); compilerResult = compiler.CompileAssemblyFromSource (parameters, code); if (compilerResult.NativeCompilerReturnValue == 0) { appPath = System.IO.Directory.GetCurrentDirectory (); } else { appPath = ""; } return compilerResult.NativeCompilerReturnValue; }
System.Reflection.Assembly _CompileSource(string Input, bool InputIsFile, bool exe, string outputname) { string[] asmrefs = new string[AssemblyReferences.Count]; List<string> assemblydirs = new List<string>(); char[] slashes = new char[] { '/', '\\' }; for (int i = 0; i < asmrefs.Length; i++) { string ar = AssemblyReferences[i]; int ils = ar.LastIndexOfAny(slashes); if (-1 != ils) { assemblydirs.Add(ar.Substring(0, ils)); ar = ar.Substring(ils + 1); } asmrefs[i] = ar; } StringBuilder localcompileropts = new StringBuilder(); { for (int i = 0; i < assemblydirs.Count; i++) { localcompileropts.Append(" /lib:\"" + assemblydirs[i] + "\""); } } System.CodeDom.Compiler.CompilerParameters cp = new System.CodeDom.Compiler.CompilerParameters(asmrefs); cp.IncludeDebugInformation = _compilerdbg; System.CodeDom.Compiler.CompilerResults cr = null; bool alreadylogged = false; string reason = ""; for (int rotor = 1; ; rotor++) { #if DEBUG if (rotor > 3) { throw new System.IO.FileNotFoundException("ArrayComboList.CompileSource dynamic C# compilation: Unable to create DLL" + reason); } #endif try { cp.OutputAssembly = outputname; cp.GenerateExecutable = exe; cp.GenerateInMemory = false; cp.CompilerOptions = getcompileropts() + localcompileropts.ToString(); { System.Threading.Mutex mdc = new System.Threading.Mutex(false, "DynCmp"); try { mdc.WaitOne(); } catch (System.Threading.AbandonedMutexException) { } try { Dictionary<string, string> providerOptions = new Dictionary<string, string>(); providerOptions["CompilerVersion"] = "v3.5"; using (Microsoft.CSharp.CSharpCodeProvider cscp = new Microsoft.CSharp.CSharpCodeProvider(providerOptions)) { if (InputIsFile) { cr = cscp.CompileAssemblyFromFile(cp, Input); } else { cr = cscp.CompileAssemblyFromSource(cp, Input); } } } finally { mdc.ReleaseMutex(); mdc.Close(); } } if (cr.Errors.HasErrors) { try { lock (typeof(Compiler)) { if (InputIsFile) { System.IO.File.Copy(Input, "error.cs", true); // overwrite=true } else { System.IO.File.WriteAllText("error.cs", Input); } } } catch { } for (int i = 0; i < cr.Errors.Count; i++) { if (!cr.Errors[i].IsWarning) { throw new Exception("CompileSource code compile error: " + cr.Errors[i].ToString()); } } throw new Exception("CompileSource code compile error: " + cr.Errors[0].ToString()); } if (0 != cr.NativeCompilerReturnValue) { //LogLine("CompileSource code compile did not return 0 (returned " + cr.NativeCompilerReturnValue.ToString() + "): "); for (int i = 0; i < cr.Output.Count; i++) { string ss = cr.Output[i].Trim(); if (0 != ss.Length) { //LogLine(" C" + rotor.ToString() + "- " + cr.Output[i]); } } } #if DEBUG if (rotor > 1) { System.Threading.Thread.Sleep(1000 * (rotor - 1)); } #else System.Threading.Thread.Sleep(1000 * rotor); #endif break; // Good. } catch (System.IO.IOException e) { if (!alreadylogged) { alreadylogged = true; //LogLine("Rotor retry: " + e.ToString()); } reason = ": " + e.ToString(); continue; } } return cr.CompiledAssembly; }