private bool init(string generateCode, params string[] referenceAssemblies)
{
bool flag = false;
result = null;
using (CSharpCodeProvider provider = new CSharpCodeProvider())
{
ICodeCompiler objICodeCompiler = provider.CreateCompiler();
CompilerParameters objCompilerParameters = new CompilerParameters();
if (referenceAssemblies != null)
objCompilerParameters.ReferencedAssemblies.AddRange(referenceAssemblies);
objCompilerParameters.GenerateExecutable = false;
objCompilerParameters.GenerateInMemory = true;
result = objICodeCompiler.CompileAssemblyFromSource(objCompilerParameters, generateCode);
}
if (result != null)
{
if (result.Errors.Count > 0 && ErrorHandler != null)
{
ErrorHandler(result.Errors);
}
else
{
flag = true;
}
}
return flag;
}
public bool Compile(string src)
{
var param = new CompilerParameters(new string[]
{
"System.dll",
"mscorlib.dll",
"System.Data.dll",
"System.Xml.dll",
"System.Xml.Linq.dll",
"lib.dll",
"compiler.dll",
});
param.GenerateInMemory = true;
param.GenerateExecutable = false;
param.IncludeDebugInformation = false;
_provider = new CSharpCodeProvider(
new Dictionary<string, string>()
{
{ "CompilerVersion", "v4.0" },
});
_results = _provider.CompileAssemblyFromSource(param, src);
if (_results.Errors.Count > 0)
{
foreach (CompilerError err in _results.Errors)
{
if (err.IsWarning) Console.WriteLine("[Warning] {0}: [{1}] {2}", err.Line, err.ErrorNumber, err.ErrorText);
else Console.WriteLine("[Error] {0}: [{1}] {2}", err.Line, err.ErrorNumber, err.ErrorText);
}
return false;
}
return true;
}
public BuildManagerCacheItem (Assembly assembly, BuildProvider bp, CompilerResults results)
{
this.BuiltAssembly = assembly;
this.CompiledCustomString = bp.GetCustomString (results);
this.VirtualPath = bp.VirtualPath;
this.Type = bp.GetGeneratedType (results);
}
public System.CodeDom.Compiler.CompilerResults compileAndReturnCompilerResultsObject(string file, string[] strReferenceAssembliesToAdd)
{
try
{
//Create an AppDomain to compile and execute the code
//This enables us to cancel the execution if needed
//executionDomain = AppDomain.CreateDomain("ExecutionDomain");
//IScriptManager manager = (IScriptManager)executionDomain.CreateInstanceFromAndUnwrap(typeof(BaseApp).Assembly.Location, typeof(ScriptManager).FullName);
ScriptManager smScriptManager = new ScriptManager();
System.CodeDom.Compiler.CompilerResults scCompilerResults = smScriptManager.CompileFile(file, strReferenceAssembliesToAdd, this);
return(scCompilerResults);
}
catch (UnsupportedLanguageExecption e)
{
ShowErrorMessage("UnsupportedLanguage (from resource):" + e.Extension);
}
catch (AppDomainUnloadedException e)
{
System.Diagnostics.Trace.WriteLine(e.Message);
}
catch (Exception e)
{
ShowErrorMessage(e.Message);
}
TerminateExecutionLoop();
return(null);
}
public override Type GetGeneratedType(CompilerResults results)
{
Type type;
try
{
using (Stream stream = base.OpenStream())
{
XamlXmlReader reader2 = new XamlXmlReader(XmlReader.Create(stream));
while (reader2.Read())
{
if (reader2.NodeType == XamlNodeType.StartObject)
{
if (reader2.Type.IsUnknown)
{
StringBuilder sb = new StringBuilder();
this.AppendTypeName(reader2.Type, sb);
throw FxTrace.Exception.AsError(new TypeLoadException(System.Xaml.Hosting.SR.CouldNotResolveType(sb)));
}
return reader2.Type.UnderlyingType;
}
}
throw FxTrace.Exception.AsError(new HttpCompileException(System.Xaml.Hosting.SR.UnexpectedEof));
}
}
catch (XamlParseException exception)
{
throw FxTrace.Exception.AsError(new HttpCompileException(exception.Message, exception));
}
return type;
}
/// <summary>
/// get an Assembly according to wsdl path.
/// </summary>
/// <param name="wsdl">wsdl path</param>
/// <param name="nameSpace">namespace</param>
/// <returns>return Assembly</returns>
public static Assembly GetWebServiceAssembly(string wsdl, string nameSpace)
{
try
{
System.Net.WebClient webClient = new System.Net.WebClient();
System.IO.Stream webStream = webClient.OpenRead(wsdl);
ServiceDescription serviceDescription = ServiceDescription.Read(webStream);
ServiceDescriptionImporter serviceDescroptImporter = new ServiceDescriptionImporter();
serviceDescroptImporter.AddServiceDescription(serviceDescription, "", "");
System.CodeDom.CodeNamespace codeNameSpace = new System.CodeDom.CodeNamespace(nameSpace);
System.CodeDom.CodeCompileUnit codeCompileUnit = new System.CodeDom.CodeCompileUnit();
codeCompileUnit.Namespaces.Add(codeNameSpace);
serviceDescroptImporter.Import(codeNameSpace, codeCompileUnit);
System.CodeDom.Compiler.CodeDomProvider codeDom = new Microsoft.CSharp.CSharpCodeProvider();
System.CodeDom.Compiler.CompilerParameters codeParameters = new System.CodeDom.Compiler.CompilerParameters();
codeParameters.GenerateExecutable = false;
codeParameters.GenerateInMemory = true;
codeParameters.ReferencedAssemblies.Add("System.dll");
codeParameters.ReferencedAssemblies.Add("System.XML.dll");
codeParameters.ReferencedAssemblies.Add("System.Web.Services.dll");
codeParameters.ReferencedAssemblies.Add("System.Data.dll");
System.CodeDom.Compiler.CompilerResults compilerResults = codeDom.CompileAssemblyFromDom(codeParameters, codeCompileUnit);
return(compilerResults.CompiledAssembly);
}
catch (Exception ex)
{
throw ex;
}
}
private void handleErrors(CompilerResults compilerResults)
{
if (compilerResults.Errors.Count > 0)
{
StringBuilder sb = new StringBuilder("Error compiling the composition script:\n");
foreach (CompilerError compilerError in compilerResults.Errors)
{
if (!compilerError.IsWarning)
{
sb.Append("\nError number:\t")
.Append(compilerError.ErrorNumber)
.Append("\nMessage:\t ")
.Append(compilerError.ErrorText)
.Append("\nLine number:\t")
.Append(compilerError.Line);
}
}
if (!sb.Length.Equals(0))
{
throw new PicoCompositionException(sb.ToString());
}
}
}
internal Type GetGeneratedType(CompilerResults results, bool useDelayLoadTypeIfEnabled)
{
string str;
if (!this.Parser.RequiresCompilation)
{
return null;
}
if (this._instantiatableFullTypeName == null)
{
if (this.Parser.CodeFileVirtualPath == null)
{
return this.Parser.BaseType;
}
str = this._intermediateFullTypeName;
}
else
{
str = this._instantiatableFullTypeName;
}
if (useDelayLoadTypeIfEnabled && DelayLoadType.Enabled)
{
return new DelayLoadType(Util.GetAssemblyNameFromFileName(Path.GetFileName(results.PathToAssembly)), str);
}
return results.CompiledAssembly.GetType(str);
}
private static _Assembly Check(CompilerResults results) {
if (results.Errors.Count > 0) {
throw new CompilerException(results);
}
return results.CompiledAssembly;
}
/// <summary>
/// This function is called on every recompilation to discard all previous results
/// </summary>
private void Reset()
{
_compilerResults = null;
_outputSettings = null;
_qil = null;
_command = null;
}
private void CacheCompileErrors(AssemblyBuilder assemblyBuilder, CompilerResults results)
{
System.Web.Compilation.BuildProvider provider = null;
foreach (CompilerError error in results.Errors)
{
if (!error.IsWarning)
{
System.Web.Compilation.BuildProvider buildProviderFromLinePragma = assemblyBuilder.GetBuildProviderFromLinePragma(error.FileName);
if (((buildProviderFromLinePragma != null) && (buildProviderFromLinePragma is BaseTemplateBuildProvider)) && (buildProviderFromLinePragma != provider))
{
provider = buildProviderFromLinePragma;
CompilerResults results2 = new CompilerResults(null);
foreach (string str in results.Output)
{
results2.Output.Add(str);
}
results2.PathToAssembly = results.PathToAssembly;
results2.NativeCompilerReturnValue = results.NativeCompilerReturnValue;
results2.Errors.Add(error);
HttpCompileException compileException = new HttpCompileException(results2, assemblyBuilder.GetGeneratedSourceFromBuildProvider(buildProviderFromLinePragma));
BuildResult result = new BuildResultCompileError(buildProviderFromLinePragma.VirtualPathObject, compileException);
buildProviderFromLinePragma.SetBuildResultDependencies(result);
BuildManager.CacheVPathBuildResult(buildProviderFromLinePragma.VirtualPathObject, result, this._utcStart);
}
}
}
}
private void BuildClientDll(string rootPath)
{
BuildDbFakeLibrary(rootPath);
BuildFakeSyncLibrary(rootPath);
String clientFileName = System.IO.Path.Combine(rootPath, @"code\Client.cs");
String clientMetadataFileName = System.IO.Path.Combine(rootPath, @"code\ClientMetadata.cs");
String clientConstantsFileName = System.IO.Path.Combine(rootPath, @"code\ClientConstants.cs");
String fileName = System.IO.Path.Combine(rootPath, @"bin\Client.dll");
CSharpCodeProvider codeProvider = new CSharpCodeProvider();
System.CodeDom.Compiler.CompilerParameters parameters = new System.CodeDom.Compiler.CompilerParameters();
parameters.GenerateExecutable = false;
parameters.OutputAssembly = fileName;
parameters.TempFiles = new TempFileCollection(String.Format(@"{0}\bin", rootPath));
parameters.ReferencedAssemblies.Add(@"System.dll");
parameters.ReferencedAssemblies.Add(System.IO.Path.Combine(rootPath, @"bin\SyncLibrary.dll"));
parameters.ReferencedAssemblies.Add(System.IO.Path.Combine(rootPath, @"bin\DbEngine.dll"));
string[] fileArray = new string[] { clientFileName, clientMetadataFileName, clientConstantsFileName };
System.CodeDom.Compiler.CompilerResults results = codeProvider.CompileAssemblyFromFile(parameters, fileArray);
CheckCompilerResults(results);
}
// Build an assembly from a list of source strings.
public override CompilerResults CompileAssemblyFromSource(CompilerParameters options, params string[] sources)
{
var root = new Root();
foreach(string code in sources)
parser.Parse(root, code);
if(root.CompilerErrors.Count > 0)
{
var results = new CompilerResults(null);
foreach(var e in root.CompilerErrors)
results.Errors.Add(e);
return results;
}
validator.Validate(options, root);
if (root.CompilerErrors.Count > 0)
{
var results = new CompilerResults(null);
foreach (var e in root.CompilerErrors)
results.Errors.Add(e);
return results;
}
var codeDomEmitter = new CodeDomEmitter();
return codeDomEmitter.Emit(options, root);
}
static string GetOutput(CompilerResults results)
{
var message = new StringBuilder();
foreach(var s in results.Output)
message.AppendLine(s);
return message.ToString();
}
/// <summary>
/// 动态编译
/// </summary>
/// <returns></returns>
public bool Compile()
{
try
{
compileErrInfo = "";
//3>动态编译
result = provider.CompileAssemblyFromSource(parameters, new string[] { SourceText });
if (result.Errors.Count > 0)
{
isCompileSucc = false;
Console.Write("编译出错！");
StringBuilder builder = new StringBuilder();
foreach (CompilerError error in result.Errors)
{
builder.Append(error.ToString());
builder.Append("\r\n");
}
compileErrInfo = builder.ToString();
}
else
{
isCompileSucc = true;
assembly = result.CompiledAssembly;
}
return isCompileSucc;
}
catch (System.Exception ex)
{
return false;
}
}
public CompilerResults CompileAssemblyFromDomBatch(CompilerParameters options, CodeCompileUnit[] compilationUnits)
{
Setup(options, ContainsLocalFunctions(compilationUnits));
foreach(var Unit in compilationUnits)
{
foreach (CodeAttributeDeclaration attribute in Unit.AssemblyCustomAttributes)
EmitAttribute(ABuilder, attribute);
EmitNamespace(ABuilder, Unit.Namespaces[0]);
}
ABuilder.SetEntryPoint(EntryPoint, PEFileKinds.WindowApplication);
Save();
var results = new CompilerResults(new TempFileCollection());
string output = options.OutputAssembly;
if (options.GenerateInMemory)
{
results.TempFiles.AddFile(output, false);
byte[] raw = File.ReadAllBytes(output);
results.CompiledAssembly = Assembly.Load(raw);
File.Delete(output);
}
else
results.PathToAssembly = Path.GetFullPath(output);
return results;
}
public List<CheckingResult> Compile(string program, out CompilerResults compilerResults)
{
compilerResults = null;
using (var provider = new CSharpCodeProvider())
{
compilerResults = provider.CompileAssemblyFromSource(new CompilerParameters(new string[]
{
"System.dll"
})
{
GenerateExecutable = true
},
new string[]
{
program
});
}
var result = new List<CheckingResult>();
if (compilerResults.Errors.HasErrors)
{
for (int i = 0; i < compilerResults.Errors.Count; i++)
result.Add(new CheckingResult
{
FirstErrorLine = compilerResults.Errors[i].Line,
FirstErrorColumn = compilerResults.Errors[i].Column,
Output = null,
Description = compilerResults.Errors[i].ErrorText
});
}
return result;
}
public TestsCompiler With(params string[] files)
{
result = provider.CompileAssemblyFromFile(parms,
files.Select(f => Path.Combine(baseDir, f)).ToArray());
outputErrorsIfAny();
return this;
}
private void Compile(CodeDom.CodeDomProvider provider, string source)
{
CodeDom.CompilerParameters param = new CodeDom.CompilerParameters();
param.GenerateExecutable = false;
param.IncludeDebugInformation = false;
param.GenerateInMemory = true;
CodeDom.CompilerResults cr = provider.CompileAssemblyFromSource(param, source);
Specialized.StringCollection output = cr.Output;
if (cr.Errors.Count != 0)
{
System.Console.WriteLine("Error invoking scripts.");
CodeDom.CompilerErrorCollection es = cr.Errors;
foreach (CodeDom.CompilerError s in es)
{
System.Console.WriteLine(s.ErrorText);
}
}
else
{
object o = cr.CompiledAssembly.CreateInstance("Script");
System.Type type = o.GetType();
type.InvokeMember("ScriptExecute",
Reflection.BindingFlags.InvokeMethod |
Reflection.BindingFlags.Default, null, o, null);
}
}
public override Type GetGeneratedType(CompilerResults results)
{
if (this.xamlBuildProviderExtension != null)
{
Type result = this.xamlBuildProviderExtension.GetGeneratedType(results);
if (result != null)
{
return result;
}
}
try
{
XamlType rootXamlType = GetRootXamlType();
if (rootXamlType.IsUnknown)
{
StringBuilder typeName = new StringBuilder();
AppendTypeName(rootXamlType, typeName);
throw FxTrace.Exception.AsError(new TypeLoadException(SR.CouldNotResolveType(typeName)));
}
return rootXamlType.UnderlyingType;
}
catch (XamlParseException ex)
{
throw FxTrace.Exception.AsError(new HttpCompileException(ex.Message, ex));
}
}
void Load (CompilerResults results, string fullName)
{
var assembly = results.CompiledAssembly;
Type transformType = assembly.GetType (fullName);
//MS Templating Engine does not look on the type itself,
//it checks only that required methods are exists in the compiled type
textTransformation = Activator.CreateInstance (transformType);
//set the host property if it exists
Type hostType = null;
var gen = host as TemplateGenerator;
if (gen != null) {
hostType = gen.SpecificHostType;
}
var hostProp = transformType.GetProperty ("Host", hostType ?? typeof(ITextTemplatingEngineHost));
if (hostProp != null && hostProp.CanWrite)
hostProp.SetValue (textTransformation, host, null);
var sessionHost = host as ITextTemplatingSessionHost;
if (sessionHost != null) {
//FIXME: should we create a session if it's null?
var sessionProp = transformType.GetProperty ("Session", typeof (IDictionary<string, object>));
sessionProp.SetValue (textTransformation, sessionHost.Session, null);
}
}
private static void ProcessResults(CompilerResults results)
{
if (results.Errors.Count != 0)
throw new CompilingErrorsException(results.Errors.OfType<CompilerError>().ToArray());
if (results.CompiledAssembly == null)
throw new CompilingException(CouldNotLocateAssemblyErrorMessage);
}
internal void AddCompilerErrorsFromCompilerResults(CompilerResults results)
{
foreach (CompilerError error in results.Errors)
base.Errors.Add(new WorkflowCompilerError(error));
foreach (string msg in results.Output)
base.Output.Add(msg);
}
/// <exception cref="TargetInvocationException">When the supplied assembly's main method throws</exception>
public void Execute(CompilerResults results, IEnumerable<string> additionalReferences)
{
var entryPoint = results.CompiledAssembly.EntryPoint;
using(serviceMessages.ProgressBlock("Executing script"))
ExecutePrivate(entryPoint, additionalReferences);
}
public CompilerErrorException(CompilerResults results)
{
foreach (CompilerError error in results.Errors)
{
this.CompilerMessage += error + "\n";
}
}
/// <summary>
/// Compile Script -> Return Assembly
/// </summary>
public Assembly CompileScript(IRefObject ScriptObject, out CompilerResults Result)
{
String ClassName, PrefixName;
switch (ScriptObject.Type)
{
case IRefObject.ScriptType.WEAPON:
ClassName = "ScriptWeapon";
PrefixName = "WeaponPrefix";
break;
default:
ClassName = "ScriptLevelNpc";
PrefixName = "LevelNpcPrefix";
break;
}
// Setup our options
CompilerParameters options = new CompilerParameters();
options.GenerateExecutable = false;
options.GenerateInMemory = true;
options.ReferencedAssemblies.Add(Assembly.GetExecutingAssembly().Location);
options.ReferencedAssemblies.Add("System.dll");
options.ReferencedAssemblies.Add("System.Core.dll");
options.ReferencedAssemblies.Add("Microsoft.CSharp.dll");
// Compile our code
CSharpCodeProvider csProvider = new Microsoft.CSharp.CSharpCodeProvider();
Result = csProvider.CompileAssemblyFromSource(options, "using CS_NPCServer; public class " + PrefixName + NextId[(int)ScriptObject.Type] + " : " + ClassName + " { public " + PrefixName + NextId[(int)ScriptObject.Type] + "(NPCServer Server, IRefObject Ref) : base(Server, Ref) { } " + ParseJoins(ScriptObject.Script) + " } ");
NextId[(int)ScriptObject.Type]++;
return (Result.Errors.HasErrors ? null : Result.CompiledAssembly);
}
public void Compile(string codeString)
{
this.Preprocess(codeString);
if (this.compilerParameters == null)
{
this.compilerParameters = InitializeCompilerParameters();
}
if (this.csharpCodeProvider == null)
{
this.csharpCodeProvider = new CSharpCodeProvider();
}
this.compiledProgram = this.csharpCodeProvider.CompileAssemblyFromSource(
this.compilerParameters, codeString);
// Check for compilation errors
if (this.compiledProgram.Errors.HasErrors)
{
var errorMsg = new StringBuilder();
foreach (CompilerError ce in this.compiledProgram.Errors)
{
errorMsg.AppendLine(ce.ToString());
}
throw new CompilationException(errorMsg.ToString());
}
}
/// <summary> 根据参数执行WebService </summary>
public static object InvokeWebService(string url, string classname, string methodname, object[] args)
{
try
{
string _namespace = "WebService";
if (string.IsNullOrEmpty(classname))
{
classname = GetClassName(url);
}
//获取服务描述语言(WSDL)
Net.WebClient wc = new Net.WebClient();
Stream stream = wc.OpenRead(url + "?WSDL"); //【1】
Web.Services.Description.ServiceDescription sd = Web.Services.Description.ServiceDescription.Read(stream); //【2】
Web.Services.Description.ServiceDescriptionImporter sdi = new Web.Services.Description.ServiceDescriptionImporter(); //【3】
sdi.AddServiceDescription(sd, "", "");
CodeDom.CodeNamespace cn = new CodeDom.CodeNamespace(_namespace); //【4】
//生成客户端代理类代码
CodeDom.CodeCompileUnit ccu = new CodeDom.CodeCompileUnit(); //【5】
ccu.Namespaces.Add(cn);
sdi.Import(cn, ccu);
//CSharpCodeProvider csc = new CSharpCodeProvider();//【6】
CodeDom.Compiler.CodeDomProvider csc = CodeDom.Compiler.CodeDomProvider.CreateProvider("CSharp");
//ICodeCompiler icc = csc.CreateCompiler();//【7】
//设定编译器的参数
CodeDom.Compiler.CompilerParameters cplist = new CodeDom.Compiler.CompilerParameters();//【8】
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");
//编译代理类
CodeDom.Compiler.CompilerResults cr = csc.CompileAssemblyFromDom(cplist, ccu);//【9】
if (true == cr.Errors.HasErrors)
{
System.Text.StringBuilder sb = new StringBuilder();
foreach (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 bj = Activator.CreateInstance(t); //【10】
System.Reflection.MethodInfo mi = t.GetMethod(methodname); //【11】
return(mi.Invoke(bj, args));
}
catch (System.Exception ex)
{
Common.LogHelper.Instance.WriteError(ex.Message + "|" + ex.StackTrace);
//MessageManager.ShowErrorMsg(ex.Message.ToString(), "test");
return(null);
}
}
public static void service_info_methods()
{
uri = new Uri("http://localhost:60377/Service1.asmx?wsdl");
WebRequest webRequest = WebRequest.Create(uri);
System.IO.Stream requestStream = webRequest.GetResponse().GetResponseStream();
// Get a WSDL file describing a service
ServiceDescription sd = ServiceDescription.Read(requestStream);
string sdName = sd.Services[0].Name;
// Initialize a service description servImport
ServiceDescriptionImporter servImport = new ServiceDescriptionImporter();
servImport.AddServiceDescription(sd, String.Empty, String.Empty);
servImport.ProtocolName = "Soap";
servImport.CodeGenerationOptions = CodeGenerationOptions.GenerateProperties;
CodeNamespace nameSpace = new CodeNamespace();
CodeCompileUnit codeCompileUnit = new CodeCompileUnit();
codeCompileUnit.Namespaces.Add(nameSpace);
// Set Warnings
ServiceDescriptionImportWarnings warnings = servImport.Import(nameSpace, codeCompileUnit);
if (warnings == 0)
{
StringWriter stringWriter = new StringWriter(System.Globalization.CultureInfo.CurrentCulture);
Microsoft.CSharp.CSharpCodeProvider prov = new Microsoft.CSharp.CSharpCodeProvider();
prov.GenerateCodeFromNamespace(nameSpace, stringWriter, new CodeGeneratorOptions());
string[] assemblyReferences = new string[2] { "System.Web.Services.dll", "System.Xml.dll" };
CompilerParameters param = new CompilerParameters(assemblyReferences);
param.GenerateExecutable = false;
param.GenerateInMemory = true;
param.TreatWarningsAsErrors = false;
param.WarningLevel = 4;
CompilerResults results = new CompilerResults(new TempFileCollection());
results = prov.CompileAssemblyFromDom(param, codeCompileUnit);
Assembly assembly = results.CompiledAssembly;
service = assembly.GetType(sdName);
methodInfo = service.GetMethods();
int c = 0;
foreach (MethodInfo t in methodInfo)
{
if (t.Name == "Discover")
break;
c++;
}
listurl = new string[c]; c = 0;
foreach (MethodInfo t in methodInfo)
{
if (t.Name == "Discover")
break;
listurl[c++] = t.Name;
}
}
}
/// <summary>
/// This method compiles the source given to it dynamically for use in plugins, etc...
///
/// --== History of Changes ==--
/// 11/05/2006 - Mike : Removed the compiler variable and called the provider method
/// CompilerAssemblyFromFile directly. I did this to remove a warning.
/// </summary>
/// <param name="strFile">The file we wish to compile</param>
/// <param name="strReferenceAssembliesToAdd">Assemblies that need to be included in the compile</param>
/// <returns>The results of the compile</returns>
public System.CodeDom.Compiler.CompilerResults CompileSourceCode(string strFile, string[] strReferenceAssembliesToAdd) // [DC]
{
//Currently only csharp scripting is supported
CodeDomProvider provider;
string extension = Path.GetExtension(strFile);
switch (extension)
{
case ".tmp": // default tmp files to .cs
case ".cs":
case ".ncs":
provider = new Microsoft.CSharp.CSharpCodeProvider();
break;
case ".vb":
case ".nvb":
provider = new Microsoft.VisualBasic.VBCodeProvider();
break;
case ".njs":
case ".js":
provider = (CodeDomProvider)Activator.CreateInstance("Microsoft.JScript", "Microsoft.JScript.JScriptCodeProvider").Unwrap();
break;
default:
throw new UnsupportedLanguageExecption(extension);
}
System.CodeDom.Compiler.CompilerParameters compilerparams = new System.CodeDom.Compiler.CompilerParameters();
compilerparams.GenerateInMemory = true;
compilerparams.GenerateExecutable = true;
// manually add references (since he nfr bellow system will need to be implemented a diferent way)
compilerparams.ReferencedAssemblies.Add("System.dll");
compilerparams.ReferencedAssemblies.Add("System.Windows.Forms.Dll");
foreach (string strReferenceAssemblyToAdd in strReferenceAssembliesToAdd)
{
compilerparams.ReferencedAssemblies.Add(strReferenceAssemblyToAdd);
}
// we don't use this (since the extra references are retrieved from the Xml file
/*
* //Add assembly references from nscript.nrf or <file>.nrf
* string nrfFile = Path.ChangeExtension(strFile, "nrf");
*
* if (File.Exists(nrfFile))
* AddReferencesFromFile(compilerparams, nrfFile);
* else
* {
* //Use nscript.nrf
* nrfFile = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "nscript.nrf");
*
* if (File.Exists(nrfFile))
* AddReferencesFromFile(compilerparams, nrfFile);
* }
* */
System.CodeDom.Compiler.CompilerResults crResults = provider.CompileAssemblyFromFile(compilerparams, strFile);
return(crResults);
}
static void AssertNoErrors(CompilerResults results)
{
if (results.Errors.Count == 0)
return;
CompilerError firstError = results.Errors[0];
throw new ArgumentException(String.Format("{2} at ({0},{1})", firstError.Line, firstError.Column, firstError.ErrorText));
}
internal override BuildResult CreateBuildResult(CompilerResults results)
{
if (base.Parser.RequiresCompilation)
{
return base.CreateBuildResult(results);
}
return this.CreateNoCompileBuildResult();
}
public CompilerException(CodeDomProvider provider,CompilerResults result,CompilerParameters parameters,String ErrorInfo)
: base(ErrorInfo)
{
this.CompilerResults = result;
this.CompilerProvider = provider;
this.CompilerParameters = parameters;
}
public override Type GetGeneratedType(CompilerResults results)
{
if (this._parser.HasInlineCode)
{
return this._parser.GetTypeToCache(results.CompiledAssembly);
}
return this._parser.GetTypeToCache(null);
}
/// <summary>
/// Runs the specified arguments.
/// </summary>
/// <param name="compilerResults">The compiler results.</param>
/// <param name="execMethod">The exec method.</param>
/// <param name="output">The output.</param>
/// <param name="arguments">The arguments.</param>
/// <returns></returns>
public virtual object Run(CompilerResults compilerResults, string execMethod, StringBuilder output, params string[] arguments)
{
// Find the method in the assembly
using (new ConsoleRerouter(output))
{
return ReflectionUtilities.InvokeMethod(compilerResults.CompiledAssembly, execMethod, new object[] { arguments });
}
}
internal override BuildResult CreateBuildResult(CompilerResults results) {
// If the page is compiled, use the default base class logic
if (Parser.RequiresCompilation)
return base.CreateBuildResult(results);
return CreateNoCompileBuildResult();
}
public static object WebserviceInvoke(string p_strUrl, string p_strNameSpace, string p_strClassName, string p_strMethodName, object[] p_objArgs)
{
object oReturnValue = null;
try
{
if (p_strNameSpace == "")
{
p_strNameSpace = "EnterpriseServerBase.WebService.DynamicWebCalling";
}
if (p_strClassName == "")
{
p_strClassName = WebServiceHelper.GetWsClassName(p_strUrl);
}
System.Net.WebClient wc = new System.Net.WebClient();
System.IO.Stream stream = wc.OpenRead(p_strUrl + "?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(p_strNameSpace);
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.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 = csc.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(p_strNameSpace + "." + p_strClassName, true, true);
object obj = Activator.CreateInstance(t);
System.Reflection.MethodInfo mi = t.GetMethod(p_strMethodName);
oReturnValue = mi.Invoke(obj, p_objArgs);
}
catch (Exception ex)
{
throw new Exception(ex.InnerException.Message, new Exception(ex.InnerException.StackTrace));
}
return(oReturnValue);
}
public void executeCode(System.CodeDom.Compiler.CompilerResults crResults, string[] args)
{
crResults.CompiledAssembly.EntryPoint.Invoke(null, BindingFlags.Static, null, new object[] { args }, null);
Type[] tTypes = crResults.CompiledAssembly.GetTypes();
foreach (Type tType in tTypes)
{
foreach (MethodInfo mi in tType.GetMethods())
{
Console.WriteLine(tType.FullName + "." + mi.Name);
}
}
//return crResults;
}
/// <summary>
/// 通过反射完成WS调用
/// </summary>
/// <param name="url">WSUrl</param>
/// <param name="namespace">WS命名空间</param>
/// <param name="classname">WS类名</class>
/// <param name="methodname">WS方法名</class>
/// <param name="args">传递给WS方法的参数</param>
/// 示例：url="http://win01:86";serviceUrl = "/Api/SiteGroupFunc.asmx";
/// object s = InvokeWebSer(url + serviceUrl, "SiteGroup", "SiteGroupFunc", "GetSiteName", new object[] { });
/// <returns>执行结果</returns>
public object InvokeWS(string url, string @namespace, string classname, string methodname, object[] args)
{
System.Net.WebClient wc = new System.Net.WebClient();
string URL = string.Empty;
if ((url.Substring(url.Length - 5, 5) != null) && ((url.Substring(url.Length - 5, 5).ToLower() != "?wsdl")))
{
URL = url + "?WSDL";
}
else
{
URL = url;
}
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, "", "");
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.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 = csc.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));
}
public static IFeatureComputeFuncProvider <TDataType, TFeature> CreateFeatureComputeFuncProvider <TDataType, TFeature>(int[] visitBandNos, string express, IArgumentProvider argProvider)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("public Func<int, %DataType%[], %Feature%> GetComputeFunc()");
sb.AppendLine("{");
sb.AppendLine(" return (idx, values) => { return " + GetFuncString(visitBandNos, express, "values[{0}]", argProvider) + ";};");
sb.AppendLine("}");
string s = sb.ToString();
string code = TemplateCode.FeatureComputeFuncTemplate;
code = code.Replace("%Func%", s);
code = code.Replace("%DataType%", typeof(TDataType).ToString());
code = code.Replace("%Feature%", typeof(TFeature).ToString());
Microsoft.CSharp.CSharpCodeProvider cp = new Microsoft.CSharp.CSharpCodeProvider();
System.CodeDom.Compiler.CompilerParameters cpar = new System.CodeDom.Compiler.CompilerParameters();
cpar.GenerateInMemory = true;
cpar.GenerateExecutable = false;
cpar.ReferencedAssemblies.Add("System.dll");
cpar.ReferencedAssemblies.Add(AppDomain.CurrentDomain.BaseDirectory + "GeoDo.RSS.MIF.Core.dll");
System.CodeDom.Compiler.CompilerResults cr = cp.CompileAssemblyFromSource(cpar, code);
StringBuilder errorMessages = new StringBuilder();
foreach (System.CodeDom.Compiler.CompilerError ce in cr.Errors)
{
errorMessages.AppendLine(ce.ErrorText + "行号:" + ce.Line + "列号:" + ce.Column);
}
if (cr.Errors.Count == 0 && cr.CompiledAssembly != null)
{
Type ObjType = cr.CompiledAssembly.GetType("GeoDo.RSS.MIF.Core.FuncBuilder");
try
{
if (ObjType != null)
{
object obj = Activator.CreateInstance(ObjType);
return(obj as IFeatureComputeFuncProvider <TDataType, TFeature>);
}
}
catch (Exception ex)
{
errorMessages.Append(ex.Message);
}
}
if (errorMessages != null && errorMessages.Length > 0)
{
throw new Exception(errorMessages.ToString());
}
return(null);
}
public static IPixelValuesOperator <T> GeneratePixelValuesOperator <T>(string express, out int[] bandNos)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("public Func<%DataType%[], float> GetOperatorFunc()");
sb.AppendLine("{");
sb.AppendLine(" return (values) => { return " + GetOperatorString(express, out bandNos) + ";};");
sb.AppendLine("}");
string s = sb.ToString();
string code = TemplateCode.FuncTemplate;
code = code.Replace("%Func%", s);
code = code.Replace("%DataType%", typeof(T).ToString());
Microsoft.CSharp.CSharpCodeProvider cp = new Microsoft.CSharp.CSharpCodeProvider();
System.CodeDom.Compiler.CompilerParameters cpar = new System.CodeDom.Compiler.CompilerParameters();
cpar.GenerateInMemory = true;
cpar.GenerateExecutable = false;
cpar.ReferencedAssemblies.Add("System.dll");
cpar.ReferencedAssemblies.Add(AppDomain.CurrentDomain.BaseDirectory + "GeoDo.RSS.RasterTools.dll");
System.CodeDom.Compiler.CompilerResults cr = cp.CompileAssemblyFromSource(cpar, code);
StringBuilder errorMessages = new StringBuilder();
foreach (System.CodeDom.Compiler.CompilerError ce in cr.Errors)
{
errorMessages.AppendLine(ce.ErrorText + "行号:" + ce.Line + "列号:" + ce.Column);
}
if (cr.Errors.Count == 0 && cr.CompiledAssembly != null)
{
Type ObjType = cr.CompiledAssembly.GetType("GeoDo.RSS.RasterTools.OperatorBuilder");
try
{
if (ObjType != null)
{
object obj = Activator.CreateInstance(ObjType);
return(obj as IPixelValuesOperator <T>);
}
}
catch (Exception ex)
{
errorMessages.Append(ex.Message);
}
}
if (errorMessages != null && errorMessages.Length > 0)
{
throw new Exception(errorMessages.ToString());
}
return(null);
}
/// <summary>
/// compiles a template into an assembly
/// </summary>
/// <param name="assemblies">the assemblies to refernce</param>
/// <param name="namespaces">the namespaces to add to the compiled template</param>
/// <param name="parameternames">the names of the parameters to be declared in the assembly (these can be used inside the template)</param>
/// <returns>the comiled assembly</returns>
public void Compile(string[] assemblies, string[] namespaces, TemplateParameters parameters)
{
Assemblies = assemblies;
Namespaces = namespaces;
Parameters = parameters;
Sections = Parser.ParsePage(Page);
CodeDomProvider provider = new Microsoft.CSharp.CSharpCodeProvider();
System.CodeDom.Compiler.CompilerParameters compilerparams = new System.CodeDom.Compiler.CompilerParameters();
compilerparams.GenerateInMemory = true;
compilerparams.GenerateExecutable = false;
// setup references assemblies
if (assemblies != null)
{
foreach (string assembly in assemblies)
{
compilerparams.ReferencedAssemblies.Add(assembly);
}
}
foreach (Section s in Sections)
{
if (s.Type == SectionType.Directive)
{
if (s.Values.Directive.ToLower() == "assembly")
{
string assembly;
if (s.Values.TryGetValue("name", out assembly))
{
compilerparams.ReferencedAssemblies.Add(assembly + ".dll");
}
}
}
}
string source = Sections.ExtractSource(namespaces, parameters);
if (source.Length > 0)
{
Result = provider.CompileAssemblyFromSource(compilerparams, new string[] { source });
Console.WriteLine(source);
}
}
////////////////////////////////////////////////////////DLLs///////////////////////////////////////////////////////////////
private void CheckCompilerResults(System.CodeDom.Compiler.CompilerResults results)
{
if (results.Errors.Count > 0)
{
String error = "";
foreach (System.CodeDom.Compiler.CompilerError CompErr in results.Errors)
{
error = error +
"Line number " + CompErr.Line +
", Error Number: " + CompErr.ErrorNumber +
", '" + CompErr.ErrorText + ";" +
Environment.NewLine + Environment.NewLine;
}
throw new Exception(error);
}
}
public void CompileAndExecuteFile(string file, string[] args, string[] strReferenceAssembliesToAdd, IScriptManagerCallback callback)
{
System.CodeDom.Compiler.CompilerResults crResults = CompileSourceCode(file, strReferenceAssembliesToAdd);
if (crResults.Errors.HasErrors)
{
System.Collections.ArrayList templist = new System.Collections.ArrayList();
foreach (System.CodeDom.Compiler.CompilerError error in crResults.Errors)
{
templist.Add(new CompilerError(error));
}
callback.OnCompilerError((CompilerError[])templist.ToArray(typeof(CompilerError)));
}
else
{
crResults.CompiledAssembly.EntryPoint.Invoke(null, BindingFlags.Static, null, new object[] { args }, null);
}
}
//<Snippet1>
// Displays information from a CompilerResults.
public static void DisplayCompilerResults(System.CodeDom.Compiler.CompilerResults cr)
{
// If errors occurred during compilation, output the compiler output and errors.
if (cr.Errors.Count > 0)
{
for (int i = 0; i < cr.Output.Count; i++)
{
Console.WriteLine(cr.Output[i]);
}
for (int i = 0; i < cr.Errors.Count; i++)
{
Console.WriteLine(i.ToString() + ": " + cr.Errors[i].ToString());
}
}
else
{
// Display information about the compiler's exit code and the generated assembly.
Console.WriteLine("Compiler returned with result code: " + cr.NativeCompilerReturnValue.ToString());
Console.WriteLine("Generated assembly name: " + cr.CompiledAssembly.FullName);
if (cr.PathToAssembly == null)
{
Console.WriteLine("The assembly has been generated in memory.");
}
else
{
Console.WriteLine("Path to assembly: " + cr.PathToAssembly);
}
// Display temporary files information.
if (!cr.TempFiles.KeepFiles)
{
Console.WriteLine("Temporary build files were deleted.");
}
else
{
Console.WriteLine("Temporary build files were not deleted.");
// Display a list of the temporary build files
IEnumerator enu = cr.TempFiles.GetEnumerator();
for (int i = 0; enu.MoveNext(); i++)
{
Console.WriteLine("TempFile " + i.ToString() + ": " + (string)enu.Current);
}
}
}
}
public System.CodeDom.Compiler.CompilerResults CompileFile(string file, string[] strReferenceAssembliesToAdd, IScriptManagerCallback callback)
{
System.CodeDom.Compiler.CompilerResults crResults = CompileSourceCode(file, strReferenceAssembliesToAdd);
if (crResults.Errors.HasErrors)
{
System.Collections.ArrayList templist = new System.Collections.ArrayList();
foreach (System.CodeDom.Compiler.CompilerError error in crResults.Errors)
{
templist.Add(new CompilerError(error));
}
callback.OnCompilerError((CompilerError[])templist.ToArray(typeof(CompilerError)));
return(null);
}
else
{
return(crResults);
}
}
public static IBandMathExecutor GenerateBandMathExecutor(string srcDataType, string dstDataType)
{
string code = TemplateCode.BandMathExecutorTemplate;
code = code.Replace("%SrcDataType%", srcDataType);
code = code.Replace("%DstDataType%", dstDataType);
Microsoft.CSharp.CSharpCodeProvider cp = new Microsoft.CSharp.CSharpCodeProvider();
System.CodeDom.Compiler.CompilerParameters cpar = new System.CodeDom.Compiler.CompilerParameters();
cpar.GenerateInMemory = true;
cpar.GenerateExecutable = false;
cpar.ReferencedAssemblies.Add("System.dll");
cpar.ReferencedAssemblies.Add(AppDomain.CurrentDomain.BaseDirectory + "GeoDo.RSS.Core.DF.dll");
cpar.ReferencedAssemblies.Add(AppDomain.CurrentDomain.BaseDirectory + "GeoDo.RSS.RasterTools.dll");
System.CodeDom.Compiler.CompilerResults cr = cp.CompileAssemblyFromSource(cpar, code);
StringBuilder errorMessages = new StringBuilder();
foreach (System.CodeDom.Compiler.CompilerError ce in cr.Errors)
{
errorMessages.AppendLine(ce.ErrorText + "行号:" + ce.Line + "列号:" + ce.Column);
}
if (cr.Errors.Count == 0 && cr.CompiledAssembly != null)
{
Type ObjType = cr.CompiledAssembly.GetType("GeoDo.RSS.RasterTools.BandMathExecutor");
try
{
if (ObjType != null)
{
object obj = Activator.CreateInstance(ObjType);
return(obj as IBandMathExecutor);
}
}
catch (Exception ex)
{
errorMessages.Append(ex.Message);
}
}
if (errorMessages != null && errorMessages.Length > 0)
{
throw new Exception(errorMessages.ToString());
}
return(null);
}
private bool BuildDbFakeLibrary(string rootPath)
{
String codeFile = System.IO.Path.Combine(rootPath, @"code\DbFake.cs");
String fileName = System.IO.Path.Combine(rootPath, @"bin\DbEngine.dll");
CSharpCodeProvider codeProvider = new CSharpCodeProvider();
System.CodeDom.Compiler.CompilerParameters parameters = new System.CodeDom.Compiler.CompilerParameters();
parameters.GenerateExecutable = false;
parameters.OutputAssembly = fileName;
parameters.TempFiles = new TempFileCollection(String.Format(@"{0}\bin", rootPath));
parameters.ReferencedAssemblies.Add(@"System.dll");
parameters.ReferencedAssemblies.Add(@"System.Linq.dll");
System.CodeDom.Compiler.CompilerResults results = codeProvider.CompileAssemblyFromFile(parameters, codeFile);
CheckCompilerResults(results);
return(true);
}
static void RunCompile(string openedFileName, string openedFileContent, IProjectContent pc)
{
var codeProvider = pc.Language.CodeDomProvider;
if (codeProvider == null)
{
return;
}
string fileContent1 = CreateLineMarker(1, openedFileName) + "\n" + openedFileContent;
StringWriter writer = new StringWriter();
Stopwatch watch = new Stopwatch();
watch.Start();
WriteClasses(pc, writer, openedFileName);
watch.Stop();
Console.WriteLine("WriteClasses for {0} took {1}ms", (pc.Project as IProject).Name, watch.ElapsedMilliseconds);
watch.Restart();
Compiler.CompilerResults cr = codeProvider.CompileAssemblyFromSource(GetParameters(pc.Project as CompilableProject), fileContent1, writer.ToString());
watch.Stop();
writer.Close();
var errors = cr.Errors.OfType <Compiler.CompilerError>().ToArray();
Console.WriteLine("CompileFile for {0} took {1}ms", (pc.Project as IProject).Name, watch.ElapsedMilliseconds);
WorkbenchSingleton.SafeThreadAsyncCall(
delegate() {
List <Task> tasks = new List <Task>();
foreach (Compiler.CompilerError e in errors)
{
tasks.Add(new Task(string.IsNullOrEmpty(e.FileName) ? null : new FileName(e.FileName), e.ErrorText + " (" + e.ErrorNumber + ")", e.Column, e.Line, e.IsWarning ? TaskType.Warning : TaskType.Error));
}
TaskService.ClearExceptCommentTasks();
TaskService.AddRange(tasks);
}
);
}
public override BuildProviderResultFlags GetResultFlags(System.CodeDom.Compiler.CompilerResults results)
{
return(BuildProviderResultFlags.Default);
}
public override string GetCustomString(System.CodeDom.Compiler.CompilerResults results)
{
return("No source code");
}
/// <summary>
/// 根据指定的信息，调用远程WebService方法
/// </summary>
/// <param name="strUrl">WebService的http形式的地址</param>
/// <param name="strNameSpace">欲调用的WebService的命名空间</param>
/// <param name="strClassName">欲调用的WebService的类名（不包括命名空间前缀）</param>
/// <param name="strMethodName">欲调用的WebService的方法名</param>
/// <param name="args">参数列表</param>
/// <returns>WebService的执行结果</returns>
public static object WebServiceInvoke(string strUrl, string strNameSpace, string strClassName, string strMethodName, object[] args)
{
try
{
//1.使用WebClient 下载WSDL信息
WebClient webClient = new WebClient();
Stream stream = webClient.OpenRead(strUrl + "?wsdl");
//2.创建和格式化WSDL文档
ServiceDescription serviceDescription = ServiceDescription.Read(stream);
//3. 创建客户端代理代理类
ServiceDescriptionImporter serviceDescriptionImporter = new ServiceDescriptionImporter();
serviceDescriptionImporter.ProtocolName = "Soap"; //指定访问协议
serviceDescriptionImporter.Style = ServiceDescriptionImportStyle.Client; //生成客户端代理，默认。
serviceDescriptionImporter.AddServiceDescription(serviceDescription, string.Empty, string.Empty); //添加WSDL文档。
//4 .使用 CodeDom 编译客户端代理类。
CodeNamespace codeNamespce = new CodeNamespace(strNameSpace);
CodeCompileUnit codeCompileUnit = new CodeCompileUnit();
codeCompileUnit.Namespaces.Add(codeNamespce);
serviceDescriptionImporter.Import(codeNamespce, codeCompileUnit);
CodeDomProvider codeDomProvider = CodeDomProvider.CreateProvider("CSharp");
//表示用于调用编译器的参数。
System.CodeDom.Compiler.CompilerParameters compilerParameters = new System.CodeDom.Compiler.CompilerParameters();
compilerParameters.GenerateExecutable = false; //设置是否生成可执行文件。
compilerParameters.GenerateInMemory = true; //设置是否在内存中生成输出。
compilerParameters.ReferencedAssemblies.Add("System.dll"); //ReferencedAssemblies 获取当前项目所引用的程序集。
compilerParameters.ReferencedAssemblies.Add("System.XML.dll");
compilerParameters.ReferencedAssemblies.Add("System.Web.Services.dll");
compilerParameters.ReferencedAssemblies.Add("System.Data.dll");
//获取从编译器返回的编译结果。
System.CodeDom.Compiler.CompilerResults compilerResults = codeDomProvider.CompileAssemblyFromDom(compilerParameters, codeCompileUnit);
if (true == compilerResults.Errors.HasErrors)
{
System.Text.StringBuilder stringBuilder = new System.Text.StringBuilder();
foreach (System.CodeDom.Compiler.CompilerError compilerError in compilerResults.Errors)
{
stringBuilder.Append(compilerError.ToString());
stringBuilder.Append(System.Environment.NewLine);
}
throw new Exception(stringBuilder.ToString());
}
//获取已编译的程序集，然后通过反射进行动态调用。
System.Reflection.Assembly assembly = compilerResults.CompiledAssembly;
Type type = assembly.GetType(strNameSpace + "." + strClassName, true, true); // 如果在前面为代理类添加了命名空间，此处需要将命名空间添加到类型前面。
object obj = Activator.CreateInstance(type);
System.Reflection.MethodInfo methodInfo = type.GetMethod(strMethodName);
return(methodInfo.Invoke(obj, args));
}
catch (Exception ex)
{
string strMessage = strUrl + "\t" + strNameSpace + "\t" + strClassName + "\t" + strMethodName + "\t" + ex.Message.Replace("\r", string.Empty).Replace("\n", string.Empty);
LogLogic.Write(strMessage + "\r\n", ERROR_WRITE_LOG_PATH, ERROR_WRITE_LOG_EXTENSION);
//throw new Exception(ex.InnerException.Message, new Exception(ex.InnerException.StackTrace));
return(string.Empty);
}
}
/// <summary>
/// Function to compile .Net C#/VB source codes at runtime
/// </summary>
/// <param name="_CodeProvider">Base class for compiler provider</param>
/// <param name="_SourceCode">C# or VB source code as a string</param>
/// <param name="_SourceFile">External file containing C# or VB source code</param>
/// <param name="_ExeFile">File path to create external executable file</param>
/// <param name="_AssemblyName">File path to create external assembly file</param>
/// <param name="_ResourceFiles">Required resource files to compile the code</param>
/// <param name="_Errors">String variable to store any errors occurred during the process</param>
/// <returns>Return TRUE if successfully compiled the code, else return FALSE</returns>
private bool CompileCode(System.CodeDom.Compiler.CodeDomProvider _CodeProvider, string _SourceCode, string _SourceFile, string _ExeFile, string _AssemblyName, string[] _ResourceFiles, ref string _Errors)
{
// set interface for compilation
System.CodeDom.Compiler.ICodeCompiler _CodeCompiler = _CodeProvider.CreateCompiler();
// Define parameters to invoke a compiler
System.CodeDom.Compiler.CompilerParameters _CompilerParameters =
new System.CodeDom.Compiler.CompilerParameters();
if (_ExeFile != null)
{
// Set the assembly file name to generate.
_CompilerParameters.OutputAssembly = _ExeFile;
// Generate an executable instead of a class library.
_CompilerParameters.GenerateExecutable = true;
_CompilerParameters.GenerateInMemory = false; // Esto será lo que haya que cambiar para que se cargue en memoria
}
else if (_AssemblyName != null)
{
// Set the assembly file name to generate.
_CompilerParameters.OutputAssembly = _AssemblyName;
// Generate an executable instead of a class library.
_CompilerParameters.GenerateExecutable = false;
_CompilerParameters.GenerateInMemory = false;
}
else
{
// Generate an executable instead of a class library.
_CompilerParameters.GenerateExecutable = false;
_CompilerParameters.GenerateInMemory = true;
}
// Generate debug information.
//_CompilerParameters.IncludeDebugInformation = true;
// Set the level at which the compiler
// should start displaying warnings.
_CompilerParameters.WarningLevel = 3;
// Set whether to treat all warnings as errors.
_CompilerParameters.TreatWarningsAsErrors = false;
// Set compiler argument to optimize output.
_CompilerParameters.CompilerOptions = "/optimize";
// Set a temporary files collection.
// The TempFileCollection stores the temporary files
// generated during a build in the current directory,
// and does not delete them after compilation.
_CompilerParameters.TempFiles = new System.CodeDom.Compiler.TempFileCollection(".", true);
if (_ResourceFiles != null && _ResourceFiles.Length > 0)
{
foreach (string _ResourceFile in _ResourceFiles)
{
// Set the embedded resource file of the assembly.
_CompilerParameters.EmbeddedResources.Add(_ResourceFile);
}
}
try
{
// Invoke compilation
System.CodeDom.Compiler.CompilerResults _CompilerResults = null;
if (_SourceFile != null && System.IO.File.Exists(_SourceFile))
{
// soruce code in external file
_CompilerResults = _CodeCompiler.CompileAssemblyFromFile(_CompilerParameters, _SourceFile);
}
else
{
// source code pass as a string
_CompilerResults = _CodeCompiler.CompileAssemblyFromSource(_CompilerParameters, _SourceCode);
}
if (_CompilerResults.Errors.Count > 0)
{
// Return compilation errors
_Errors = "";
foreach (System.CodeDom.Compiler.CompilerError CompErr in _CompilerResults.Errors)
{
_Errors += "Line number " + CompErr.Line +
", Error Number: " + CompErr.ErrorNumber +
", '" + CompErr.ErrorText + ";\r\n\r\n";
}
// Return the results of compilation - Failed
return(false);
}
else
{
// no compile errors
_Errors = null;
}
}
catch (Exception _Exception)
{
// Error occurred when trying to compile the code
_Errors = _Exception.Message;
return(false);
}
// Return the results of compilation - Success
return(true);
}
private void btnCompileRun_Click(object sender, EventArgs e)
{
string code = null;
code += "using System;\r\n";
code += "using TextIndex;\r\n";
code += "using System.Collections;\r\n";
code += "using System.Data;\r\n";
code += "public class TestParser : SiteParser{ ";
code += " public override string Parse(HtmlDocument document) { ";
code += " " + textCode.Text;
code += " } ";
code += "}";
// CodeDOM'dan C# compiler'ı elde edelim
Microsoft.CSharp.CSharpCodeProvider cp = new Microsoft.CSharp.CSharpCodeProvider();
System.CodeDom.Compiler.ICodeCompiler ic = cp.CreateCompiler();
// compiler parametrelerini ayarlayalım
System.CodeDom.Compiler.CompilerParameters cpar = new System.CodeDom.Compiler.CompilerParameters();
cpar.GenerateInMemory = true;
cpar.GenerateExecutable = false;
cpar.ReferencedAssemblies.Add("system.dll");
cpar.ReferencedAssemblies.Add("System.Drawing.dll");
cpar.ReferencedAssemblies.Add("System.Windows.Forms.dll");
cpar.ReferencedAssemblies.Add("System.Data.dll");
cpar.ReferencedAssemblies.Add(Application.ExecutablePath);
// kodu derletim ve sonuçları alalım
System.CodeDom.Compiler.CompilerResults cr = ic.CompileAssemblyFromSource(cpar, code);
// eğer derleme hatası varsa bu hataları bir bir gösterelim.
foreach (System.CodeDom.Compiler.CompilerError ce in cr.Errors)
{
// hata mesajı, hatanın oluştuğu satır, önceki üç satır ve sonraki üç satırı içeren
// bir hata mesajı hazırlayalım.
string[] srcArr = code.Split('\n');
string errMessage = ce.ErrorText + " at line " + (ce.Line - 1) + "\n\n";
for (int i = ce.Line - 3; i < ce.Line + 3; i++)
{
if (i < 0 || i >= srcArr.Length)
{
continue;
}
errMessage += i + " " + srcArr[i] + "\n";
}
// hatayı gösterelim
MessageBox.Show(errMessage);
return;
}
// kod hatasız derlendiyse test işlemlerine başlayalım.
if (cr.Errors.Count == 0 && cr.CompiledAssembly != null)
{
// test edilecek iki koda (sınıfa) ait tipleri elde edelim.
Type type = cr.CompiledAssembly.GetType("TestParser");
try
{
SiteParser parser = (SiteParser)Activator.CreateInstance(type);
string result = parser.Parse(document);
textBox2.Text = result;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
}
public static System.CodeDom.Compiler.CompilerResults CompileCode(string codeStr, EngineNS.ECSType csType, Guid dllId, string absCodeFile = "", string dllOutputFile = "", bool debug = false)
{
System.CodeDom.Compiler.CodeDomProvider cdProvider = new CodeGenerateSystem.CSharpCodeProvider();
System.CodeDom.Compiler.CompilerParameters compilerParam = new System.CodeDom.Compiler.CompilerParameters();
compilerParam.GenerateExecutable = false;
compilerParam.GenerateInMemory = false;
compilerParam.ReferencedAssemblies.Add("System.dll");
switch (csType)
{
case EngineNS.ECSType.Client:
compilerParam.ReferencedAssemblies.Add(EngineNS.CEngine.Instance.FileManager.Bin + "/ClientCommon.dll");
compilerParam.ReferencedAssemblies.Add(EngineNS.CEngine.Instance.FileManager.Bin + "/Client.dll");
break;
//case EngineNS.ECSType.Server:
// compilerParam.ReferencedAssemblies.Add(EngineNS.CEngine.Instance.FileManager.Root + CSUtility.Support.IFileConfig.Server_Directory + "/ServerCommon.dll");
// compilerParam.ReferencedAssemblies.Add(EngineNS.CEngine.Instance.FileManager.Root + CSUtility.Support.IFileConfig.Server_Directory + "/Server.dll");
// break;
}
if (!string.IsNullOrEmpty(dllOutputFile))
{
compilerParam.OutputAssembly = dllOutputFile;
}
System.CodeDom.Compiler.CompilerResults compilerResult = null;
if (debug == true)
{
compilerParam.IncludeDebugInformation = true;
if (string.IsNullOrEmpty(absCodeFile))
{
absCodeFile = $"{EngineNS.CEngine.Instance.FileManager.ProjectSourceRoot}CodeFiles\\{dllId}_{csType.ToString()}.cs";
}
var fileDir = EngineNS.CEngine.Instance.FileManager.GetPathFromFullName(absCodeFile);
if (!System.IO.Directory.Exists(fileDir))
{
System.IO.Directory.CreateDirectory(fileDir);
}
var fs = new System.IO.FileStream(absCodeFile, System.IO.FileMode.Create, System.IO.FileAccess.ReadWrite, System.IO.FileShare.ReadWrite);
fs.Write(System.Text.Encoding.Default.GetBytes(codeStr), 0, System.Text.Encoding.Default.GetByteCount(codeStr));
fs.Close();
absCodeFile = absCodeFile.Replace("/", "\\");
compilerResult = cdProvider.CompileAssemblyFromFile(compilerParam, new string[] { absCodeFile });
var purefileName = dllOutputFile.Substring(0, dllOutputFile.Length - 4);
var pdbFile = purefileName + ".pdb";
if (EngineNS.CEngine.Instance.FileManager.FileExists(pdbFile))
{
EngineNS.CEngine.Instance.FileManager.CopyFile(pdbFile, purefileName + ".vpdb", true);
EngineNS.CEngine.Instance.FileManager.DeleteFile(pdbFile);
}
}
else
{
compilerResult = cdProvider.CompileAssemblyFromSource(compilerParam, codeStr);
}
return(compilerResult);
}
public static int GetWebServiceDataWSDL(string url, string funcName, string className, Object[] parameters, ref Object retItem)
{
try
{
string @namespace = "KFBIO.Webservice.WSDL";
System.Net.WebClient client = new System.Net.WebClient();
//String classname;
//String url = System.Configuration.ConfigurationManager.ConnectionStrings["serviceAddress"].ConnectionString;//这个地址可以写在Config文件里面，这里取出来就行了.在原地址后面加上： ?WSDL
//String url = "http://192.168.4.4:8090/yfy-client/services/Msg_Service";
//String param = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><NOTICEMSG><MSGCONTENT><APPLICATION><INP_ID></INP_ID><INP_VISIT_TYPE_CD>1</INP_VISIT_TYPE_CD><NAME></NAME><GENDER_CD>2</GENDER_CD><BIRTHDATE> </BIRTHDATE><ID_NO></ID_NO><PATI_PHONE> </PATI_PHONE><PROVINCE_NAME> </PROVINCE_NAME><CITY_NAME> </CITY_NAME><AREA_NAME> </AREA_NAME><STREET_ID> </STREET_ID><VILLAGE_NAME> </VILLAGE_NAME><HOUSE_NO> </HOUSE_NO><APPLY_REASON>2</APPLY_REASON><CONSULT_AIM>远程诊断</CONSULT_AIM><ILLNESS_DIAG> </ILLNESS_DIAG><CONSULT_ORG_CODE> </CONSULT_ORG_CODE><CONSULT_ORG_NAME> </CONSULT_ORG_NAME></APPLICATION><EXAMSET><REPORT_NO> </REPORT_NO><REPORT_DATE> </REPORT_DATE><TEST_DEPT_NAME>病理科</TEST_DEPT_NAME><REPORT_DOC_NAME>牛爱芳</REPORT_DOC_NAME><ITEM_CD>00213564</ITEM_CD><ITEM_NAME>病理诊断</ITEM_NAME><CLINICDESC>送检目的</CLINICDESC><EXAMFINDING>检查所见</EXAMFINDING><EXAMCONCLUSION>检查结论</EXAMCONCLUSION><FTP_USER>FTP</FTP_USER><FTP_PASSWORD>1234</FTP_PASSWORD><FTP_FILEPATH> FTP文件完整路径</FTP_FILEPATH></EXAMSET></MSGCONTENT><CREATETIME>产生日期时间</CREATETIME></NOTICEMSG>";
//classname = "Msg_Service";
url = url + "?wsdl";
Stream stream = client.OpenRead(url);
ServiceDescription description = ServiceDescription.Read(stream);
ServiceDescriptionImporter importer = new ServiceDescriptionImporter(); //创建客户端代理代理类。
importer.ProtocolName = "Soap"; //指定访问协议。
importer.Style = ServiceDescriptionImportStyle.Client; //生成客户端代理。
importer.CodeGenerationOptions = CodeGenerationOptions.GenerateProperties | CodeGenerationOptions.GenerateNewAsync;
importer.AddServiceDescription(description, null, null); //添加WSDL文档。
CodeNamespace nmspace = new CodeNamespace(); //命名空间
nmspace.Name = @namespace;
System.CodeDom.CodeCompileUnit unit = new System.CodeDom.CodeCompileUnit();
unit.Namespaces.Add(nmspace);
System.Web.Services.Description.ServiceDescriptionImportWarnings warning = importer.Import(nmspace, unit);
System.CodeDom.Compiler.CodeDomProvider provider = System.CodeDom.Compiler.CodeDomProvider.CreateProvider("CSharp");
System.CodeDom.Compiler.CompilerParameters parameter = new System.CodeDom.Compiler.CompilerParameters();
parameter.GenerateExecutable = false;
if (!Directory.Exists(System.Web.HttpContext.Current.Server.MapPath("Temp")))
{
Directory.CreateDirectory(System.Web.HttpContext.Current.Server.MapPath("Temp"));
}
parameter.OutputAssembly = System.Web.HttpContext.Current.Server.MapPath("Temp/") + "TempClass.dll"; //"D:/TempClass.dll";//输出程序集的名称
parameter.ReferencedAssemblies.Add("System.dll");
parameter.ReferencedAssemblies.Add("System.XML.dll");
parameter.ReferencedAssemblies.Add("System.Web.Services.dll");
parameter.ReferencedAssemblies.Add("System.Data.dll");
System.CodeDom.Compiler.CompilerResults result = provider.CompileAssemblyFromDom(parameter, unit);
if (result.Errors.HasErrors)
{
// 显示编译错误信息
//临时模板编译错误，内部错误
string a = System.Web.HttpContext.Current.Server.MapPath("Temp/") + "TempClass.dll";
if (!File.Exists(System.Web.HttpContext.Current.Server.MapPath("Temp/") + "TempClass.dll"))
{
return(-5);
}
}
System.Reflection.Assembly asm = System.Reflection.Assembly.LoadFrom(System.Web.HttpContext.Current.Server.MapPath("Temp/") + "TempClass.dll");//加载前面生成的程序集
//Type t = asm.GetType(nameSpace + "." + className);
Type t = asm.GetType(@namespace + "." + className);
object o = Activator.CreateInstance(t);
System.Reflection.MethodInfo method = t.GetMethod(funcName);//CONSULTAPPLYNOTICE_PATHOLOGY是服务端的方法名称,你想调用服务端的什么方法都可以在这里改,最好封装一下
retItem = method.Invoke(o, parameters);
}
catch (WebException ex)
{
//网络异常异常
return(-1);
}
catch (Exception ex)
{
//未知错误
return(-99);
}
return(0);
}
/**/
/// <summary>
/// 動態呼叫Web Service
/// </summary>
/// <param name="pUrl">WebService的http形式的位址，EX:http://www.yahoo.com/Service/Service.asmx </param>
/// <param name="pNamespace">欲呼叫的WebService的namespace</param>
/// <param name="pClassname">欲呼叫的WebService的class name</param>
/// <param name="pMethodname">欲呼叫的WebService的method name</param>
/// <param name="pArgs">參數列表，請將每個參數分別放入object[]中</param>
/// <returns>WebService的執行結果</returns>
/// <remarks>
/// 如果呼叫失敗，將會拋出Exception。請呼叫的時候，適當截獲異常。
/// 目前知道有兩個地方可能會發生異常：
/// 1、動態構造WebService的時候，CompileAssembly失敗。
/// 2、WebService本身執行失敗。
/// </remarks>
public object InvokeWebservice(string pUrl, string @pNamespace, string pClassname, string pMethodname, object[] pArgs)
{
WebClient tWebClient = new WebClient();
//讀取WSDL檔，確認Web Service描述內容
Stream tStream = tWebClient.OpenRead(pUrl + "?WSDL");
ServiceDescription tServiceDesp = ServiceDescription.Read(tStream);
//將讀取到的WSDL檔描述import近來
ServiceDescriptionImporter tServiceDespImport = new ServiceDescriptionImporter();
tServiceDespImport.AddServiceDescription(tServiceDesp, "", "");
CodeNamespace tCodeNamespace = new CodeNamespace(@pNamespace);
//指定要編譯程式
CodeCompileUnit tCodeComUnit = new CodeCompileUnit();
tCodeComUnit.Namespaces.Add(tCodeNamespace);
tServiceDespImport.Import(tCodeNamespace, tCodeComUnit);
//以C#的Compiler來進行編譯
CSharpCodeProvider tCSProvider = new CSharpCodeProvider();
ICodeCompiler tCodeCom = tCSProvider.CreateCompiler();
//設定編譯參數
System.CodeDom.Compiler.CompilerParameters tComPara = new
System.CodeDom.Compiler.CompilerParameters();
tComPara.GenerateExecutable = false;
tComPara.GenerateInMemory = true;
//取得編譯結果
System.CodeDom.Compiler.CompilerResults tComResult =
tCodeCom.CompileAssemblyFromDom(tComPara, tCodeComUnit);
//如果編譯有錯誤的話，將錯誤訊息丟出
if (true == tComResult.Errors.HasErrors)
{
System.Text.StringBuilder tStr = new System.Text.StringBuilder();
foreach (System.CodeDom.Compiler.CompilerError tComError in tComResult.Errors)
{
tStr.Append(tComError.ToString());
tStr.Append(System.Environment.NewLine);
}
throw new Exception(tStr.ToString());
}
//取得編譯後產出的Assembly
System.Reflection.Assembly tAssembly = tComResult.CompiledAssembly;
Type tType = tAssembly.GetType(@pNamespace + "." + pClassname, true, true);
object tTypeInstance = Activator.CreateInstance(tType);
//若WS有overload的話，需明確指定參數內容
Type[] tArgsType = null;
if (pArgs == null)
{
tArgsType = new Type[0];
}
else
{
int tArgsLength = pArgs.Length;
tArgsType = new Type[tArgsLength];
for (int i = 0; i < tArgsLength; i++)
{
tArgsType[i] = pArgs[i].GetType();
}
}
//若沒有overload的話，第二個參數便不需要，這邊要注意的是WsiProfiles.BasicProfile1_1本身不支援Web Service overload，因此需要改成不遵守WsiProfiles.BasicProfile1_1協議
System.Reflection.MethodInfo tInvokeMethod = tType.GetMethod(pMethodname, tArgsType);
//實際invoke該method
return(tInvokeMethod.Invoke(tTypeInstance, pArgs));
}
private void Compile(bool file)
{
System.CodeDom.Compiler.CodeDomProvider CodeDomProvider = System.CodeDom.Compiler.CodeDomProvider.CreateProvider("CSharp");
System.CodeDom.Compiler.CompilerParameters CompilerParameters = new System.CodeDom.Compiler.CompilerParameters();
CompilerParameters.ReferencedAssemblies.Add("System.dll");
CompilerParameters.ReferencedAssemblies.Add("System.Data.dll");
CompilerParameters.ReferencedAssemblies.Add("System.Xml.dll");
CompilerParameters.ReferencedAssemblies.Add("System.Linq.dll");
CompilerParameters.ReferencedAssemblies.Add("RakNetSwig.dll");
CompilerParameters.ReferencedAssemblies.Add("GMP_Server.exe");
foreach (String str in Program.serverOptions.AdditionalLibs)
{
CompilerParameters.ReferencedAssemblies.Add(str);
}
CompilerParameters.CompilerOptions = "/t:library";///debug:full
for (int i = 0; i < Program.serverOptions.AdditionalSymbols.Count; i++)
{
String str = Program.serverOptions.AdditionalSymbols[i];
if (i == 0)
{
CompilerParameters.CompilerOptions += "/define: ";
}
CompilerParameters.CompilerOptions += str;
if (i != Program.serverOptions.AdditionalLibs.Count - 1)
{
CompilerParameters.CompilerOptions += ";";
}
}
CompilerParameters.IncludeDebugInformation = true;
if (!file)
{
CompilerParameters.GenerateInMemory = true;
}
else
{
CompilerParameters.GenerateInMemory = false;
CompilerParameters.OutputAssembly = "scripts/_compiled/ServerScripts.dll";
}
List <String> fileList = new List <string>();
GetFileList(fileList, "scripts/server");
//getFileList(fileList, "scripts/both");
System.CodeDom.Compiler.CompilerResults CompilerResults = CodeDomProvider.CompileAssemblyFromFile(CompilerParameters, fileList.ToArray());
if (CompilerResults.Errors.Count > 0)
{
foreach (CompilerError col in CompilerResults.Errors)
{
Log.Logger.log(Log.Logger.LOG_ERROR, col.FileName + ":" + col.Line + " \t" + col.ErrorText);
}
return;
}
m_Assembly = CompilerResults.CompiledAssembly;
}
// 创建Assembly
// parameters:
// strCode: 脚本代码
// refs: 连接的外部assembly
// strResult:处理信息
// objDb:数据库对象，在出错调getErrorInfo用到
// 返回值:创建好的Assembly
public static Assembly CreateAssembly(string strCode,
string[] refs,
string strLibPaths,
string strOutputFile,
out string strErrorInfo,
out string strWarningInfo)
{
// System.Reflection.Assembly compiledAssembly = null;
strErrorInfo = "";
strWarningInfo = "";
// 2019/4/15
if (refs != null &&
Array.IndexOf(refs, "netstandard.dll") == -1)
{
List <string> temp = new List <string>(refs);
temp.Add("netstandard.dll");
refs = temp.ToArray();
}
// CompilerParameters对象
System.CodeDom.Compiler.CompilerParameters compilerParams;
compilerParams = new CompilerParameters();
compilerParams.GenerateInMemory = true; //Assembly is created in memory
// compilerParams.IncludeDebugInformation = true;
if (strOutputFile != null && strOutputFile != "")
{
compilerParams.GenerateExecutable = false;
compilerParams.OutputAssembly = strOutputFile;
// compilerParams.CompilerOptions = "/t:library";
}
if (strLibPaths != null && strLibPaths != "") // bug
{
compilerParams.CompilerOptions = "/lib:" + strLibPaths;
}
compilerParams.TreatWarningsAsErrors = false;
compilerParams.WarningLevel = 4;
// 正规化路径，去除里面的宏字符串
// RemoveRefsBinDirMacro(ref refs);
compilerParams.ReferencedAssemblies.AddRange(refs);
CSharpCodeProvider provider;
// System.CodeDom.Compiler.ICodeCompiler compiler;
System.CodeDom.Compiler.CompilerResults results = null;
try
{
provider = new CSharpCodeProvider();
// compiler = provider.CreateCompiler();
results = provider.CompileAssemblyFromSource(
compilerParams,
strCode);
}
catch (Exception ex)
{
strErrorInfo = "出错 " + ex.Message;
return(null);
}
int nErrorCount = 0;
if (results.Errors.Count != 0)
{
string strErrorString = "";
nErrorCount = getErrorInfo(results.Errors,
out strErrorString);
strErrorInfo = "信息条数:" + Convert.ToString(results.Errors.Count) + "\r\n";
strErrorInfo += strErrorString;
if (nErrorCount == 0 && results.Errors.Count != 0)
{
strWarningInfo = strErrorInfo;
strErrorInfo = "";
}
}
if (nErrorCount != 0)
{
return(null);
}
return(results.CompiledAssembly);
}
/// <summary>
/// Gets the result from the original exception.
/// </summary>
/// <param name="results">The result from the initial exception.</param>
public FormatterCompileException(System.CodeDom.Compiler.CompilerResults results)
: base("A compile exception has occured during creation of the formatter assembly")
{
Results = results;
}
