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