public static Assembly BuildInMemory(string code, out string errors)
{
CSharpCodeProvider cp = new CSharpCodeProvider();
CompilerParameters cpar = new CompilerParameters();
cpar.GenerateInMemory = true;
cpar.GenerateExecutable = false;
cpar.ReferencedAssemblies.Add("system.dll");
cpar.ReferencedAssemblies.Add(Assembly.GetAssembly(typeof(Vector2)).Location); //"Microsoft.Xna.Framework, Version=3.0.0.0, PublicKeyToken=6d5c3888ef60e27d");
cpar.ReferencedAssemblies.Add("Gnomic.dll");
cpar.ReferencedAssemblies.Add("SquareHeroesTypes.dll");
CompilerResults cr = cp.CompileAssemblyFromSource(cpar, new string[] { code });
cp.Dispose();
errors = "";
if (cr.Errors.Count == 0 && cr.CompiledAssembly != null)
{
return(cr.CompiledAssembly);
}
for (int i = 0; i < cr.Errors.Count; i++)
{
errors += cr.Errors[i].ErrorText + "\n";
}
return(null);
}
public void Dispose()
{
if (null != compiler)
{
compiler.Dispose();
}
}
/// <inheritdoc />
protected override bool OnStepStart()
{
var codeProvider = new CSharpCodeProvider();
var rspFilePath = MakeResponseFile();
var compilerParams = MakeCompilerParameters(rspFilePath);
// create a missing directory path
var directoryPath = PathHelpers.GetDirectoryName(OutputPath);
if (!Directory.Exists(directoryPath))
{
Directory.CreateDirectory(directoryPath);
}
// compile the DLL then dispose of code provider
var compilerResults = codeProvider.CompileAssemblyFromFile(compilerParams);
codeProvider.Dispose();
if (!compilerResults.Errors.HasErrors)
{
return(true);
}
foreach (CompilerError compilerError in compilerResults.Errors)
{
RockLog.WriteLine(this, compilerError.IsWarning
? LogTier.Warning
: LogTier.Error, compilerError.ToString());
}
return(false);
}
private bool CompileCSharpCode(string script, string filename, out List <string> errors)
{
errors = new List <string>();
try
{
CSharpCodeProvider provider = new CSharpCodeProvider();
CompilerParameters cp = new CompilerParameters
{
GenerateInMemory = false,
GenerateExecutable = false,
IncludeDebugInformation = true,
OutputAssembly = filename,
};
cp.ReferencedAssemblies.Add("System.dll");
cp.ReferencedAssemblies.Add("Newtonsoft.Json.dll");
cp.ReferencedAssemblies.Add("System.ComponentModel.DataAnnotations.dll");
CompilerResults cr = provider.CompileAssemblyFromSource(cp, script);
if (cr.Errors.Count > 0)
{
foreach (CompilerError ce in cr.Errors)
{
errors.Add(ce.ToString());
}
return(false);
}
provider.Dispose();
}
catch (Exception e)
{
errors.Add("Error: " + e.Message + e.StackTrace.ToString());
return(false);
}
return(true);
}
public static Assembly CompileInMemory(string code)
{
var provider = new CSharpCodeProvider(new Dictionary <string, string>()
{
{ "CompilerVersion", "v4.0" }
});
CompilerParameters options = new CompilerParameters();
options.ReferencedAssemblies.Add("System.dll");
options.ReferencedAssemblies.Add("System.Core.dll");
options.ReferencedAssemblies.Add("WindowsBase.dll");
options.ReferencedAssemblies.Add("PresentationFramework.dll");
options.ReferencedAssemblies.Add("PresentationCore.dll");
options.IncludeDebugInformation = false;
options.GenerateExecutable = false;
options.GenerateInMemory = true;
CompilerResults results = provider.CompileAssemblyFromSource(options, code);
provider.Dispose();
if (results.Errors.Count == 0)
{
return(results.CompiledAssembly);
}
else
{
return(null);
}
}
private void createOneExecuteScriptToolStripMenuItem_Click(object sender, EventArgs e)
{
try
{
Forms.OneExecute ox = new Forms.OneExecute();
ox.ShowDialog();
CSharpCodeProvider provider = new CSharpCodeProvider();
CompilerParameters parameters = new CompilerParameters();
parameters.GenerateInMemory = true;
parameters.ReferencedAssemblies.Add("System.dll");
parameters.ReferencedAssemblies.Add("System.Windows.Forms.dll");
parameters.ReferencedAssemblies.Add("dal.dll");
parameters.ReferencedAssemblies.Add("dgl.dll");
parameters.ReferencedAssemblies.Add("dglw.dll");
parameters.ReferencedAssemblies.Add("dreary.exe");
Console.WriteLine("Code transmorgified: \n" + TransmorgifyCode(ox.output, true));
CompilerResults results = provider.CompileAssemblyFromSource(parameters, TransmorgifyCode(ox.output, true));
foreach (string i in results.Output)
{
Console.WriteLine(i);
}
foreach (CompilerError i in results.Errors)
{
Console.WriteLine("[ERROR in JIT Code] " + i.ErrorText);
}
results.CompiledAssembly.GetType("RuntimeCode.Code").GetMethod("Entry").Invoke(null, new object[] { scene, pcam, this, 1.0 });
provider.Dispose();
}
catch (Exception exc)
{
MessageBox.Show(exc.ToString(), "Script Error");
}
}
/// <summary>
/// Writes the current code scope to file.
/// </summary>
/// <param name="fileName">File name to write the code to.</param>
public void WriteToFile(string fileName)
{
// Create a new CSharpCodeProvider to generate the code for us.
CSharpCodeProvider codeProvider = new CSharpCodeProvider();
// Create a new stream writer to write the file.
using (StreamWriter writer = new StreamWriter(fileName))
{
// Create a new IndentedTextWriter to format the code is a nice mannor.
IndentedTextWriter tw = new IndentedTextWriter(writer, " ");
// Setup the code generation options for style preferences.
CodeGeneratorOptions options = new CodeGeneratorOptions();
options.BlankLinesBetweenMembers = true;
options.BracingStyle = "C";
options.VerbatimOrder = false;
// Generate the code using the code provider.
codeProvider.GenerateCodeFromCompileUnit(this.codeUnit, tw, options);
// Close the text writer.
tw.Close();
}
// Dispose of the code provider.
codeProvider.Dispose();
}
/// <summary>
/// 动态编译类
/// </summary>
/// <param name="code"></param>
/// <param name="err"></param>
/// <returns></returns>
private static string NewCompilerClass(string code, string nodeId, ref ErrorInfo err)
{
string assemblyName = "";
string pathServer = AppDomain.CurrentDomain.BaseDirectory + "Easyman.ScriptService.exe";
#region 判断类库是否存在
if (!System.IO.File.Exists(pathServer))
{
pathServer = AppDomain.CurrentDomain.BaseDirectory + "Bin\\Easyman.ScriptService.exe";
}
if (!System.IO.File.Exists(pathServer))
{
err.IsError = true;
err.Message = string.Format("类库【{0}】不存在", pathServer);
return(null);
}
#endregion
using (CSharpCodeProvider objCSharpCodePrivoder = new CSharpCodeProvider())
{
//生成程序集名(动态)
string assemblyNameTemp = AppDomain.CurrentDomain.BaseDirectory + "dlls\\DynamicalCode_" + nodeId + "_" + DateTime.Now.Ticks + ".dll";
//ICodeCompiler objICodeCompiler = objCSharpCodePrivoder.CreateCompiler();
CompilerParameters objCompilerParameters = new CompilerParameters();
objCompilerParameters.ReferencedAssemblies.Add("System.dll");
objCompilerParameters.ReferencedAssemblies.Add("System.Windows.Forms.dll");
//objCompilerParameters.ReferencedAssemblies.Add(AppDomain.CurrentDomain.BaseDirectory + "Easyman.Librarys.dll");
objCompilerParameters.ReferencedAssemblies.Add(pathServer);
//objCompilerParameters.GenerateExecutable = false;
objCompilerParameters.GenerateInMemory = false;
objCompilerParameters.OutputAssembly = assemblyNameTemp;
CompilerResults cr = objCSharpCodePrivoder.CompileAssemblyFromSource(objCompilerParameters, code);
if (cr.Errors.HasErrors)
{
StringBuilder sb = new StringBuilder("编译错误：");
foreach (CompilerError e in cr.Errors)
{
sb.AppendLine(string.Format("行{0}列{1}：{2}\r\n", e.Line - 12, e.Column, e.ErrorText));
}
err.IsError = true;
err.Message = sb.ToString();
//return null;
}
else
{
assemblyName = assemblyNameTemp; //赋值返回变量
}
objCSharpCodePrivoder.Dispose(); //手动释放
}
return(assemblyName);
}
/// <summary>
/// Releases all the resources used by this object.
/// </summary>
public void Dispose()
{
if (csCompiler != null)
{
csCompiler.Dispose();
csCompiler = null;
}
}
protected override void DisposeCore(bool disposing)
{
if (disposing)
{
_compiler?.Dispose();
_compiler = null;
}
}
void IDisposable.Dispose()
{
if (run != null)
{
run.Dispose();
}
_csCodeProvider.Dispose();
}
void Dispose(bool disposing)
{
if (provider != null && disposing)
{
provider.Dispose();
provider = null;
}
}
///// <summary>
///// 获取地址
///// </summary>
///// <param name="lab"></param>
///// <returns></returns>
//public static string getURL(string lab)
//{
// string URL = string.Empty;
// bool IsExist = ConfigurationSettings.AppSettings.AllKeys.Contains(lab);
// if (IsExist)
// {
// URL = ConfigurationSettings.AppSettings[lab];
// }
// return URL;
//}
///// <summary>
///// 执行各地webservice方法
///// </summary>
///// <param name="lab"></param>
///// <returns></returns>
//public static string Execute(string lab, string methodname, object[] obj)
//{
// if (lab == string.Empty) { return ErrorCode.Login_1001; }
// string url = getURL(lab);
// if (url == string.Empty)
// {
// return string.Format(ErrorCode.Login_1002 + " 分点代码[ {0} ]！", lab);
// }
// return InvokeWebservice(url, "LISWebService", "LISService", methodname, obj).ToString();
//}
/// <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/GSP_WorkflowWebservice/common.asmx","Genersoft.Platform.Service.Workflow","Common","GetToolType",new object[]{"1"});
/// </code>
/// </example>
public static object InvokeWebservice(string url, string @namespace, string classname, string methodname, object[] args)
{
WebClient wc = null;
Stream stream = null;
try
{
wc = new WebClient();
stream = wc.OpenRead(url + "?WSDL");
ServiceDescription sd = ServiceDescription.Read(stream);
ServiceDescriptionImporter sdi = new ServiceDescriptionImporter();
sdi.AddServiceDescription(sd, "", "");
CodeNamespace cn = new CodeNamespace(@namespace);
CodeCompileUnit ccu = new CodeCompileUnit();
ccu.Namespaces.Add(cn);
sdi.Import(cn, ccu);
CSharpCodeProvider csc = new CSharpCodeProvider();
//CodeDomProvider icc = csc.crete;
CompilerParameters cplist = new 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");
CompilerResults cr = CodeDomProvider.CreateProvider("C#").CompileAssemblyFromDom(cplist, ccu);
if (true == cr.Errors.HasErrors)
{
StringBuilder sb = new StringBuilder();
foreach (CompilerError ce in cr.Errors)
{
sb.Append(ce.ToString());
sb.Append(System.Environment.NewLine);
}
throw new Exception(sb.ToString());
}
Assembly assembly = cr.CompiledAssembly;
Type t = assembly.GetType(@namespace + "." + classname, true, true);
object obj = Activator.CreateInstance(t);
MethodInfo mi = t.GetMethod(methodname);
csc.Dispose();
return(mi.Invoke(obj, args));
}
catch (Exception ex)
{
return(string.Format(" {0} \r\n 请求地址：[ {1} ] \r\n {2}", ex.Message, url, ex.InnerException == null ? "" : ex.InnerException.Message));
}
finally
{
stream.Close();
wc.Dispose();
GC.Collect();
}
}
public void Dispose()
{
_provider?.Dispose();
if (_ownStream)
{
_stream?.Dispose();
}
_document?.Dispose();
}
/// <exception cref="Exception"><c>Exception</c>.</exception>
public void CreateLauncher(bool retributionLauncher)
{
LoggingManager.SendMessage("ModPacker - Generating launcher for mod " + ModManager.ModName);
string outputPath = m_sOutputDirectory + "Launch " + ModManager.ModName + ".exe";
CodeDomProvider provider = null;
try
{
var provOpts = new Dictionary <string, string> {
{ "CompilerVersion", "v2.0" }
};
provider = new CSharpCodeProvider(provOpts);
var compilerParams = new CompilerParameters
{
GenerateExecutable = true,
IncludeDebugInformation = false,
OutputAssembly = outputPath
};
compilerParams.ReferencedAssemblies.Add("System.dll");
// set an icon if the user wishes to include one
if (m_sIconPath != string.Empty && File.Exists(m_sIconPath))
{
compilerParams.CompilerOptions = "/win32icon:\"" + m_sIconPath + "\"";
}
string tmp = Resources.CrudeLauncherSource.Replace("_MODNAME_", ModManager.ModName);
tmp = tmp.Replace("_APPID_", retributionLauncher ? GameConstants.RETRIBUTION_APP_ID : GameConstants.CR_APP_ID);
provider.CompileAssemblyFromSource(compilerParams, tmp);
provider.Dispose();
}
catch (Exception ex)
{
if (provider != null)
{
provider.Dispose();
}
LoggingManager.SendMessage("ModPacker - Failed to create launcher for mod " + ModManager.ModName);
LoggingManager.HandleException(ex);
throw;
}
LoggingManager.SendMessage("ModPacker - Successfully created launcher for mod " + ModManager.ModName);
}
private bool disposedValue = false; // To detect redundant calls
void Dispose(bool disposing)
{
if (!disposedValue)
{
if (disposing)
{
codeProvider.Dispose();
}
disposedValue = true;
}
}
private bool disposedValue = false; // To detect redundant calls
protected virtual void Dispose(bool disposing)
{
if (!disposedValue)
{
disposedValue = true;
if (disposing)
{
codeProvider.Dispose();
}
}
}
static public void Dispose()
{
if (CSharpCodeProvider != null)
{
CSharpCodeProvider.Dispose();
CSharpCodeProvider = null;
}
if (PythonEngine != null)
{
PythonEngine.Runtime.Shutdown();
PythonEngine = null;
}
}
protected virtual void Dispose(bool disposing)
{
if (_disposed)
{
return;
}
if (disposing)
{
_cSharpCodeProvider.Dispose();
}
_disposed = true;
}
private void ThrowIfErrorsIn(CompilerResults results, IEnumerable <SourceFile> files)
{
if (results.Errors.Count > 0)
{
StringBuilder message = new StringBuilder();
CodeDomProvider cSharpCodeProvider;
try
{
cSharpCodeProvider = CodeDomProvider.GetCompilerInfo("csharp").CreateProvider();
}
catch (SecurityException)
{
cSharpCodeProvider = new CSharpCodeProvider();
}
catch (ConfigurationException)
{
cSharpCodeProvider = new CSharpCodeProvider();
}
try
{
foreach (SourceFile file in files)
{
CompilerResults result = cSharpCodeProvider.CompileAssemblyFromSource(parameters, file.ConcreteClass);
if (result.Errors.Count > 0)
{
foreach (CompilerError err in result.Errors)
{
message.AppendLine(string.Format(@"
On '{0}' (class name: {1}) Line {2}, Column {3}, {4} {5}:
{6}
========================================",
file.ViewName,
file.ClassName,
err.Line,
err.Column,
err.IsWarning ? "Warning" : "Error",
err.ErrorNumber,
err.ErrorText));
}
}
}
}
finally
{
cSharpCodeProvider.Dispose();
}
throw new Exception("Error while compiling views: " + message);
}
}
public string Build()
{
IEnumerable <FunctionEntry> entries;
using (StreamReader reader = new StreamReader(_commandOptions.Input, Encoding.GetEncoding("SHIFT_JIS")))
using (var csv = new CsvReader(reader, new CultureInfo("ja-JP", false)))
{
csv.Configuration.HasHeaderRecord = true;
entries = csv.GetRecords <FunctionEntry>().ToList();
}
var unit = new CodeCompileUnit();
var @namespace = _commandOptions.ClassNamespace != null
? new CodeNamespace(_commandOptions.ClassNamespace)
: new CodeNamespace();
var @class = new CodeTypeDeclaration(NoConflictSyntaxText(_commandOptions.ClassName));
@class.IsEnum = _commandOptions.Type == TypeSpec.Enum;
if (@class.IsEnum)
{
@class.BaseTypes.Add(new CodeTypeReference(typeof(long)));
}
foreach (FunctionEntry entry in entries)
{
var field = new CodeMemberField(typeof(long), SignatureParse(entry.Name, entry.Location));
field.InitExpression = new CodeSnippetExpression("0x" + entry.Location);
if (_commandOptions.Type == TypeSpec.Const)
{
field.Attributes = MemberAttributes.Const | MemberAttributes.Public;
}
field.Comments.Add(new CodeCommentStatement("<summary>" + EscapeDoc(entry.Signature) + "</summary>", true));
@class.Members.Add(field);
}
@namespace.Types.Add(@class);
unit.Namespaces.Add(@namespace);
CSharpCodeProvider provider = new CSharpCodeProvider();
using (StringWriter writer = new StringWriter())
{
provider.GenerateCodeFromCompileUnit(unit, writer, new CodeGeneratorOptions());
provider.Dispose();
return(writer.ToString());
}
}
/// <summary>
/// 动态编译类
/// </summary>
/// <param name="code"></param>
/// <param name="err"></param>
/// <returns></returns>
private static CompilerResults CompilerClass(string code, ref ErrorInfo err)
{
string pathServer = AppDomain.CurrentDomain.BaseDirectory + "Easyman.ScriptService.exe";
#region 判断类库是否存在
if (!System.IO.File.Exists(pathServer))
{
pathServer = AppDomain.CurrentDomain.BaseDirectory + "Bin\\Easyman.ScriptService.exe";
}
if (!System.IO.File.Exists(pathServer))
{
err.IsError = true;
err.Message = string.Format("类库【{0}】不存在", pathServer);
return(null);
}
#endregion
CompilerResults cr = null;//初始化
using (CSharpCodeProvider objCSharpCodePrivoder = new CSharpCodeProvider())
{
ICodeCompiler objICodeCompiler = objCSharpCodePrivoder.CreateCompiler();
CompilerParameters objCompilerParameters = new CompilerParameters();
objCompilerParameters.ReferencedAssemblies.Add("System.dll");
objCompilerParameters.ReferencedAssemblies.Add("System.Windows.Forms.dll");
//objCompilerParameters.ReferencedAssemblies.Add(AppDomain.CurrentDomain.BaseDirectory + "Easyman.Librarys.dll");
objCompilerParameters.ReferencedAssemblies.Add(pathServer);
objCompilerParameters.GenerateExecutable = false;
objCompilerParameters.GenerateInMemory = true;
cr = objICodeCompiler.CompileAssemblyFromSource(objCompilerParameters, code);
if (cr.Errors.HasErrors)
{
StringBuilder sb = new StringBuilder("编译错误：");
foreach (CompilerError e in cr.Errors)
{
sb.AppendLine(string.Format("行{0}列{1}：{2}\r\n", e.Line - 12, e.Column, e.ErrorText));
}
err.IsError = true;
err.Message = sb.ToString();
return(null);
}
objCSharpCodePrivoder.Dispose();//手动释放
}
return(cr);
}
protected void AssertCompilationFails(string expectedError, string csharpline)
{
CSharpCodeProvider codeProvider = null;
try
{
codeProvider = new CSharpCodeProvider();
var compilerparams = new CompilerParameters();
compilerparams.GenerateExecutable = false;
compilerparams.GenerateInMemory = true;
compilerparams.ReferencedAssemblies.Add("System.dll");
compilerparams.ReferencedAssemblies.Add("System.Core.dll");
compilerparams.ReferencedAssemblies.Add("System.Numerics.dll");
compilerparams.ReferencedAssemblies.Add("NGenericDimensions.dll");
var className = "UnitTestDynamicCompiledCode";
string codeStr = @"
public static class " + className + @"
{
public static void Eval()
{
" + csharpline + @";
}
}";
var results = codeProvider.CompileAssemblyFromSource(compilerparams, codeStr);
var resultsMessage = string.Join(@" | ", results.Errors.OfType <CompilerError>().Select(e => e.ToString()));
if (string.IsNullOrEmpty(expectedError))
{
Assert.IsFalse(results.Errors.HasErrors, resultsMessage);
}
else
{
Assert.IsTrue(resultsMessage.Contains(expectedError), resultsMessage);
}
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
finally
{
codeProvider.Dispose();
}
}
/// <summary>
/// ±àÒë
/// </summary>
/// <param name="code">´úÂë</param>
/// <param name="errorMessage">´íÎóÐÅÏ¢</param>
/// <returns></returns>
public static CodeGenInfo DoCompiler(string code, string className, List <string> dllReference, StringBuilder errorMessage)
{
using (CodeDomProvider cdp = new CSharpCodeProvider(_codeProviderVersion))
{
// ±àÒëÆ÷µÄ²ÎÊý
CompilerParameters cp = new CompilerParameters();
cp.ReferencedAssemblies.Add("System.dll");
cp.ReferencedAssemblies.Add("System.Data.dll");
cp.ReferencedAssemblies.Add("System.Xml.dll");
foreach (string link in dllReference)
{
if (!string.IsNullOrEmpty(link))
{
string elink = link.Trim('\r', '\n', ' ');
if (!string.IsNullOrEmpty(elink))
{
cp.ReferencedAssemblies.Add(elink);
}
}
}
cp.GenerateExecutable = false;
cp.GenerateInMemory = true;
// ±àÒë½á¹û
CompilerResults cr = cdp.CompileAssemblyFromSource(cp, code);
if (cr.Errors.HasErrors)
{
foreach (CompilerError cerror in cr.Errors)
{
errorMessage.AppendLine(cerror.ToString());
}
cdp.Dispose();
return(null);
}
else
{
Assembly ass = cr.CompiledAssembly;
Type objType = ass.GetType(className);
CodeGenInfo info = new CodeGenInfo(objType, code);
return(info);
}
}
}
internal static Assembly GetProxyAssembly(string wsdlUri, string codeNamespace)
{
var provider = new CSharpCodeProvider();
var client = new WebClient();
var referenceAssemblies = new[] { "system.dll", "System.Xml.dll", "System.Web.Services.dll" };
var wsdlStream = client.OpenRead(wsdlUri);
var wsdl = ServiceDescription.Read(wsdlStream);
var wsdlImport = new ServiceDescriptionImporter();
wsdlImport.AddServiceDescription(wsdl, null, null);
var proxyClassNamespace = new CodeNamespace(codeNamespace);
var codeCompileUnit = new CodeCompileUnit();
codeCompileUnit.Namespaces.Add(proxyClassNamespace);
var warnings = wsdlImport.Import(proxyClassNamespace, codeCompileUnit);
if (warnings != 0)
{
throw new ApplicationException("SOAPHTTPRequestResponseStep experienced problems while importing the WSDL!");
}
var compileParam = new CompilerParameters(referenceAssemblies)
{
GenerateInMemory = false,
OutputAssembly = GetProxyFileName()
};
CompilerResults compilerResults = provider.CompileAssemblyFromDom(compileParam, codeCompileUnit);
if (compilerResults.Errors.HasErrors)
{
throw new ApplicationException("SOAPHTTPRequestResponseStep experienced problems while executing CompileAssemblyFromDom");
}
provider.Dispose();
return(compilerResults.CompiledAssembly);
}
public static void Initialize()
{
CSharpCodeProvider codeProvider = new CSharpCodeProvider();
CompilerParameters parameters = new CompilerParameters();
parameters.GenerateExecutable = false;
parameters.GenerateInMemory = true;
parameters.OutputAssembly = string.Empty;
parameters.IncludeDebugInformation = false;
parameters.ReferencedAssemblies.Add(Assembly.GetExecutingAssembly().Location);
parameters.ReferencedAssemblies.Add("System.Drawing.dll");
var files = Directory.GetFiles(Path.Combine(Environment.CurrentDirectory, PATH)).Where(x => Path.GetExtension(x) == EXTENSION).ToArray();
CompilerResults results = codeProvider.CompileAssemblyFromFile(parameters, files);
if (results.Errors.Count > 0)
{
StringBuilder sb = new StringBuilder();
foreach (CompilerError err in results.Errors)
{
sb.AppendLine(string.Format("{0}({1},{2}) : {3}", Path.GetFileName(err.FileName), err.Line, err.Column, err.ErrorText));
}
Logger.Write(sb.ToString(), MessageState.WARNING);
Console.Read();
Environment.Exit(0);
}
codeProvider.Dispose();
foreach (var type in results.CompiledAssembly.GetTypes())
{
Scripts.Add(type.Name, type);
}
}
internal static Type BuildWithAttrCS(string source, string[] additionalReferencedAssemblies = null)
{
CSharpCodeProvider codeProvider = new CSharpCodeProvider();
CompilerParameters parameters = new CompilerParameters();
parameters.GenerateExecutable = true;
parameters.GenerateInMemory = true;
parameters.ReferencedAssemblies.Add(typeof(Template.AttrFill).Assembly.Location);
parameters.ReferencedAssemblies.Add("System.Core.dll");
parameters.ReferencedAssemblies.Add("System.dll");
if (additionalReferencedAssemblies != null)
{
foreach (string dll in additionalReferencedAssemblies)
{
parameters.ReferencedAssemblies.Add(dll);
}
}
CompilerResults results = codeProvider.CompileAssemblyFromSource(parameters, source);
if (results.Errors.Count > 0)
{
string errs = "";
foreach (CompilerError CompErr in results.Errors)
{
errs += "Line number " + CompErr.Line +
", Error Number: " + CompErr.ErrorNumber +
", '" + CompErr.ErrorText + ";" + Environment.NewLine + Environment.NewLine;
}
}
var type = results.CompiledAssembly.GetTypes()[0];
codeProvider.Dispose();
return(type);
}
private static List <MethodInfo> FindAllMethods <T>()
{
var types = Assembly.GetExecutingAssembly().GetTypes();
// get BinaryReader extension methods from the executing assembly
var extensionMethods = (from type in types
where type.IsSealed && !type.IsGenericType && !type.IsNested
from method in type.GetMethods(BindingFlags.Static
| BindingFlags.Public | BindingFlags.NonPublic)
where method.IsDefined(typeof(ExtensionAttribute), false)
where method.GetParameters()[0].ParameterType == typeof(T)
select method).ToList();
// trim this down further to one of each return type
extensionMethods = (from method in extensionMethods
group method by method.ReturnType
into g
select g.First()).ToList();
var provider = new CSharpCodeProvider();
var methods = (from method in typeof(T).GetMethods()
where method.ReturnType != typeof(void)
select method).Where(x =>
{
var typeString = provider.CreateValidIdentifier((x.ReturnType).ToString());
typeString = typeString.Split('.').Last();
return(x.Name.ToLower().Contains(typeString.ToLower()));
}).ToList();
methods = (from method in methods
group method by method.ReturnType
into g
select g.First()).ToList();
var totalMethods = methods.Union(extensionMethods).ToList();
provider.Dispose();
return(totalMethods);
}
//编译类文件
private static Assembly CreateDynamiClass(string className, string classSource)
{
Assembly assembly;
CSharpCodeProvider provider = new CSharpCodeProvider();
CompilerParameters paras = new CompilerParameters();
//paras.ReferencedAssemblies.Add("Assets/Plugins/Editor/Excel/IConfig.dll");
paras.GenerateExecutable = false;
paras.GenerateInMemory = false;
CompilerResults result = provider.CompileAssemblyFromSource(paras, classSource);
assembly = result.CompiledAssembly;
provider.Dispose();
if (result.Errors.Count > 0)
{
foreach (CompilerError vCompilerError in result.Errors)
{
Debug.Log("错误：" + vCompilerError.ErrorText);
}
return(null);
}
return(assembly);
}
private static List <MethodInfo> FindAllMethodsByReturnValue <T>()
{
var types = Assembly.GetExecutingAssembly().GetTypes();
// get BinaryReader extension methods from the executing assembly
var extensionMethods = (from type in types
where type.IsSealed && !type.IsGenericType && !type.IsNested
from method in type.GetMethods(BindingFlags.Static
| BindingFlags.Public | BindingFlags.NonPublic)
where method.IsDefined(typeof(ExtensionAttribute), false)
where method.ReturnType == typeof(void)
where method.Name == "Write"
where method.Parameters().Count > 1 && method.Parameters()[0].ParameterType == typeof(T)
select method).ToList();
// trim this down further to one of each return type
extensionMethods = (from method in extensionMethods
group method by method.Parameters()[1].ParameterType
into g
select g.First()).ToList();
var provider = new CSharpCodeProvider();
var methods = (from method in typeof(T).GetMethods()
where method.ReturnType == typeof(void)
where method.Parameters().Count > 0
where method.Name == "Write"
select method).ToList();
methods = (from method in methods
group method by method.Parameters()[0].ParameterType
into g
select g.First()).ToList();
var totalMethods = methods.Union(extensionMethods).ToList();
provider.Dispose();
return(totalMethods);
}
