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;
}
public ICompiledTemplate GetTemplateFactory(Stream template)
{
var engine = CreateEngine();
GeneratorResults results;
using (var reader = new StreamReader(template))
{
results = engine.GenerateCode(reader);
}
var outputAssemblyName = string.Format("Generated_{0}.dll", Guid.NewGuid().ToString("N"));
var codeProvider = new CSharpCodeProvider();
var thisAssembly = typeof(TemplateBase).Assembly.Location;
codeProvider.CompileAssemblyFromDom(
new CompilerParameters(new[] {thisAssembly}, outputAssemblyName),
results.GeneratedCode);
var newAssembly = Assembly.LoadFrom(outputAssemblyName);
var type = newAssembly.GetType("RazorOutput.Template");
var factory = CreateFactory(type);
return new CompiledTemplate(factory);
}
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>
/// This method Parses and compiles the source code into an Assembly and returns it
/// </summary>
/// <param name="baseClassType">The Type of the Base class the generated class descends from</param>
/// <param name="namespaceOfGeneratedClass">The Namespace of the generated class</param>
/// <param name="generatedClassName">The Class Name of the generated class</param>
/// <param name="sourceCodeReader">A Text reader that is a warpper around the "Template" that is to be parsed and compiled</param>
/// <returns>An instance of a generated assembly that contains the generated class</returns>
public Assembly ParseAndCompileTemplate(Type baseClassType, string namespaceOfGeneratedClass, string generatedClassName, TextReader sourceCodeReader)
{
RazorTemplateEngine engine = InitializeRazorEngine(baseClassType, namespaceOfGeneratedClass, generatedClassName);
GeneratorResults razorResults = engine.GenerateCode(sourceCodeReader);
CSharpCodeProvider codeProvider = new CSharpCodeProvider();
CodeGeneratorOptions options = new CodeGeneratorOptions();
string generatedCode = null;
using (StringWriter writer = new StringWriter())
{
codeProvider.GenerateCodeFromCompileUnit(razorResults.GeneratedCode, writer, options);
generatedCode = writer.GetStringBuilder().ToString();
}
var outputAssemblyName = Path.GetTempPath() + Guid.NewGuid().ToString("N") + ".dll";
CompilerParameters compilerParameters = new CompilerParameters(new string[]{}, outputAssemblyName);
compilerParameters.ReferencedAssemblies.Add("System.dll");
compilerParameters.ReferencedAssemblies.Add("System.Core.dll");
compilerParameters.ReferencedAssemblies.Add(Assembly.GetExecutingAssembly().CodeBase.Substring(8));
compilerParameters.GenerateInMemory = false;
CompilerResults compilerResults = codeProvider.CompileAssemblyFromDom(compilerParameters, razorResults.GeneratedCode);
if (compilerResults.Errors.Count > 0)
{
var compileErrors = new StringBuilder();
foreach (System.CodeDom.Compiler.CompilerError compileError in compilerResults.Errors)
compileErrors.Append(String.Format("Line: {0}\t Col: {1}\t Error: {2}\r\n", compileError.Line, compileError.Column, compileError.ErrorText));
throw new Exception(compileErrors.ToString() + generatedCode);
}
return compilerResults.CompiledAssembly;
}
/// <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;
}
}
public Assembly ToAssembly()
{
var errors = new List<string>();
Assembly generatedAssembly = null;
String[] assemblyNames = {
"System.dll",
"System.Core.dll",
"System.Xml.dll",
typeof(FileTable<>).Assembly.Location,
typeof(HtmlNode).Assembly.Location
};
CSharpCodeProvider provider = new CSharpCodeProvider();
CompilerParameters cp = new CompilerParameters(assemblyNames);
cp.GenerateExecutable = false;
//cp.OutputAssembly = "test";
cp.GenerateInMemory = true;
CompilerResults cr = provider.CompileAssemblyFromDom(cp, _units);
foreach (CompilerError compilerError in cr.Errors)
{
if(!compilerError.IsWarning)
Errors.Add(compilerError + Environment.NewLine);
}
if (!Errors.Any())
generatedAssembly = cr.CompiledAssembly;
return generatedAssembly;
}
static Assembly compileToAssembly(CodeCompileUnit compileUnit)
{
var provider = new CSharpCodeProvider();
var baseAssembly = typeof(RazorHtmlTemplate<>).Assembly;
// todo: autodetect @using header lines and add them.
var parameters = new CompilerParameters(
// path does not work
// csharp.dll is for the use of dynamic
new[] { baseAssembly.Location, "System.Core.dll", "Microsoft.CSharp.dll"},
string.Empty,
false);
dumpGeneratedCode(compileUnit, provider);
var compRes = provider.CompileAssemblyFromDom(parameters, new[] { compileUnit });
if (compRes.Output.Count != 0)
{
#if DEBUG
Log.D("Compilation results:");
foreach (var str in compRes.Output)
Log.D(str);
#endif
if (compRes.Errors.Count != 0)
throw new Exception(compRes.Errors[0].ToString());
}
var assembly = compRes.CompiledAssembly;
return assembly;
}
/// <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>
/// 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;
}
}
/// <summary>
///
/// </summary>
/// <param name="url"></param>
public SIC_WebServiceAgent(string url)
{
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);
Microsoft.CSharp.CSharpCodeProvider icc = new Microsoft.CSharp.CSharpCodeProvider();
CompilerParameters cp = new CompilerParameters();
CompilerResults cr = icc.CompileAssemblyFromDom(cp, ccu);
agentType = cr.CompiledAssembly.GetTypes()[0];
Agent = Activator.CreateInstance(agentType);
}
static void Main(string[] args)
{
// Output some program information using Console.WriteLine.
Console.WriteLine("This program compiles a CodeDOM program that incorrectly declares multiple data");
Console.WriteLine("types to demonstrate handling compiler errors programmatically.");
Console.WriteLine("");
// Compile the CodeCompileUnit retrieved from the GetCompileUnit() method.
CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider();
// Initialize a CompilerParameters with the options for compilation.
string[] assemblies = new String[] { "System.dll" };
CompilerParameters options = new CompilerParameters(assemblies, "output.exe");
// Compile the CodeDOM graph and store the results in a CompilerResults.
CompilerResults results = provider.CompileAssemblyFromDom(options, GetCompileUnit());
// Compilation produces errors. Print out each error.
Console.WriteLine("Listing errors from compilation: ");
Console.WriteLine("");
for (int i = 0; i < results.Errors.Count; i++)
{
Console.WriteLine(results.Errors[i].ToString());
}
}
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
};
}
private static Assembly Compile(CodeCompileUnit codeCompileUnit)
{
var compilerParameters = new CompilerParameters();
compilerParameters.GenerateInMemory = true;
compilerParameters.ReferencedAssemblies.Add("System.dll");
compilerParameters.ReferencedAssemblies.Add("System.Core.dll");
compilerParameters.ReferencedAssemblies.Add("Microsoft.CSharp.dll");
compilerParameters.ReferencedAssemblies.Add(Assembly.GetExecutingAssembly().CodeBase.Substring(8));
var codeProvider = new CSharpCodeProvider();
var result = codeProvider.CompileAssemblyFromDom(compilerParameters, codeCompileUnit);
if (result.Errors.HasErrors)
{
foreach (var error in result.Errors)
{
Console.WriteLine(error);
}
return null;
}
return result.CompiledAssembly;
}
private object CompileAndCreateTest(string fileName, Feature feature)
{
string className = Path.GetFileNameWithoutExtension(fileName);
const string targetNamespace = "Target.Namespace";
// the row test generation has to be set to false, because our verifications support the old style test generation only
SpecFlowUnitTestConverter converter = new SpecFlowUnitTestConverter(CreateUnitTestGeneratorProvider(), new CodeDomHelper(CodeDomProviderLanguage.CSharp), new GeneratorConfiguration { AllowRowTests = false, AllowDebugGeneratedFiles = true });
var codeNamespace = converter.GenerateUnitTestFixture(feature, className, targetNamespace);
var compileUnit = new CodeCompileUnit();
compileUnit.Namespaces.Add(codeNamespace);
Dictionary<string, string> providerOptions = new Dictionary<string, string>();
providerOptions["CompilerVersion"] = "v3.5";
CSharpCodeProvider codeProvider = new CSharpCodeProvider(providerOptions);
CompilerParameters compilerParameters = new CompilerParameters();
compilerParameters.GenerateInMemory = true;
compilerParameters.TempFiles.KeepFiles = true;
compilerParameters.ReferencedAssemblies.Add(
TestFileHelper.GetAssemblyPath(typeof (GeneratedCodeAttribute))); //System
compilerParameters.ReferencedAssemblies.Add(
TestFileHelper.GetAssemblyPath(typeof (TestAttribute))); //NUnit
compilerParameters.ReferencedAssemblies.Add(
TestFileHelper.GetAssemblyPath(typeof (ITestRunner))); //TechTalk.SpecFlow
var results = codeProvider.CompileAssemblyFromDom(compilerParameters, compileUnit);
if (results.NativeCompilerReturnValue != 0)
throw new InvalidOperationException("Test cannot be compiled: " +
string.Join(Environment.NewLine, results.Errors.Cast<CompilerError>().Select(ce => ce.ToString()).ToArray()));
Type testType = results.CompiledAssembly.GetType(targetNamespace + "." + className, true);
return Activator.CreateInstance(testType);
}
/// <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";
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)
{
return ex.Message;
}
}
public virtual List<ExplorerItem> BuildAssembly(IConnectionInfo cxInfo, AssemblyName assemblyToBuild, ref string nameSpace, ref string typeName)
{
var unit = new CodeCompileUnit();
var namespace2 = new CodeNamespace(nameSpace);
namespace2.Imports.Add(new CodeNamespaceImport("System"));
namespace2.Imports.Add(new CodeNamespaceImport("System.Linq"));
namespace2.Imports.Add(new CodeNamespaceImport("Sitecore.ContentSearch"));
namespace2.Imports.Add(new CodeNamespaceImport("Sitecore.ContentSearch.SearchTypes"));
var settings = new SitecoreConnectionSettings();
var mapper = new DriverDataCxSettingsMapper();
mapper.Read(cxInfo, settings);
var selectedType = settings.SearchResultType.GetSelectedType();
namespace2.Imports.Add(new CodeNamespaceImport(selectedType.Namespace));
var declaration = new CodeTypeDeclaration(typeName)
{
IsClass = true,
TypeAttributes = TypeAttributes.Public
};
namespace2.Types.Add(declaration);
unit.Namespaces.Add(namespace2);
var constructor = new CodeConstructor
{
Attributes = MemberAttributes.Public
};
this.AddConstructorCode(constructor, settings);
declaration.Members.Add(constructor);
var indexNames = this.GetIndexNames(cxInfo);
var list = new List<ExplorerItem>();
foreach (var str in indexNames)
{
this.AddIndexAsProperty(str, selectedType, declaration);
var item = new ExplorerItem(str, ExplorerItemKind.QueryableObject, ExplorerIcon.Table)
{
IsEnumerable = false
};
item.DragText = this.GetDragText(item, settings);
list.Add(item);
}
var provider = new CSharpCodeProvider();
var options = new CompilerParameters();
var assemblyFilesToReference = this.GetAssemblyFilesToReference(settings);
foreach (var str2 in assemblyFilesToReference)
{
options.ReferencedAssemblies.Add(str2);
}
options.GenerateInMemory = true;
options.OutputAssembly = assemblyToBuild.CodeBase;
var results = provider.CompileAssemblyFromDom(options, new CodeCompileUnit[] { unit });
if (results.Errors.Count > 0)
{
throw new Exception(string.Concat(new object[] { "Cannot compile typed context: ", results.Errors[0].ErrorText, " (line ", results.Errors[0].Line, ")" }));
}
return list;
}
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);
}
/// < 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 = WSHelper.GetWsClassName(url);
}
try
{ //获取WSDL
WebClient wc = new WebClient();
Stream stream = wc.OpenRead(url + "?WSDL");
ServiceDescription sd = ServiceDescription.Read(stream);
ServiceDescriptionImporter sdi = new ServiceDescriptionImporter();
sdi.AddServiceDescription(sd, "", "");
CodeNamespace cn = new CodeNamespace(@namespace);
//生成客户端代理类代码
CodeCompileUnit ccu = new CodeCompileUnit();
ccu.Namespaces.Add(cn);
sdi.Import(cn, ccu);
CSharpCodeProvider 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);
// PropertyInfo propertyInfo = type.GetProperty(propertyname);
//return propertyInfo.GetValue(obj, null);
}
catch (Exception ex)
{
throw new Exception(ex.InnerException.Message, new Exception(ex.InnerException.StackTrace));
}
}
public static Type GetWsProxyType(string wsUrl, string classname)
{
string name = "ESBasic.WebService.DynamicWebCalling";
if ((classname == null) || (classname == ""))
{
classname = GetWsClassName(wsUrl);
}
string key = wsUrl + "@" + classname;
if (WSProxyTypeDictionary.ContainsKey(key))
{
return WSProxyTypeDictionary[key];
}
WebClient client = new WebClient();
ServiceDescription serviceDescription = ServiceDescription.Read(client.OpenRead(wsUrl + "?WSDL"));
ServiceDescriptionImporter importer = new ServiceDescriptionImporter();
importer.AddServiceDescription(serviceDescription, "", "");
CodeNamespace namespace2 = new CodeNamespace(name);
CodeCompileUnit codeCompileUnit = new CodeCompileUnit();
codeCompileUnit.Namespaces.Add(namespace2);
importer.Import(namespace2, codeCompileUnit);
ICodeCompiler compiler = new CSharpCodeProvider().CreateCompiler();
CompilerParameters options = new CompilerParameters
{
GenerateExecutable = false,
GenerateInMemory = true
};
options.ReferencedAssemblies.Add("System.dll");
options.ReferencedAssemblies.Add("System.XML.dll");
options.ReferencedAssemblies.Add("System.Web.Services.dll");
options.ReferencedAssemblies.Add("System.Data.dll");
CompilerResults results = compiler.CompileAssemblyFromDom(options, codeCompileUnit);
if (results.Errors.HasErrors)
{
StringBuilder builder = new StringBuilder();
foreach (CompilerError error in results.Errors)
{
builder.Append(error.ToString());
builder.Append(Environment.NewLine);
}
throw new Exception(builder.ToString());
}
Assembly compiledAssembly = results.CompiledAssembly;
compiledAssembly.GetTypes();
Type type2 = compiledAssembly.GetType(name + "." + classname, true, true);
lock (WSProxyTypeDictionary)
{
if (!WSProxyTypeDictionary.ContainsKey(key))
{
WSProxyTypeDictionary.Add(key, type2);
}
}
return type2;
}
public object CreateProxy(Type interfaceType, IReadOnlyDictionary<string, object> properties)
{
Guard.NotNull("interfaceType", interfaceType);
Guard.NotNull("properties", properties);
var typeDeclaration = new CodeTypeDeclaration(GetProxyClassName(interfaceType))
{
BaseTypes = { new CodeTypeReference(interfaceType) }
};
var proxyAssembly = new CodeCompileUnit
{
Namespaces =
{
new CodeNamespace(proxyNamespace)
{
Types = { typeDeclaration }
}
}
};
proxyAssembly.ReferencedAssemblies.Add(interfaceType.Assembly.Location);
proxyAssembly.ReferencedAssemblies.AddRange(
interfaceType.GetInterfaces().Select(i => i.Assembly.Location).ToArray());
foreach (var property in GetInterfaceProperties(interfaceType))
{
object value;
if (!properties.TryGetValue(property.Name, out value))
value = GetDefaultValue(property.PropertyType);
typeDeclaration.Members.Add(new CodeMemberProperty()
{
Attributes = MemberAttributes.Public | MemberAttributes.Final,
Name = property.Name,
HasGet = true,
GetStatements =
{
new CodeMethodReturnStatement(GetValueExpression(value))
},
Type = new CodeTypeReference(property.PropertyType)
});
}
using (var codeProvider = new CSharpCodeProvider())
{
return Activator.CreateInstance(
codeProvider
.CompileAssemblyFromDom(new CompilerParameters { GenerateInMemory = true }, proxyAssembly)
.CompiledAssembly
.GetType(proxyNamespace + "." + typeDeclaration.Name));
}
}
/// <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));
}
private Assembly BuildGeneratedCode(CodeCompileUnit ccu, out CompilerErrorCollection errors)
{
CSharpCodeProvider codeProvider = new CSharpCodeProvider();
CompilerParameters parameters = new CompilerParameters();
parameters.ReferencedAssemblies.Add("System.dll");
parameters.ReferencedAssemblies.Add(_UrlsType.Assembly.FullName);
parameters.GenerateInMemory = true;
CompilerResults results = codeProvider.CompileAssemblyFromDom(parameters, ccu);
errors = results.Errors;
return results.CompiledAssembly;
}
public string Compute(string expression)
{
var source = "class Evaluator { public static string Evaluate() { return ("+expression+").ToString(); } }";
var compileUnit = new CodeSnippetCompileUnit(source);
var provider = new CSharpCodeProvider();
var parameters = new CompilerParameters();
var results = provider.CompileAssemblyFromDom(parameters, compileUnit);
var type = results.CompiledAssembly.GetType("Evaluator");
var method = type.GetMethod("Evaluate");
return (string) method.Invoke(null, null);
}
private string CompileCode(GeneratorResults razorResult)
{
var codeProvider = new CSharpCodeProvider();
string outputAssemblyName = String.Format("Temp_{0}.dll", Guid.NewGuid().ToString("N"));
codeProvider.CompileAssemblyFromDom(
new CompilerParameters(new[]
{
typeof (Form1).Assembly.CodeBase.Replace("file:///", "").Replace("/", "\\"),
"System.Core.dll",
"Microsoft.CSharp.dll"
}, outputAssemblyName),
razorResult.GeneratedCode);
return outputAssemblyName;
}
public WebServiceHelper(string Url, string classname)
{
if ((classname == null) || (classname == string.Empty))
{
this.classname = this.GetWsClassName(Url);
}
else
{
this.classname = classname;
}
try
{
Stream stream = new WebClient().OpenRead(Url + "?WSDL");
ServiceDescription serviceDescription = ServiceDescription.Read(stream);
ServiceDescriptionImporter importer = new ServiceDescriptionImporter();
importer.AddServiceDescription(serviceDescription, "", "");
CodeNamespace namespace2 = new CodeNamespace(this.@namespace);
stream.Close();
CodeCompileUnit codeCompileUnit = new CodeCompileUnit();
codeCompileUnit.Namespaces.Add(namespace2);
importer.Import(namespace2, codeCompileUnit);
ICodeCompiler compiler = new CSharpCodeProvider().CreateCompiler();
CompilerParameters options = new CompilerParameters();
options.GenerateExecutable = false;
options.GenerateInMemory = true;
options.ReferencedAssemblies.Add("System.dll");
options.ReferencedAssemblies.Add("System.XML.dll");
options.ReferencedAssemblies.Add("System.Web.Services.dll");
options.ReferencedAssemblies.Add("System.Data.dll");
CompilerResults results = compiler.CompileAssemblyFromDom(options, codeCompileUnit);
if (results.Errors.HasErrors)
{
StringBuilder builder = new StringBuilder();
foreach (CompilerError error in results.Errors)
{
builder.Append(error.ToString());
builder.Append(Environment.NewLine);
}
throw new Exception(builder.ToString());
}
this.assembly = results.CompiledAssembly;
}
catch (Exception exception)
{
throw new Exception(exception.InnerException.Message, new Exception(exception.InnerException.StackTrace));
}
}
public Assembly GenerateAssembly(Type serviceType)
{
var compileUnit = GenerateUnit(new GenerationOptions(serviceType));
string serviceTypeAssemblyName = serviceType.Assembly.ManifestModule.Name;
var options = new CompilerParameters(new[] { "ServiceStack.dll", "ServiceStack.ServiceInterface.dll", "ServiceStack.Interfaces.dll", serviceTypeAssemblyName });
var compiler = new CSharpCodeProvider();
var result = compiler.CompileAssemblyFromDom(options, compileUnit);
if (result.Errors.Count > 0)
{
throw new Exception("Failed to compile assembly :(");
}
return result.CompiledAssembly;
}
public static Assembly GenerateAssemblyFromTemplate(string template)
{
var host = new RazorEngineHost(new CSharpRazorCodeLanguage())
{
DefaultNamespace = "Federation.MailService",
DefaultBaseClass = typeof(MailMessageTemplate).FullName
};
var engine = new RazorTemplateEngine(host);
var generatedCode = engine.GenerateCode(new StringReader(template), "MailMessageRazorTemplate", "Federation.MailService", "MailMessageTemplate.cs");
var currentAssemblyLocation = typeof(MailMessageTemplate).Assembly.CodeBase.Replace("file:///", string.Empty).Replace("/", "\\");
var modelsAssemblyLocation = typeof(MailRecord).Assembly.CodeBase.Replace("file:///", string.Empty).Replace("/", "\\");
List<string> refer = new List<string>
{
"mscorlib.dll",
"system.dll",
"system.core.dll",
"microsoft.csharp.dll",
"system.configuration.dll",
"system.data.linq.dll",
"system.data.dll",
currentAssemblyLocation,
modelsAssemblyLocation
};
var codeProvider = new CSharpCodeProvider();
var compilerParameters = new CompilerParameters(refer.ToArray()) { GenerateInMemory = true, CompilerOptions = "/optimize" };
var compilerResults = codeProvider.CompileAssemblyFromDom(compilerParameters, generatedCode.GeneratedCode);
if (compilerResults.Errors.HasErrors)
{
var compileExceptionMessage = string.Join("\n", compilerResults.Errors.OfType<CompilerError>().Where(ce => !ce.IsWarning).Select(e => "ERROR in " + e.Line + ": " + e.ErrorText).ToArray());
throw new InvalidOperationException(compileExceptionMessage);
}
return compilerResults.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;
}
private static Type CreateFor(Type t)
{
var provider = new CSharpCodeProvider();
CompilerParameters cp = new CompilerParameters();
cp.GenerateInMemory = true;
CodeCompileUnit cu = new CodeCompileUnit();
AddAssemblyReference(cu, t);
cu.Namespaces.Add(CreateNamespace(t));
#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.GetTypes()[0];
}
/// <summary>
/// Compiles a type.
/// </summary>
public void Compile()
{
//compile to assembly
CodeBuilder builder = new CodeBuilder();
CodeCompileUnit compunit = builder.CreateCodeCompileUnit(this._nsdecl);
CodeDomProvider compiler = new CSharpCodeProvider();
CompilerParameters options = new CompilerParameters();
options.GenerateInMemory = true;
options.WarningLevel = 4;
options.TreatWarningsAsErrors = true;
options.IncludeDebugInformation = true;
options.ReferencedAssemblies.Add(@"C:\lib\Castle\bin\Castle.ActiveRecord.dll");
CompilerResults results = compiler.CompileAssemblyFromDom(options, compunit);
_isCompiled = results.Errors.Count == 0;
_compiled = results.CompiledAssembly;
if (results.Errors.Count > 0)
{
foreach(CompilerError error in results.Errors)
{
Console.WriteLine(error.ErrorText);
}
}
}
public void CanCreateActiveRecordClass()
{
NamespaceDeclaration nsdecl = new NamespaceDeclaration("My.Data").Imports("Castle.ActiveRecord");
ClassDeclaration cdecl = nsdecl.AddClass("Customer").IsAbstract().InheritsFrom("ActiveRecordBase", "My.Data.Customer");
//compile to assembly
CodeBuilder builder = new CodeBuilder();
CodeCompileUnit compunit = builder.CreateCodeCompileUnit(nsdecl);
CodeDomProvider compiler = new CSharpCodeProvider();
CompilerParameters options = new CompilerParameters();
options.GenerateInMemory = true;
options.WarningLevel = 4;
options.TreatWarningsAsErrors = true;
options.IncludeDebugInformation = true;
options.ReferencedAssemblies.Add(@"C:\lib\Castle\bin\Castle.ActiveRecord.dll");
CompilerResults results = compiler.CompileAssemblyFromDom(options, compunit);
foreach (CompilerError error in results.Errors)
{
Console.WriteLine(error.ErrorText);
}
Assembly compiled = results.CompiledAssembly;
//load assembly in it's own app domain
AppDomain testdomain = AppDomain.CreateDomain("testdomain");
testdomain.Load("System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
testdomain.Load(compiled.GetName());
//test the assembly
Type testtype = compiled.GetType("My.Data.Customer");
Assert.IsNotNull(testtype);
Assert.AreEqual("ActiveRecordBase`1", testtype.BaseType.Name);
Assert.AreEqual("Customer", testtype.BaseType.GetGenericArguments()[0].Name);
AppDomain.Unload(testdomain);
}
private string ExecuteInternal(GeneratorResults razorResults, string defaultnamespace, string defaultclassname, IDictionary<string, object> bulaqData)
{
using (var provider = new CSharpCodeProvider())
{
var compiler = new CompilerParameters();
compiler.ReferencedAssemblies.Add("System.dll");
compiler.ReferencedAssemblies.Add("System.Core.dll");
compiler.ReferencedAssemblies.Add("Microsoft.CSharp.dll");
compiler.ReferencedAssemblies.Add(AppDomain.CurrentDomain.BaseDirectory + "\\bin\\BulaqCMS.Models.dll");
compiler.ReferencedAssemblies.Add(Assembly.GetExecutingAssembly().Location);
compiler.GenerateInMemory = true;
var result = provider.CompileAssemblyFromDom(compiler, razorResults.GeneratedCode);
if (result.Errors.HasErrors)
{
var error = result.Errors.OfType<CompilerError>().Where(i => !i.IsWarning).FirstOrDefault();
if (error != null) throw new Exception(error.ErrorText); //抛出错误
}
BulaqTemplateForRazorBase temp = (BulaqTemplateForRazorBase)result.CompiledAssembly.CreateInstance(defaultnamespace + "." + defaultclassname);
//temp.Model = new { Title = "Abduwaris" };//Model;
temp.SetProperty(bulaqData);
//if (temp.Layout != null)
//{
// //有布局页
//}
try
{
temp.Execute();
}
catch (Exception ex)
{
throw new Exception("执行错误", ex);
}
return temp.Output.ToString();
}
}
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;
}
internal static Func<IDataRecord, object> CreateFactory(DbClassInfoCache target, FactoryHelperSettings settings)
{
var classCtorAttr =
target.Attributes.First(s => s.Attribute is AutoGenerateCtorAttribute).Attribute as
AutoGenerateCtorAttribute;
CodeNamespace importNameSpace;
importNameSpace = new CodeNamespace(target.Type.Namespace);
var cp = new CompilerParameters();
string superName;
var compiler = new CodeTypeDeclaration();
compiler.IsClass = true;
var generateFactory = target.Type.IsSealed || classCtorAttr.CtorGeneratorMode == CtorGeneratorMode.FactoryMethod;
CodeMemberMethod codeConstructor;
var codeName = target.Name.Split('.').Last();
if (generateFactory)
{
codeConstructor = GenerateFactory(target, settings, importNameSpace);
superName = codeName + "_Factory";
compiler.Attributes = MemberAttributes.Static;
}
else
{
compiler.BaseTypes.Add(target.Type);
codeConstructor = GenerateConstructor(target, settings, importNameSpace);
compiler.IsPartial = true;
superName = codeName + "_Super";
}
if (target.Constructors.Any(f => f.Arguments.Any()))
{
throw new TypeAccessException(string.Format("Target type '{0}' does not define an public parametherless constructor. POCO's!!!!", target.Name));
}
compiler.Attributes |= MemberAttributes.Public;
compiler.Name = superName;
compiler.Members.Add(codeConstructor);
cp.GenerateInMemory = true;
if (settings.FileCollisonDetection == CollisonDetectionMode.Pessimistic)
{
cp.OutputAssembly =
Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)
+ @"\"
+ Guid.NewGuid().ToString("N")
+ "_Poco.dll";
}
else
{
cp.OutputAssembly =
Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)
+ @"\" + target.Type.FullName
+ "_Poco.dll";
}
settings.TempFileData.Add(cp.OutputAssembly);
Assembly compiledAssembly;
ConstructorInfo[] constructorInfos = null;
TypeInfo targetType = null;
if (File.Exists(cp.OutputAssembly) && settings.FileCollisonDetection == CollisonDetectionMode.Optimistic)
{
var bufferAssam = Assembly.Load(cp.OutputAssembly);
targetType = target.Type.GetTypeInfo();
var type = bufferAssam.DefinedTypes.FirstOrDefault(s => s == targetType);
if (targetType != null)
constructorInfos = targetType.GetConstructors();
if(constructorInfos == null)
throw new Exception(string.Format("A dll with a matching name for type: {0} was found and the FileCollisonDetection is Optimistic but no matching Constuctors where found", type.Name));
}
if (constructorInfos == null)
{
var callingAssm = Assembly.GetEntryAssembly();
if (callingAssm == null)
{
//testing we are?
callingAssm = Assembly.GetExecutingAssembly();
}
if (settings.CreateDebugCode)
{
cp.TempFiles = new TempFileCollection(Path.GetDirectoryName(callingAssm.Location), true);
cp.GenerateInMemory = false;
cp.TempFiles.KeepFiles = true;
cp.IncludeDebugInformation = true;
}
//cp.GenerateExecutable = true;
cp.ReferencedAssemblies.Add(target.Type.Assembly.Location);
cp.ReferencedAssemblies.Add("System.dll");
cp.ReferencedAssemblies.Add("System.Core.dll");
cp.ReferencedAssemblies.Add("System.Data.dll");
cp.ReferencedAssemblies.Add("System.Xml.dll");
cp.ReferencedAssemblies.Add("System.Xml.Linq.dll");
cp.ReferencedAssemblies.Add(typeof(DbAccessLayer).Assembly.Location);
var compileUnit = new CodeCompileUnit();
foreach (var defaultNamespace in settings.DefaultNamespaces)
{
importNameSpace.Imports.Add(new CodeNamespaceImport(defaultNamespace));
}
foreach (var additionalNamespace in target.Attributes.Where(f => f.Attribute is AutoGenerateCtorNamespaceAttribute).Select(f => f.Attribute as AutoGenerateCtorNamespaceAttribute))
{
importNameSpace.Imports.Add(new CodeNamespaceImport(additionalNamespace.UsedNamespace));
}
if (classCtorAttr.FullSateliteImport)
{
foreach (var referencedAssembly in target.Type.Assembly.GetReferencedAssemblies())
{
cp.ReferencedAssemblies.Add(referencedAssembly.Name);
}
}
importNameSpace.Types.Add(compiler);
compileUnit.Namespaces.Add(importNameSpace);
var provider = new CSharpCodeProvider();
var compileAssemblyFromDom = provider.CompileAssemblyFromDom(cp, compileUnit);
if (compileAssemblyFromDom.Errors.Count > 0 && !settings.EnforceCreation)
{
var sb = new StringBuilder(string.Format("There are {0} errors due compilation.",
compileAssemblyFromDom.Errors.Count));
int errNr = 0;
foreach (CompilerError error in compileAssemblyFromDom.Errors)
{
sb.AppendLine(errNr++ + error.ErrorNumber + ":" + error.Column + "," + error.Line + " -> " + error.ErrorText);
}
var ex =
new InvalidDataException(sb.ToString());
ex.Data.Add("Object", compileAssemblyFromDom);
throw ex;
}
compiledAssembly = compileAssemblyFromDom.CompiledAssembly;
targetType = compiledAssembly.DefinedTypes.First();
constructorInfos = targetType.GetConstructors();
if (!constructorInfos.Any())
{
if (settings.EnforceCreation)
return null;
var ex =
new InvalidDataException(string.Format("There are was an unknown error due compilation. No CTOR was build"));
ex.Data.Add("Object", compileAssemblyFromDom);
foreach (CompilerError error in compileAssemblyFromDom.Errors)
{
ex.Data.Add(error.ErrorNumber, error);
}
throw ex;
}
}
var matchingCtor = constructorInfos.FirstOrDefault(s =>
{
var param = s.GetParameters();
if (generateFactory)
{
if (param.Length < 1)
return false;
if (param.First().ParameterType != typeof(IDataRecord))
return false;
}
return true;
});
var dm = new DynamicMethod("Create" + target.Name.Split('.')[0], target.Type, new[] { typeof(IDataRecord) }, target.Type, true);
var il = dm.GetILGenerator();
if (generateFactory)
{
il.Emit(OpCodes.Nop);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Call, targetType.GetMethod("Factory"));
il.Emit(OpCodes.Ret);
}
else
{
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Newobj, matchingCtor);
il.Emit(OpCodes.Ret);
}
if (!settings.CreateDebugCode)
foreach (string tempFile in cp.TempFiles)
{
if (!tempFile.EndsWith("dll") && !tempFile.EndsWith("pdb"))
File.Delete(tempFile);
}
var func = (Func<IDataRecord, object>)dm.CreateDelegate(typeof(Func<IDataRecord, object>));
return func;
}
public static void GenerateXObjects(
XmlSchemaSet set,
string csFileName,
string configFileName,
string assemblyName,
bool xmlSerializable,
bool nameMangler2)
{
LinqToXsdSettings configSettings = new LinqToXsdSettings(nameMangler2);
if (configFileName != null)
{
configSettings.Load(configFileName);
}
configSettings.EnableServiceReference = xmlSerializable;
XsdToTypesConverter xsdConverter = new XsdToTypesConverter(configSettings);
ClrMappingInfo mapping = xsdConverter.GenerateMapping(set);
CodeDomTypesGenerator codeGenerator = new CodeDomTypesGenerator(configSettings);
CodeCompileUnit ccu = new CodeCompileUnit();
foreach(var codeNs in codeGenerator.GenerateTypes(mapping))
{
ccu.Namespaces.Add(codeNs);
}
//Write to file
CSharpCodeProvider provider = new CSharpCodeProvider();
if (csFileName != string.Empty && csFileName != null)
{
using (var update =
new Update(csFileName, System.Text.Encoding.UTF8))
{
provider.GenerateCodeFromCompileUnit(
ccu, update.Writer, new CodeGeneratorOptions());
}
PrintMessage(csFileName);
}
if(assemblyName != string.Empty)
{
var options = new CompilerParameters()
{
OutputAssembly = assemblyName,
IncludeDebugInformation = true,
TreatWarningsAsErrors = true,
};
options.TempFiles.KeepFiles = true;
{
var r = options.ReferencedAssemblies;
r.Add("System.dll");
r.Add("System.Core.dll");
r.Add("System.Xml.dll");
r.Add("System.Xml.Linq.dll");
r.Add("Xml.Schema.Linq.dll");
}
var results = provider.CompileAssemblyFromDom(options, ccu);
if (results.Errors.Count > 0)
{
PrintErrorMessage("compilation error(s): ");
for (int i = 0; i < results.Errors.Count; i++)
{
PrintErrorMessage(results.Errors[i].ToString());
}
throw new Exception("compilation error(s)");
}
else
{
PrintMessage(
"Generated Assembly: " +
results.CompiledAssembly.ToString());
}
}
}
public static object GetDbInfo(System.Data.DataSet ds)
{
// Get a code provider object.
System.CodeDom.Compiler.CodeDomProvider cdp = new Microsoft.CSharp.CSharpCodeProvider();
// Create the namespace and import the default "System" namespace.
System.CodeDom.CodeNamespace nmspc = new System.CodeDom.CodeNamespace("DataExplorer");
nmspc.Imports.Add(new System.CodeDom.CodeNamespaceImport("System"));
nmspc.Imports.Add(new System.CodeDom.CodeNamespaceImport("System.ComponentModel"));
// Create a class object.
System.CodeDom.CodeTypeDeclaration clsDbInfo = new System.CodeDom.CodeTypeDeclaration("DbInfo");
clsDbInfo.IsClass = true;
nmspc.Types.Add(clsDbInfo);
// Add fields to the class for each value returned.
List <string> fldNms = new List <string>();
for (int i = 0; i < ds.Tables.Count; i++)
{
for (int j = 0; j < ds.Tables[i].Columns.Count; j++)
{
string fldNm = "_" + ds.Tables[i].Columns[j].ColumnName.ToLower();
if (!fldNms.Contains(fldNm))
{
System.CodeDom.CodeMemberField fld = new System.CodeDom.CodeMemberField(typeof(System.String), fldNm);
fld.Attributes = System.CodeDom.MemberAttributes.Public;
clsDbInfo.Members.Add(fld);
fldNms.Add(fldNm);
}
}
}
// Add properties for the class to access each field.
List <string> propNms = new List <string>();
for (int i = 0; i < ds.Tables.Count; i++)
{
for (int j = 0; j < ds.Tables[i].Columns.Count; j++)
{
string
fldNm = "_" + ds.Tables[i].Columns[j].ColumnName.ToLower(),
propNm = ds.Tables[i].Columns[j].ColumnName;
if (!propNms.Contains(propNm))
{
System.CodeDom.CodeMemberProperty prop = new System.CodeDom.CodeMemberProperty();
prop.Attributes = System.CodeDom.MemberAttributes.Public;
prop.Name = propNm;
prop.Type = new System.CodeDom.CodeTypeReference(typeof(System.String));
System.CodeDom.CodeVariableReferenceExpression retExp = new System.CodeDom.CodeVariableReferenceExpression(fldNm);
System.CodeDom.CodeMethodReturnStatement getReturn = new System.CodeDom.CodeMethodReturnStatement(retExp);
prop.GetStatements.Add(getReturn);
prop.HasGet = true;
prop.HasSet = false;
string catName = (ds.Tables[i].TableName.EndsWith("1")) ? "File Group" : "Database";
System.CodeDom.CodeAttributeDeclaration attrCat = new System.CodeDom.CodeAttributeDeclaration("Category", new System.CodeDom.CodeAttributeArgument(new System.CodeDom.CodePrimitiveExpression(catName)));
prop.CustomAttributes.Add(attrCat);
// Add the property to our class.
clsDbInfo.Members.Add(prop);
propNms.Add(propNm);
}
}
}
// Add a constructor to the class
System.CodeDom.CodeConstructor clsDbInfoConstr = new System.CodeDom.CodeConstructor();
clsDbInfoConstr.Attributes = System.CodeDom.MemberAttributes.Public;
clsDbInfo.Members.Add(clsDbInfoConstr);
// Create a CompileUnit for this new type.
System.CodeDom.CodeCompileUnit cu = new System.CodeDom.CodeCompileUnit();
cu.ReferencedAssemblies.Add("system.dll");
cu.Namespaces.Add(nmspc);
// Now, we're ready to generate some code!
#if DEBUG
// If we're running in DEBUG mode, I want to see the generated code.
using (System.IO.FileStream fs = new System.IO.FileStream("dbinfo.cs", System.IO.FileMode.Create, System.IO.FileAccess.Write))
using (System.IO.StreamWriter sr = new System.IO.StreamWriter(fs))
cdp.GenerateCodeFromCompileUnit(cu, sr, null);
#endif
System.CodeDom.Compiler.CompilerParameters cp = new System.CodeDom.Compiler.CompilerParameters();
cp.ReferencedAssemblies.Add("system.dll");
cp.GenerateExecutable = false;
cp.IncludeDebugInformation = false;
cp.GenerateInMemory = false;
//cp.OutputAssembly = _outputName;
System.CodeDom.Compiler.CompilerResults cr = cdp.CompileAssemblyFromDom(cp, cu);
if (!cr.Errors.HasErrors)
{
System.Reflection.Assembly asm = cr.CompiledAssembly;
object dbInfo = asm.CreateInstance("DataExplorer.DbInfo");
return(dbInfo);
}
else
{
return(null);
}
}
public static void TestSpecific(string str, object[] result)
{
Protocol protocol = Protocol.Parse(str);
var codegen = new CodeGen();
codegen.AddProtocol(protocol);
var compileUnit = codegen.GenerateCode();
// add a constructor to the main class using the passed assignment statements
CodeTypeDeclaration ctd = compileUnit.Namespaces[0].Types[(int)result[0]];
CodeConstructor constructor = new CodeConstructor();
constructor.Attributes = MemberAttributes.Public;
CodeSnippetExpression snippet = new CodeSnippetExpression((string)result[2]);
constructor.Statements.Add(snippet);
ctd.Members.Add(constructor);
// add a function to the main class to populate the data
// This has been moved from constructor, as it was causing some tests to pass that shouldn't when referencing a blank object on READ.
CodeMemberMethod method = new CodeMemberMethod();
method.Attributes = MemberAttributes.Public;
method.Name = "Populate";
CodeSnippetExpression snippet2 = new CodeSnippetExpression((string)result[3]);
method.Statements.Add(snippet2);
ctd.Members.Add(method);
// compile
var comparam = new CompilerParameters(new string[] { "mscorlib.dll" });
comparam.ReferencedAssemblies.Add("System.dll");
comparam.ReferencedAssemblies.Add("Avro.dll");
comparam.GenerateInMemory = true;
var ccp = new Microsoft.CSharp.CSharpCodeProvider();
var units = new CodeCompileUnit[] { compileUnit };
var compres = ccp.CompileAssemblyFromDom(comparam, units);
if (compres == null || compres.Errors.Count > 0)
{
for (int i = 0; i < compres.Errors.Count; i++)
{
Console.WriteLine(compres.Errors[i]);
}
}
if (null != compres)
{
Assert.IsTrue(compres.Errors.Count == 0);
}
// create record
ISpecificRecord rec = compres.CompiledAssembly.CreateInstance((string)result[1]) as ISpecificRecord;
// Call populate to put some data in it.
Type recType = rec.GetType();;
MethodInfo methodInfo = recType.GetMethod("Populate");
methodInfo.Invoke(rec, null);
var x1 = compres.CompiledAssembly.FullName;
Assert.IsFalse(rec == null);
// serialize
var stream = new MemoryStream();
var binEncoder = new BinaryEncoder(stream);
var writer = new SpecificDefaultWriter(rec.Schema);
writer.Write(rec.Schema, rec, binEncoder);
// deserialize
stream.Position = 0;
var decoder = new BinaryDecoder(stream);
var reader = new SpecificDefaultReader(rec.Schema, rec.Schema);
var rec2 = (ISpecificRecord)reader.Read(null, rec.Schema, rec.Schema, decoder);
Assert.IsFalse(rec2 == null);
}
public static void TestSpecific(string str, object[] result)
{
Protocol protocol = Protocol.Parse(str);
var codegen = new CodeGen();
codegen.AddProtocol(protocol);
var compileUnit = codegen.GenerateCode();
// add a constructor to the main class using the passed assignment statements
CodeTypeDeclaration ctd = compileUnit.Namespaces[0].Types[(int)result[0]];
CodeConstructor constructor = new CodeConstructor();
constructor.Attributes = MemberAttributes.Public;
CodeSnippetExpression snippet = new CodeSnippetExpression((string)result[2]);
constructor.Statements.Add(snippet);
ctd.Members.Add(constructor);
// compile
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 Microsoft.CSharp.CSharpCodeProvider();
var units = new CodeCompileUnit[] { compileUnit };
var compres = ccp.CompileAssemblyFromDom(comparam, units);
if (compres == null || compres.Errors.Count > 0)
{
for (int i = 0; i < compres.Errors.Count; i++)
{
Console.WriteLine(compres.Errors[i]);
}
}
if (null != compres)
{
Assert.IsTrue(compres.Errors.Count == 0);
}
// create record
ISpecificRecord rec = compres.CompiledAssembly.CreateInstance((string)result[1]) as ISpecificRecord;
Assert.IsFalse(rec == null);
// serialize
var stream = new MemoryStream();
var binEncoder = new BinaryEncoder(stream);
var writer = new SpecificDefaultWriter(rec.Schema);
writer.Write(rec.Schema, rec, binEncoder);
// deserialize
stream.Position = 0;
var decoder = new BinaryDecoder(stream);
var reader = new SpecificDefaultReader(rec.Schema, rec.Schema);
var rec2 = (ISpecificRecord)reader.Read(null, rec.Schema, rec.Schema, decoder);
Assert.IsFalse(rec2 == null);
}
