public static void Main ()
{
CompilerParameters options = new CompilerParameters ();
options.WarningLevel = 4;
CodeDomProvider provider = new CSharpCodeProvider ();
#if NET_2_0
CompilerResults result = provider.CompileAssemblyFromDom (
options, new CodeSnippetCompileUnit (src));
#else
ICodeCompiler compiler = provider.CreateCompiler ();
CompilerResults result = compiler.CompileAssemblyFromDom (
options, new CodeSnippetCompileUnit (src));
#endif
Assert.IsFalse (result.Errors.HasErrors, "#1");
#if ONLY_1_0
Assert.IsFalse (result.Errors.HasWarnings, "#2");
Assert.AreEqual (0, result.Errors.Count, "#3");
#else
Assert.IsTrue (result.Errors.HasWarnings, "#2");
#if MONO
Assert.AreEqual (2, result.Errors.Count, "#3");
Assert.AreEqual ("CS0108", result.Errors [0].ErrorNumber, "#4");
Assert.IsTrue (result.Errors [0].IsWarning, "#5");
Assert.AreEqual ("CS0169", result.Errors [1].ErrorNumber, "#6");
Assert.IsTrue (result.Errors [1].IsWarning, "#7");
#else
Assert.AreEqual (1, result.Errors.Count, "#3");
Assert.AreEqual ("CS0108", result.Errors [0].ErrorNumber, "#4");
Assert.IsTrue (result.Errors [0].IsWarning, "#5");
#endif
#endif
}
public static Assembly Compile(CodeCompileUnit code)
{
var codeProvider = new CSharpCodeProvider();
var parameters = new CompilerParameters();
parameters.GenerateInMemory = true;
parameters.ReferencedAssemblies.Add(typeof(Razor).Assembly.Location);
parameters.ReferencedAssemblies.Add("System.dll");
parameters.ReferencedAssemblies.Add("System.Core.dll");
CompilerResults results = codeProvider.CompileAssemblyFromDom(parameters, code);
if (results.Errors.HasErrors)
{
CompilerError error = results.Errors
.OfType <CompilerError>()
.Where(e => !e.IsWarning)
.First();
string s = string.Format("Error Compiling Template: ({0}, {1}) {2}",
error.Line, error.Column, error.ErrorText);
throw new Exception(s);
}
return(results.CompiledAssembly);
}
/// <summary>
/// 动态调用web服务
/// </summary>
/// <param name="url">WSDL服务地址</param>
/// <param name="classname">服务接口类名</param>
/// <param name="methodname">方法名</param>
/// <param name="args">参数值</param>
/// <returns></returns>
public static object InvokeWebService(string url, string classname, string methodname, object[] args)
{
string @namespace = "EnterpriseServerBase.WebService.DynamicWebCalling";
if ((classname == null) || (classname == ""))
{
classname = WebServiceHelper.GetWsClassName(url);
}
try
{
//获取WSDL
WebClient wc = new WebClient();
Stream stream = wc.OpenRead(url + "?WSDL");
ServiceDescription sd = ServiceDescription.Read(stream);
//注意classname一定要赋值获取
classname = sd.Services[0].Name;
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 icc = new CSharpCodeProvider();
//设定编译参数
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 = icc.CompileAssemblyFromDom(cplist, ccu);
if (true == cr.Errors.HasErrors)
{
System.Text.StringBuilder sb = new System.Text.StringBuilder();
foreach (System.CodeDom.Compiler.CompilerError ce in cr.Errors)
{
sb.Append(ce.ToString());
sb.Append(System.Environment.NewLine);
}
throw new Exception(sb.ToString());
}
//生成代理实例，并调用方法
System.Reflection.Assembly assembly = cr.CompiledAssembly;
Type t = assembly.GetType(@namespace + "." + classname, true, true);
object obj = Activator.CreateInstance(t);
System.Reflection.MethodInfo mi = t.GetMethod(methodname);
return(mi.Invoke(obj, args));
}
catch (Exception ex)
{
throw new Exception(ex.Message, new Exception(ex.StackTrace));
}
}
private Assembly CompileCSharpCode(CodeCompileUnit source)
{
var provider = new CSharpCodeProvider();
var cp = new CompilerParameters();
cp.ReferencedAssemblies.Add("System.dll");
cp.GenerateExecutable = false;
cp.GenerateInMemory = true;
// Compile the code DOM
var cr = provider.CompileAssemblyFromDom(cp, source);
if (cr.Errors.Count <= 0)
{
return(cr.CompiledAssembly);
}
var message = new StringBuilder();
foreach (CompilerError err in cr.Errors)
{
message.AppendLine(err.ErrorText);
}
throw new Exception($"Compilation had {cr.Errors.Count} errors: {message}");
}
public static Assembly GenerateAssembly(Generator GenerateClassCode, out String errors)
{
CSharpCodeProvider csp = new CSharpCodeProvider();
CompilerParameters cp = new CompilerParameters();
foreach (var item in GenerateClassCode.References)
{
cp.ReferencedAssemblies.Add(item);
}
cp.WarningLevel = 3;
cp.IncludeDebugInformation = false;
cp.CompilerOptions = "/target:library /optimize";
cp.GenerateExecutable = false;
cp.GenerateInMemory = true;
CompilerResults results = csp.CompileAssemblyFromDom(cp, GenerateClassCode.CodeCompileUnit);
if (results.Errors.HasErrors)
{
string errorMessage = "";
errorMessage = results.Errors.Count.ToString() + " Errors:";
for (int x = 0; x < results.Errors.Count; x++)
{
errorMessage = errorMessage + "\r\nLine: " +
results.Errors[x].Line.ToString() + " - " + results.Errors[x].ErrorText;
}
errors = errorMessage;
}
else
{
errors = null;
}
return(results.CompiledAssembly);
}
/// <summary>
/// Compiles an assembly from a CodeDOM CodeCompileUnit
/// </summary>
public static CompilerResults CompileCSharp(this CodeCompileUnit code, string outputPath)
{
var providerOptions = new Dictionary <string, string>();
if (Environment.Version.Major < 4)
{
providerOptions.Add("CompilerVersion", "v3.5");
}
var compiler = new CSharpCodeProvider(providerOptions);
CompilerResults results = compiler.CompileAssemblyFromDom(GetCompilerParameters(outputPath), code);
if (results.Errors.Count > 0)
{
// Display compilation errors.
var sb = new StringBuilder();
foreach (CompilerError ce in results.Errors)
{
sb.AppendLine(ce.ToString());
}
throw new CompileException(sb.ToString(), results.Errors);
}
return(results);
}
public static object InvokeWebService(string url, string classname, string methodname, object[] args)
{
var @namespace = "iPem.Core.WebService";
if (string.IsNullOrWhiteSpace(classname))
{
classname = GetWsClassName(url);
}
try {
if (!url.EndsWith("wsdl", StringComparison.CurrentCultureIgnoreCase))
{
url = string.Format("{0}?{1}", url, "wsdl");
}
//获取wsdl
var wc = new WebClient();
var stream = wc.OpenRead(url);
var sd = ServiceDescription.Read(stream);
var sdi = new ServiceDescriptionImporter();
sdi.AddServiceDescription(sd, "", "");
var cn = new CodeNamespace(@namespace);
var ccu = new CodeCompileUnit();
ccu.Namespaces.Add(cn);
sdi.Import(cn, ccu);
//设定编译参数
var 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");
//编译代理类
var icc = new CSharpCodeProvider();
var cr = icc.CompileAssemblyFromDom(cplist, ccu);
if (true == cr.Errors.HasErrors)
{
var sb = new System.Text.StringBuilder();
foreach (CompilerError ce in cr.Errors)
{
sb.AppendLine(ce.ToString());
}
throw new Exception(sb.ToString());
}
//生成代理实例，并调用方法
var assembly = cr.CompiledAssembly;
var t = assembly.GetType(@namespace + "." + classname, true, true);
var obj = Activator.CreateInstance(t);
var mi = t.GetMethod(methodname);
return(mi.Invoke(obj, args));
} catch (Exception ex) {
throw new Exception(ex.InnerException.Message, new Exception(ex.InnerException.StackTrace));
}
}
/// <summary>
/// 实例化WebServices
/// </summary>
/// <param name="url">WebServices地址</param>
/// <param name="methodname">调用的方法</param>
/// <param name="args">把webservices里需要的参数按顺序放到这个object[]里</param>
public static object InvokeWebService(string url, string methodname, object[] args)
{
//这里的namespace是需引用的webservices的命名空间，我没有改过，也可以使用。也可以加一个参数从外面传进来。
//string @namespace = "client";
string @namespace = assemblyName;
try
{
//获取WSDL
WebClient wc = new WebClient();
Stream stream = wc.OpenRead(url + "?WSDL");
ServiceDescription sd = ServiceDescription.Read(stream);
string classname = sd.Services[0].Name;
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();
//ICodeCompiler icc = csc.CreateCompiler();
//设定编译参数
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 = 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));
}
catch (Exception ex)
{
throw ex.InnerException;//throw ex.InnerException; 看到的是原始异常
//return null;
}
}
private static Type CreateFor(Type t, Dictionary <string, List <string> > influences)
{
var provider = new CSharpCodeProvider();
CompilerParameters cp = new CompilerParameters();
cp.GenerateInMemory = true;
CodeCompileUnit cu = new CodeCompileUnit();
AddAllAssemblyAsReference(cu);
cu.Namespaces.Add(CreateNamespace(t, influences));
#if DEBUG
StringWriter sw = new StringWriter();
provider.GenerateCodeFromCompileUnit(cu, sw, new CodeGeneratorOptions()
{
BracingStyle = "C"
});
Trace.WriteLine(sw.GetStringBuilder());
#endif
CompilerResults cr = provider.CompileAssemblyFromDom(cp, cu);
if (cr.Errors.Count > 0)
{
ThrowErrors(cr.Errors);
}
return(cr.CompiledAssembly.GetTypes()[0]);
}
public bool GetAeeembly(out Assembly assembly)
{
assembly = null;
var compiler = new CSharpCodeProvider();
var comPara = new CompilerParameters();
comPara.GenerateExecutable = false;
comPara.GenerateInMemory = true;
comPara.OutputAssembly = "";
var assemblies = AppDomain.CurrentDomain
.GetAssemblies()
.Where(a => !a.IsDynamic)
.Select(a => a.Location);
comPara.ReferencedAssemblies.AddRange(assemblies.ToArray());
comPara.OutputAssembly = "Assembly-CSharp";
var result = compiler.CompileAssemblyFromDom(comPara, m_codeUnit);
//var result = compiler.CompileAssemblyFromFile(comPara, m_sourceFileName);
if (result.Errors.HasErrors)
{
foreach (var error in result.Errors)
{
Debug.LogError(error.ToString());
}
return(false);
}
assembly = result.CompiledAssembly;
return(true);
}
private void CompileAssembly(bool inMemory)
{
CompilerParameters compilerParams = new CompilerParameters();
compilerParams.GenerateInMemory = inMemory;
compilerParams.GenerateExecutable = true;
compilerParams.OutputAssembly = inMemory ? null : this.OutputExePath;
compilerParams.ReferencedAssemblies.Add("System.dll");
compilerParams.ReferencedAssemblies.Add("Microsoft.CSharp.dll");
compilerParams.ReferencedAssemblies.Add("System.Core.dll");
compilerParams.ReferencedAssemblies.AddRange(this.ReferencedDlls.ToArray());
//compilerParams.TempFiles = new TempFileCollection(DefaultOutputDir, true);
//compilerParams.CompilerOptions = "/optimize-";
CSharpCodeProvider provider = new CSharpCodeProvider();
CompilerResults results = provider.CompileAssemblyFromDom(compilerParams, this.CompileUnit);
if (results.Errors.Count != 0)
{
throw this.ResultErrorsToException(results.Errors);
}
this.Assembly = results.CompiledAssembly;
}
private static Assembly MakeAssembly(Action <CodeCompileUnit> contentGenerator)
{
var provider = new CSharpCodeProvider();
CompilerParameters cp = new CompilerParameters();
cp.GenerateInMemory = true;
CodeCompileUnit cu = new CodeCompileUnit();
contentGenerator(cu);
#if DEBUG
StringWriter sw = new StringWriter();
provider.GenerateCodeFromCompileUnit(cu, sw, new CodeGeneratorOptions()
{
BracingStyle = "C"
});
var s = sw.GetStringBuilder().ToString();
Trace.WriteLine(s);
#endif
CompilerResults cr = provider.CompileAssemblyFromDom(cp, cu);
if (cr.Errors.Count > 0)
{
ThrowErrors(cr.Errors);
}
return(cr.CompiledAssembly);
}
// Generate code for a particular provider and compile it
static void GenerateCode(CodeCompileUnit ccu)
{
CompilerParameters cp = new CompilerParameters();
String sourceFile;
CompilerResults cr;
// Generate Code from Compile Unit using CSharp code provider
//
CSharpCodeProvider csharpcodeprovider = new CSharpCodeProvider();
if (csharpcodeprovider.FileExtension[0] == '.')
{
sourceFile = "CSharpSample" + csharpcodeprovider.FileExtension;
}
else
{
sourceFile = "CSharpSample." + csharpcodeprovider.FileExtension;
}
IndentedTextWriter tw1 = new IndentedTextWriter(new StreamWriter(sourceFile, false), " ");
csharpcodeprovider.GenerateCodeFromCompileUnit(ccu, tw1, new CodeGeneratorOptions());
tw1.Close();
cp.GenerateExecutable = true;
cp.OutputAssembly = "CSharpSample.exe";
cp.GenerateInMemory = false;
cr = csharpcodeprovider.CompileAssemblyFromDom(cp, ccu);
return;
}
private static CompilerResults GenerateAssembly(CodeGen schema)
{
var compileUnit = schema.GenerateCode();
var comparam = new CompilerParameters(new string[] { "mscorlib.dll" });
comparam.ReferencedAssemblies.Add("System.dll");
comparam.ReferencedAssemblies.Add("System.Core.dll");
comparam.ReferencedAssemblies.Add(Type.GetType("Mono.Runtime") != null ? "Mono.CSharp.dll" : "Microsoft.CSharp.dll");
comparam.ReferencedAssemblies.Add("Avro.dll");
comparam.GenerateInMemory = true;
var ccp = new CSharpCodeProvider();
var units = new[] { compileUnit };
var compres = ccp.CompileAssemblyFromDom(comparam, units);
if (compres.Errors.Count > 0)
{
for (int i = 0; i < compres.Errors.Count; i++)
{
Console.WriteLine(compres.Errors[i]);
}
}
Assert.AreEqual(0, compres.Errors.Count);
return(compres);
}
internal static TemplateCompilationResult Compile(Type templateType, string templateBody, IEnumerable <string> namespaces, string tempDirectory)
{
LoadRuntimeBinder();
string className;
var compileUnit = GetCodeCompileUnit(templateType, namespaces, templateBody, out className);
string sourceCode;
var codeProvider = new CSharpCodeProvider();
var builder = new StringBuilder();
using (var writer = new StringWriter(builder, CultureInfo.InvariantCulture))
{
codeProvider.GenerateCodeFromCompileUnit(compileUnit, writer, new CodeGeneratorOptions());
sourceCode = builder.ToString();
}
var parameters = CreateComplilerParameters(tempDirectory);
var compileResult = codeProvider.CompileAssemblyFromDom(parameters, compileUnit);
if (compileResult.Errors != null && compileResult.Errors.Count > 0)
{
throw new TemplateCompilationException(compileResult.Errors, sourceCode, templateBody);
}
var fullClassName = TEMPLATES_NAMESPACE + "." + className;
return(new TemplateCompilationResult
{
Type = compileResult.CompiledAssembly.GetType(fullClassName),
SourceCode = sourceCode
});
}
static void Main(string[] args)
{
CSharpCodeProvider provider = new CSharpCodeProvider();
CompilerParameters parameters = new CompilerParameters();
parameters.GenerateExecutable = false;
parameters.GenerateInMemory = false;
parameters.ReferencedAssemblies.Add("netstandard.dll");
parameters.ReferencedAssemblies.Add("System.Composition.AttributedModel.dll");
parameters.ReferencedAssemblies.Add("MEFdlls.dll");
parameters.OutputAssembly = "C:/temp/NewMEF.dll";
CodeCompileUnit compileUnit = BuildNewMefGraph();
string sourceFile = "NewMEF." + provider.FileExtension;
using (StreamWriter sw = new StreamWriter(sourceFile, false))
{
IndentedTextWriter tw = new IndentedTextWriter(sw, " ");
provider.GenerateCodeFromCompileUnit(compileUnit, tw,
new CodeGeneratorOptions());
tw.Close();
}
CompilerResults results = provider.CompileAssemblyFromDom(parameters, compileUnit);
var s = results.PathToAssembly;
}
/// <summary>
/// Compiles temporary assembly.
/// </summary>
/// <param name="codeNamespace">Namespace to include in the assembly.</param>
/// <param name="referencedAssemblies">Assemblies referenced by the assembly being compiled.</param>
/// <returns>Compiled assembly.</returns>
public static Assembly Create(CodeNamespace codeNamespace, Assembly[] referencedAssemblies)
{
var codeProvider = new CSharpCodeProvider();
var compileUnit = new CodeCompileUnit();
compileUnit.Namespaces.Add(codeNamespace);
var compilerParameters = new CompilerParameters
{
GenerateExecutable = false,
GenerateInMemory = true,
#if DEBUG
IncludeDebugInformation = true,
#endif
};
foreach (var assemblyLocation in GetReferencedAssemblies(referencedAssemblies))
{
compilerParameters.ReferencedAssemblies.Add(assemblyLocation);
compileUnit.ReferencedAssemblies.Add(assemblyLocation);
}
#if DEBUG
string sourcePath = Path.GetTempFileName() + ".cs";
using (var writer = new StreamWriter(sourcePath))
{
codeProvider.GenerateCodeFromNamespace(codeNamespace, writer, null);
}
var compileResult = codeProvider.CompileAssemblyFromFile(compilerParameters, sourcePath);
File.Delete(sourcePath);
#else
var compileResult = codeProvider.CompileAssemblyFromDom(compilerParameters, compileUnit);
#endif
return(compileResult.CompiledAssembly);
}
private static void Compile(CodeCompileUnit compileUnit, string exeName)
{
// prepare for compilation
CodeDomProvider codeProvider = new CSharpCodeProvider();
CompilerParameters compilerParameters = new CompilerParameters
{
GenerateExecutable = true,
GenerateInMemory = false,
IncludeDebugInformation = true,
OutputAssembly = exeName
};
codeProvider.GenerateCodeFromCompileUnit(compileUnit, Console.Out, new CodeGeneratorOptions());
// compile!
CompilerResults result = codeProvider.CompileAssemblyFromDom(compilerParameters, compileUnit);
if (result.Errors.Count > 0)
{
throw new CompileException
{
Errors = result.Errors
};
}
// Get asssembly
Assembly assembly = result.CompiledAssembly;
}
public Assembly ToAssembly()
{
var errors = new List <string>();
Assembly generatedAssembly = null;
String[] assemblyNames =
{
"System.dll",
"System.Core.dll",
typeof(IArgs).Assembly.Location
};
CSharpCodeProvider provider = new CSharpCodeProvider();
CompilerParameters cp = new CompilerParameters(assemblyNames);
cp.GenerateExecutable = false;
cp.GenerateInMemory = true;
CompilerResults cr = provider.CompileAssemblyFromDom(cp, _unit);
foreach (CompilerError compilerError in cr.Errors)
{
if (!compilerError.IsWarning)
{
Errors.Add(compilerError + Environment.NewLine);
}
}
if (!Errors.Any())
{
generatedAssembly = cr.CompiledAssembly;
}
return(generatedAssembly);
}
private bool BuildWSDL(WebProperties WebProps, IntegrationLog Log)
{
try
{
Uri uri = new Uri(WebProps.Properties["WSDL"].ToString());
//byte[] byteArray = Encoding.ASCII.GetBytes(WebProps.Properties["WSDL"].ToString());
//MemoryStream stream = new MemoryStream(byteArray);
WebRequest webRequest = WebRequest.Create(uri);
System.IO.Stream stream = webRequest.GetResponse().GetResponseStream();
ServiceDescription sd = ServiceDescription.Read(stream);
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);
ServiceDescriptionImportWarnings warnings = servImport.Import(nameSpace, codeCompileUnit);
if (warnings == 0)
{
using (var stringWriter = new StringWriter(CultureInfo.CurrentCulture))
{
var prov = new CSharpCodeProvider();
prov.GenerateCodeFromNamespace(nameSpace, stringWriter, new CodeGeneratorOptions());
var assemblyReferences = new string[2] {
"System.Web.Services.dll", "System.Xml.dll"
};
var param = new CompilerParameters(assemblyReferences)
{
GenerateExecutable = false,
GenerateInMemory = true,
TreatWarningsAsErrors = false,
WarningLevel = 4,
};
var results = new CompilerResults(new TempFileCollection());
results = prov.CompileAssemblyFromDom(param, codeCompileUnit);
var assembly = results.CompiledAssembly;
service = assembly.GetType(sdName);
methodInfo = service.GetMethods();
}
}
return(true);
}
catch (Exception ex)
{
Log.LogMessage(ex.Message, IntegrationLogType.Error);
}
return(false);
}
public void Generate(string className, IDictionary <string, Type> props, string dllsPath)
{
var csc = new CSharpCodeProvider(new Dictionary <string, string>()
{
{ "CompilerVersion", "v4.0" }
});
var outputFile = $"{className}.dll";
var parameters = CreateParameters(dllsPath, outputFile);
var compileUnit = new CodeCompileUnit();
var ns = new CodeNamespace($"Models.{className}");
compileUnit.Namespaces.Add(ns);
ns.Imports.Add(new CodeNamespaceImport("System"));
var classType = new CodeTypeDeclaration(className);
classType.Attributes = MemberAttributes.Public;
ns.Types.Add(classType);
foreach (var prop in props)
{
AddProperty(prop, classType);
}
var results = csc.CompileAssemblyFromDom(parameters, compileUnit);
results.Errors.Cast <CompilerError>().ToList().ForEach(error => Console.WriteLine(error.ErrorText));
}
private static Assembly compile(CodeCompileUnit compileUnit)
{
var provider = new CSharpCodeProvider(new Dictionary <String, String> {
{ "CompilerVersion", "v4.0" }
});
var parameters = new CompilerParameters();
parameters.ReferencedAssemblies.Add("System.dll");
parameters.ReferencedAssemblies.Add("System.Runtime.Caching.dll");
parameters.ReferencedAssemblies.Add("CM.Caching.dll");
parameters.ReferencedAssemblies.Add(Assembly.GetAssembly(typeof(ClassCache)).ManifestModule.Name);
//parameters.OutputAssembly = $"{Assembly.GetAssembly(typeof(CacheCreatorTests)).ManifestModule.Name}";
parameters.GenerateInMemory = true;
parameters.TreatWarningsAsErrors = true;
parameters.CompilerOptions = "/optimize";
var compileResults = provider.CompileAssemblyFromDom(parameters, compileUnit);
foreach (CompilerError ce in compileResults.Errors)
{
Trace.TraceError("Error: {0}", ce.ToString());
}
if (compileResults.Errors.Count > 0)
{
return(null);
}
Trace.TraceInformation("Compile succesfull");
return(compileResults.CompiledAssembly);
}
public bool WriteAssembly()
{
var parameters = new CompilerParameters
{
//NOTE: we place this assembly in the output directory, the linker will move it to the final folder
OutputAssembly = Path.Combine(OutputDirectory, "Resource.designer.dll"),
};
parameters.ReferencedAssemblies.Add(XamarinAndroid.FindAssembly("System.dll"));
parameters.ReferencedAssemblies.Add(XamarinAndroid.FindAssembly("System.Runtime.dll"));
parameters.ReferencedAssemblies.Add(XamarinAndroid.FindAssembly("Java.Interop.dll"));
parameters.ReferencedAssemblies.Add(XamarinAndroid.FindAssembly("Mono.Android.dll"));
foreach (var assembly in Assemblies)
{
parameters.ReferencedAssemblies.Add(assembly.Location);
}
var results = csc.CompileAssemblyFromDom(parameters, unit);
if (results.Errors.HasErrors)
{
foreach (var error in results.Errors)
{
Diagnostics.Error("Error: {0}", error);
}
return(false);
}
return(true);
}
private static Type CompileView(GeneratorResults razorResult, CompilerParameters compilerParameters)
{
var codeProvider = new CSharpCodeProvider(CompilerProperties);
var result = codeProvider.CompileAssemblyFromDom(compilerParameters, razorResult.GeneratedCode);
if (result.Errors != null && result.Errors.HasErrors)
{
throw new RazorCompilerException(result.Errors.OfType <CompilerError>().Where(x => !x.IsWarning));
}
var assembly = Assembly.LoadFrom(compilerParameters.OutputAssembly);
if (assembly == null)
{
throw new RazorCompilerException("Unable to load view assembly.");
}
var type = assembly.GetType(SimpleRazorConfiguration.Namespace + "." + compilerParameters.MainClass);
if (type == null)
{
throw new RazorCompilerException("Unable to load view assembly.");
}
return(type);
}
private static void Compile(CodeGenerationBuilder builder)
{
var compilerParameters = new CompilerParameters
{
GenerateExecutable = false,
GenerateInMemory = false,
OutputAssembly = CompositeGeneratedAssemblyPath,
TempFiles = new TempFileCollection(TempAssemblyFolderPath)
};
compilerParameters.ReferencedAssemblies.AddRangeIfNotContained(builder.AssemblyLocations.ToArray());
compilerParameters.AddAssemblyLocationsFromBin();
var codeCompileUnit = new CodeCompileUnit();
codeCompileUnit.Namespaces.AddRange(builder.Namespaces.ToArray());
for (int i = 0; i < NumberOfCompileRetries; i++)
{
var compiler = new CSharpCodeProvider();
CompilerResults compileResult = compiler.CompileAssemblyFromDom(compilerParameters, codeCompileUnit);
if (compileResult.Errors.Count == 0)
{
return;
}
if (i == NumberOfCompileRetries - 1)
{
#if OUTPUT_SOURCE_CODE_ON_ERROR
using (FileStream file = File.Create(Path.Combine(PathUtil.BaseDirectory, "output.cs")))
{
using (var sw = new StreamWriter(file))
{
compiler.GenerateCodeFromCompileUnit(codeCompileUnit, sw, new CodeGeneratorOptions());
}
}
#endif
var sb = new StringBuilder();
foreach (CompilerError compilerError in compileResult.Errors)
{
if (compilerError.IsWarning)
{
continue;
}
string entry = "Compile error: " + compilerError.ErrorNumber + "(" + compilerError.Line + ")" + ": " + compilerError.ErrorText.Replace("{", "{{").Replace("}", "}}");
Log.LogError(LogTitle, entry);
sb.AppendLine(entry);
}
throw new InvalidOperationException(sb.ToString());
}
}
}
static Assembly CompilerAssembly(CodeCompileUnit cUnit)
{
CompilerParameters cParameters = new CompilerParameters();
cParameters.GenerateExecutable = false;
cParameters.GenerateInMemory = true;
cParameters.ReferencedAssemblies.Add("System.dll");
cParameters.ReferencedAssemblies.Add("System.XML.dll");
cParameters.ReferencedAssemblies.Add("System.Web.Services.dll");
cParameters.ReferencedAssemblies.Add("System.Data.dll");
cParameters.ReferencedAssemblies.Add("System.ServiceModel.Web.dll");
cParameters.OutputAssembly = @"D:\" + DateTime.Now.ToString("hh_mm_ss") + ".dll";
cParameters.CompilerOptions = "/platform:x86";
CSharpCodeProvider cSharpCodeProvider = new CSharpCodeProvider();
CompilerResults compilerResults = cSharpCodeProvider.CompileAssemblyFromDom(cParameters, cUnit);
if (compilerResults.Errors.HasErrors == true)
{
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());
}
//CreateCodeFile(cSharpCodeProvider, codeCompileUnit);
return(compilerResults.CompiledAssembly);
}
protected virtual Assembly GenerateAssembly(params KeyValuePair <string, string>[] templates)
{
var assemblyName = NamespaceName + "." + Guid.NewGuid().ToString("N") + ".dll";
var templateResults = templates.Select(pair => razorEngine.GenerateCode(new StringReader(pair.Value), pair.Key, NamespaceName, pair.Key + ".cs")).ToList();
if (templateResults.Any(result => result.ParserErrors.Any()))
{
var parseExceptionMessage = string.Join(Environment.NewLine + Environment.NewLine, templateResults.SelectMany(r => r.ParserErrors).Select(e => e.Location + ":" + Environment.NewLine + e.Message).ToArray());
throw new InvalidOperationException(parseExceptionMessage);
}
using (var codeProvider = new CSharpCodeProvider())
{
var compilerParameter = new CompilerParameters(referencedAssemblies, assemblyName, false)
{
GenerateInMemory = true,
CompilerOptions = "/optimize"
};
var compilerResults = codeProvider.CompileAssemblyFromDom(compilerParameter, templateResults.Select(r => r.GeneratedCode).ToArray());
if (compilerResults.Errors.HasErrors)
{
var compileExceptionMessage = string.Join(Environment.NewLine + Environment.NewLine, compilerResults.Errors.OfType <CompilerError>().Where(ce => !ce.IsWarning).Select(e => e.FileName + ":" + Environment.NewLine + e.ErrorText).ToArray());
throw new InvalidOperationException(compileExceptionMessage);
}
return(compilerResults.CompiledAssembly);
}
}
public WebServiceAgent(string url)
{
XmlTextReader reader = new XmlTextReader(url + "?wsdl");
//创建和格式化 WSDL 文档
ServiceDescription sd = ServiceDescription.Read(reader);
//创建客户端代理代理类
ServiceDescriptionImporter sdi = new ServiceDescriptionImporter();
sdi.AddServiceDescription(sd, null, null);
//sdi.Style = ServiceDescriptionImportStyle.Server;
//使用 CodeDom 编译客户端代理类
CodeNamespace cn = new CodeNamespace(CODE_NAMESPACE);
CodeCompileUnit ccu = new CodeCompileUnit();
ccu.Namespaces.Add(cn);
sdi.Import(cn, ccu);
CSharpCodeProvider icc = new CSharpCodeProvider();
CompilerParameters cp = new CompilerParameters(new string[] { "System.Data.dll" }); // 在此添加所缺的dll，比如"System.Data.dll"
CompilerResults cr = icc.CompileAssemblyFromDom(cp, ccu);
agentType = cr.CompiledAssembly.GetTypes()[0];
agent = Activator.CreateInstance(agentType);
}
/// <summary>
/// 根据映射的类名获取CDSSSystemData.GlobalData中成员数据
/// 返回值类型不定，由CDSSSystemData.GlobalData中成员数据类型决定
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public static object GetMapperValue(string strClassName)
{
CodeSnippetCompileUnit unit = ConstructAndCompileCode(strClassName);
ICodeCompiler compiler = new CSharpCodeProvider().CreateCompiler();
CompilerParameters para = new CompilerParameters();
para.ReferencedAssemblies.Add(CONST_IMPORT_SYSTEM_DLL);
para.ReferencedAssemblies.Add(CONST_IMPORT_CDSS_SYSTEM_DATA_DLL);
para.GenerateInMemory = true;
para.GenerateExecutable = false;
CompilerResults cr = compiler.CompileAssemblyFromDom(para, unit);
if (cr.Errors.Count > 0)
{
string str = "编译文件出错： " + cr.PathToAssembly + ": \r\n";
foreach (CompilerError ce in cr.Errors)
{
str = ce.ToString();
}
return(false);
}
else
{
Assembly asm = cr.CompiledAssembly;
Type type = asm.GetType(
CONST_GENERATECODE_NAMESPACE + "." + CONST_GENERATECODE_CLASSNAME);
MethodInfo mi = type.GetMethod(
CONST_GENERATECODE_METHODNAME_OBTAIN_SYSTEM_DATA, BindingFlags.Public | BindingFlags.Instance);
object obj = asm.CreateInstance(
CONST_GENERATECODE_NAMESPACE + "." + CONST_GENERATECODE_CLASSNAME);
return(mi.Invoke(obj, null));
}
}
/// <summary>
/// Compiles the given code unit.
/// </summary>
/// <param name="codeUnit"></param>
/// <param name="referencedAssemblies"></param>
/// <returns></returns>
static Assembly Compile(
CodeCompileUnit codeUnit,
IEnumerable <string> referencedAssemblies)
{
if (codeUnit == null)
{
throw new ArgumentNullException(nameof(codeUnit));
}
if (referencedAssemblies == null)
{
throw new ArgumentNullException(nameof(referencedAssemblies));
}
// configure compiler and add additional references
var outputAssemblyName = Path.GetTempPath() + Guid.NewGuid().ToString("N") + ".dll";
var compilerParameters = new CompilerParameters(ToLocalPaths(referencedAssemblies).ToArray(), outputAssemblyName);
compilerParameters.GenerateInMemory = true;
#if DEBUG
compilerParameters.IncludeDebugInformation = true;
#endif
// begin compilation
var compilerResults = codeProvider.CompileAssemblyFromDom(compilerParameters, codeUnit);
if (compilerResults.Errors.Count > 0)
{
throw new CompilerErrorException(compilerResults.Errors,
codeProvider.GenerateCodeFromCompileUnit(codeUnit, new CodeGeneratorOptions()));
}
return(compilerResults.CompiledAssembly);
}
/// <summary>
/// 构造函数
/// </summary>
public WebServiceAgent(string url)
{
try
{
XmlTextReader reader = new XmlTextReader(url + "?wsdl");
//创建和格式化 WSDL 文档
ServiceDescription sd = ServiceDescription.Read(reader);
//创建客户端代理类
ServiceDescriptionImporter sdi = new ServiceDescriptionImporter();
sdi.AddServiceDescription(sd, null, null);
//使用 CodeDom 编译客户端代理类
CodeNamespace cn = new CodeNamespace(CODE_NAMESPACE);
CodeCompileUnit ccu = new CodeCompileUnit();
ccu.Namespaces.Add(cn);
sdi.Import(cn, ccu);
CSharpCodeProvider icc = new CSharpCodeProvider();
CompilerParameters cp = new CompilerParameters();
CompilerResults cr = icc.CompileAssemblyFromDom(cp, ccu);
//得到代理对象的类型
agentType = cr.CompiledAssembly.GetTypes()[0];
//通过反射创建一个远程代理实例
agent = Activator.CreateInstance(agentType);
}
catch (Exception ex)
{ throw ex; }
}
private static Type CreateFor(Type t, Dictionary<string, List<string>> influences)
{
var provider = new CSharpCodeProvider();
CompilerParameters cp = new CompilerParameters();
cp.GenerateInMemory = true;
CodeCompileUnit cu = new CodeCompileUnit();
AddAllAssemblyAsReference(cu);
cu.Namespaces.Add(CreateNamespace(t, influences));
#if DEBUG
StringWriter sw = new StringWriter();
provider.GenerateCodeFromCompileUnit(cu, sw, new CodeGeneratorOptions() { BracingStyle = "C" });
Trace.WriteLine(sw.GetStringBuilder());
#endif
CompilerResults cr = provider.CompileAssemblyFromDom(cp, cu);
if (cr.Errors.Count > 0)
{
ThrowErrors(cr.Errors);
}
return cr.CompiledAssembly.GetTypes()[0];
}
public static unsafe int Main(string[] args)
{
string baseDirectory = AppDomain.CurrentDomain.BaseDirectory;
string pluginDirectory;
if (baseDirectory.EndsWith("bin"))
{
// Windows
pluginDirectory = Path.GetFullPath(Path.Combine(baseDirectory, "..\\lib\\plugins"));
}
else
{
// *nix
pluginDirectory = Path.Combine(baseDirectory, "plugins");
}
List<string> codeFiles = new List<string>();
List<CodeCompileUnit> codeSnippets = new List<CodeCompileUnit>();
List<Assembly> references = new List<Assembly>();
List<string> imports = new List<string>();
StringBuilder compilerOptions = new StringBuilder();
bool codeOnly = false;
string codeFile = string.Empty;
string assemblyFile = "out.dll";
int warnLevel = 0;
string smokeLib = null;
string defaultNamespace = "Qyoto";
string globalClass = "Global";
string destination = string.Empty;
string docs = string.Empty;
List<Assembly> plugins = new List<Assembly>();
foreach (string arg in args)
{
if (arg == "-help" || arg == "--help" || arg == "-h")
{
PrintHelp();
return 0;
}
if (arg == "-verbose")
{
Debug.Listeners.Add(new ConsoleTraceListener(true));
continue;
}
if (arg == "-code-only")
{
codeOnly = true;
continue;
}
if (arg.StartsWith("-code-file:"))
{
codeFile = arg.Substring(11);
continue;
}
if (arg.StartsWith("-out:"))
{
assemblyFile = arg.Substring(5);
continue;
}
if (arg.StartsWith("-warn:"))
{
warnLevel = int.Parse(arg.Substring(6));
continue;
}
if (arg.StartsWith("-r:"))
{
references.Add(Assembly.LoadFrom(arg.Substring(3)));
continue;
}
if (arg.StartsWith("-reference:"))
{
references.Add(Assembly.LoadFrom(arg.Substring(11)));
continue;
}
if (arg.StartsWith("-global-class:"))
{
globalClass = arg.Substring(14);
continue;
}
if (arg.StartsWith("-namespace:"))
{
defaultNamespace = arg.Substring(11);
continue;
}
if (arg.StartsWith("-dest:"))
{
destination = arg.Substring("-dest:".Length);
continue;
}
if (arg.StartsWith("-import:"))
{
imports.AddRange(arg.Substring(8).Split(','));
continue;
}
if (arg.StartsWith("-docs:"))
{
docs = arg.Substring("-docs:".Length);
continue;
}
if (arg.StartsWith("-plugins:"))
{
foreach (string str in arg.Substring(9).Split(','))
{
Assembly a;
try
{
a = Assembly.LoadFrom(str);
}
catch (FileNotFoundException)
{
a = Assembly.LoadFrom(Path.Combine(pluginDirectory, str));
}
plugins.Add(a);
}
continue;
}
if (arg.StartsWith("-"))
{
compilerOptions.Append(" /");
compilerOptions.Append(arg.Substring(1));
continue;
}
if (smokeLib == null)
{
smokeLib = arg;
continue;
}
codeFiles.Add(arg);
FileStream fs = new FileStream(arg, FileMode.Open);
StreamReader sr = new StreamReader(fs);
codeSnippets.Add(new CodeSnippetCompileUnit(sr.ReadToEnd()));
sr.Close();
fs.Close();
}
if (!string.IsNullOrEmpty(docs))
{
compilerOptions.Append(" /doc:" + Path.ChangeExtension(Path.GetFileName(assemblyFile), ".xml"));
}
compilerOptions.Append(" -debug");
if (smokeLib == null)
{
PrintHelp();
return 1;
}
Smoke* smoke = InitSmoke(smokeLib);
if (smoke == (Smoke*) 0)
{
return SmokeLoadingFailure;
}
List<ICustomTranslator> customTranslators = (from plugin in plugins
from type in plugin.GetTypes()
from iface in type.GetInterfaces()
where iface == typeof(ICustomTranslator)
select (ICustomTranslator) Activator.CreateInstance(type)).ToList();
GeneratorData data = new GeneratorData(smoke, defaultNamespace, imports, references, destination, docs);
data.GlobalSpaceClassName = globalClass;
Translator translator = new Translator(data, customTranslators);
foreach (IHookProvider provider in from type in plugins.SelectMany(plugin => plugin.GetTypes())
where type.GetInterfaces().Any(iface => iface == typeof(IHookProvider))
select (IHookProvider) Activator.CreateInstance(type))
{
provider.Translator = translator;
provider.Data = data;
provider.RegisterHooks();
}
ClassesGenerator classgen = new ClassesGenerator(data, translator);
Console.Error.WriteLine("Generating CodeCompileUnit...");
classgen.Run();
DestroySmoke((IntPtr) smoke);
Dictionary<string, string> providerOptions = new Dictionary<string, string>();
providerOptions.Add("CompilerVersion", "v4.0");
CodeDomProvider csharp = new CSharpCodeProvider(providerOptions);
if (codeFile != string.Empty)
{
FileStream fs = new FileStream(codeFile, FileMode.Create);
StreamWriter sw = new StreamWriter(fs);
Console.Error.WriteLine("Generating code...");
CodeGeneratorOptions cgo = new CodeGeneratorOptions();
csharp.GenerateCodeFromCompileUnit(data.CompileUnit, sw, cgo);
sw.Close();
fs.Close();
codeFiles.Add(codeFile);
}
if (codeOnly)
{
if (codeFile == string.Empty)
{
Console.Error.WriteLine("Missing output filename. Use the -code-file:<file> option.");
return MissingOptionError;
}
return NoError;
}
codeSnippets.Add(data.CompileUnit);
Console.Error.WriteLine("Compiling assembly...");
CompilerParameters cp = new CompilerParameters();
cp.GenerateExecutable = false;
cp.TreatWarningsAsErrors = false;
cp.OutputAssembly = assemblyFile;
cp.GenerateInMemory = false;
cp.WarningLevel = warnLevel;
cp.CompilerOptions = compilerOptions.ToString();
cp.ReferencedAssemblies.Add(typeof(Regex).Assembly.Location);
cp.ReferencedAssemblies.Add(typeof(ExtensionAttribute).Assembly.Location);
foreach (Assembly assembly in references)
{
cp.ReferencedAssemblies.Add(assembly.Location);
}
CompilerResults cr;
if(codeFile == null)
{
cr = csharp.CompileAssemblyFromDom(cp, codeSnippets.ToArray());
}
else
{
cr = csharp.CompileAssemblyFromFile(cp, codeFiles.ToArray());
}
bool errorsOccured = false;
foreach (CompilerError error in cr.Errors)
{
if (!error.IsWarning)
errorsOccured = true;
Console.Error.WriteLine(error);
}
if (errorsOccured)
{
Console.Error.WriteLine("Errors occured. No assembly was generated.");
return CompilationError;
}
Console.Error.WriteLine("Done.");
return NoError;
}