private void GenerateCodeFromFeature(Feature feature, TextWriter writer) { CodeDomHelper codeDomHelper = new CodeDomHelper(CodeDomProviderLanguage.CSharp); XUnitTestGeneratorProvider xUnitTestGeneratorProvider = new XUnitTestGeneratorProvider(); SpecFlowUnitTestConverter converter = FactoryMethods.CreateUnitTestConverter(xUnitTestGeneratorProvider); var codeNamespace = converter.GenerateUnitTestFixture(feature, "TestClassName", "Target.Namespace"); CSharpCodeProvider codeProvider = new CSharpCodeProvider(); CodeGeneratorOptions options = new CodeGeneratorOptions(); codeProvider.GenerateCodeFromNamespace(codeNamespace, writer, options); }
public static void Main (string [] args) { try { if (args.Length < 1) { Console.WriteLine ("mono dsgentest.exe filename"); return; } DataSet ds = new DataSet (); ds.ReadXml (args [0]); ICodeGenerator gen = new CSharpCodeProvider ().CreateGenerator (); CodeNamespace cns = new CodeNamespace ("MyNamespace"); TextWriter tw = new StreamWriter (Path.ChangeExtension (args [0], ".ms.cs"), false, Encoding.Default); TypedDataSetGenerator.Generate (ds, cns, gen); gen.GenerateCodeFromNamespace (cns, tw, null); tw.Close (); cns = new CodeNamespace ("MyNamespace"); tw = new StreamWriter (Path.ChangeExtension (args [0], ".mono.cs"), false, Encoding.Default); CustomDataClassGenerator.CreateDataSetClasses (ds, cns, gen, null); gen.GenerateCodeFromNamespace (cns, tw, null); tw.Close (); } catch (Exception ex) { Console.WriteLine (ex); } }
public void Build(DataStructure dataStructure, string rendererFilename = "") { if (string.IsNullOrEmpty(rendererFilename)) { rendererFilename = this.GetFilename(dataStructure); } var rendererType = new CodeTypeDeclaration(dataStructure.RendererName); rendererType.IsClass = true; rendererType.IsPartial = true; rendererType.BaseTypes.Add(typeof(Renderer)); rendererType.Comments.Add(new CodeCommentStatement("<summary>", true)); rendererType.Comments.Add(new CodeCommentStatement(string.Format("Renderer of {0}", dataStructure.TargetName), true)); rendererType.Comments.Add(new CodeCommentStatement("</summary>", true)); BuildCreate(rendererType, dataStructure); BuildConstructor(rendererType, dataStructure); BuildDoInitialize(rendererType, dataStructure); BuildDoRender(rendererType, dataStructure); var parserNamespace = new CodeNamespace("CSharpGL"); parserNamespace.Imports.Add(new CodeNamespaceImport(typeof(System.Object).Namespace)); parserNamespace.Imports.Add(new CodeNamespaceImport(typeof(System.Collections.Generic.List<int>).Namespace)); parserNamespace.Types.Add(rendererType); //生成代码 using (var stream = new StreamWriter(rendererFilename, false)) { CSharpCodeProvider codeProvider = new CSharpCodeProvider(); CodeGeneratorOptions opentions = new CodeGeneratorOptions();//代码生成选项 opentions.BlankLinesBetweenMembers = true; opentions.BracingStyle = "C"; opentions.ElseOnClosing = false; opentions.IndentString = " "; opentions.VerbatimOrder = true; codeProvider.GenerateCodeFromNamespace(parserNamespace, stream, opentions); } }
public void CanCreateDataTableAssignment() { CodeNamespace nsdecl = new CodeNamespace("My.Data"); CodeTypeDeclaration cdecl = new CodeTypeDeclaration("ResultSet"); CodeMemberMethod method = new CodeMemberMethod(); method.Name = "GetData"; method.Attributes = MemberAttributes.Public | MemberAttributes.Final; method.ReturnType = new CodeTypeReference("System.Data.DataTable"); method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "name")); method.Statements.Add(new CodeVariableDeclarationStatement( typeof(DataTable), "result", new CodeObjectCreateExpression(typeof(DataTable)))); cdecl.Members.Add(method); method.Statements.Add( new CodeVariableDeclarationStatement( typeof(DataColumnCollection), "columns", new CodePropertyReferenceExpression( new CodeVariableReferenceExpression("result"), "Columns"))); method.Statements.Add(new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("columns"), "Add", new CodeTypeOfExpression(typeof(string)), new CodeSnippetExpression("name"))); nsdecl.Types.Add(cdecl); CSharpCodeProvider provider = new CSharpCodeProvider(); provider.GenerateCodeFromNamespace(nsdecl, Console.Out, new System.CodeDom.Compiler.CodeGeneratorOptions()); }
public static FileInfo CreateCode(DataTable dataTable, string filename = null) { // CodeGeneratorOptions so the output is clean and easy to read CodeGeneratorOptions codeOptions = CreateGeneratorOptions(); string result = string.Empty; CodeNamespace codeNamespace = Code.CreateCodeNamespace(dataTable); using (MemoryStream memoryStream = new MemoryStream()) using (TextWriter textWriter = new StreamWriter(memoryStream, new UTF8Encoding(false, true))) using (CSharpCodeProvider codeProvider = new CSharpCodeProvider()) { codeProvider.GenerateCodeFromNamespace(codeNamespace, textWriter, codeOptions); result = Encoding.UTF8.GetString(memoryStream.ToArray()); } // Correct our little auto-property 'hack' result = result.Replace("//;", ""); if (string.IsNullOrWhiteSpace(filename)) { filename = Path.GetRandomFileName(); } // Save file (if appropriate) File.WriteAllText(filename, result); return new FileInfo(filename); }
public void Build(DataStructure dataStructure, string modelFilename = "") { if (string.IsNullOrEmpty(modelFilename)) { modelFilename = this.GetFilename(dataStructure); } // public class DemoModel : IBufferable { } var modelType = new CodeTypeDeclaration(dataStructure.ModelName); modelType.IsClass = true; modelType.IsPartial = true; modelType.BaseTypes.Add(typeof(IBufferable)); modelType.Comments.Add(new CodeCommentStatement("<summary>", true)); modelType.Comments.Add(new CodeCommentStatement(string.Format("Model of {0}", dataStructure.TargetName), true)); modelType.Comments.Add(new CodeCommentStatement("</summary>", true)); BuildFields(modelType, dataStructure); BuildGetVertexAttributeBuffer(modelType, dataStructure); BuildGetIndex(modelType, dataStructure); var parserNamespace = new CodeNamespace("CSharpGL"); parserNamespace.Imports.Add(new CodeNamespaceImport(typeof(System.Object).Namespace)); parserNamespace.Imports.Add(new CodeNamespaceImport(typeof(System.Collections.Generic.List<int>).Namespace)); parserNamespace.Types.Add(modelType); //生成代码 using (var stream = new StreamWriter(modelFilename, false)) { CSharpCodeProvider codeProvider = new CSharpCodeProvider(); CodeGeneratorOptions opentions = new CodeGeneratorOptions();//代码生成选项 opentions.BlankLinesBetweenMembers = true; opentions.BracingStyle = "C"; opentions.ElseOnClosing = false; opentions.IndentString = " "; opentions.VerbatimOrder = true; codeProvider.GenerateCodeFromNamespace(parserNamespace, stream, opentions); } }
private static void WriteCSharpCodeFile(CodeNamespace code, string outputFileName) { CSharpCodeProvider provider = new CSharpCodeProvider(); CodeGeneratorOptions options = new CodeGeneratorOptions(); using (StreamWriter writer = new StreamWriter(outputFileName, false)) provider.GenerateCodeFromNamespace(code, writer, options); }
private void GenerateCodeFromFeature(Feature feature, TextWriter writer) { SpecFlowUnitTestConverter converter = FactoryMethods.CreateUnitTestConverter(new NUnitTestConverter()); var codeNamespace = converter.GenerateUnitTestFixture(feature, "TestClassName", "Target.Namespace"); CSharpCodeProvider codeProvider = new CSharpCodeProvider(); CodeGeneratorOptions options = new CodeGeneratorOptions(); codeProvider.GenerateCodeFromNamespace(codeNamespace, writer, options); }
private void GenerateCodeFromFeature(Feature feature, TextWriter writer) { var codeDomHelper = new CodeDomHelper(CodeDomProviderLanguage.CSharp); var mbUnitTestGeneratorProvider = new MbUnitTestGeneratorProvider(); var converter = new SpecFlowUnitTestConverter(mbUnitTestGeneratorProvider, codeDomHelper, true); CodeNamespace codeNamespace = converter.GenerateUnitTestFixture(feature, "TestClassName", "Target.Namespace"); var codeProvider = new CSharpCodeProvider(); var options = new CodeGeneratorOptions(); codeProvider.GenerateCodeFromNamespace(codeNamespace, writer, options); }
public static System.Reflection.Assembly CreateAssemblyFromDataTable(DataTable DataValues) { Random rnd = new Random(); if (DataValues.TableName == null || DataValues.TableName == string.Empty) DataValues.TableName = rnd.Next().ToString(); CodeTypeDeclaration classDec = new CodeTypeDeclaration(DataValues.TableName); classDec.IsClass = true; CodeConstructor constructor = new CodeConstructor(); constructor.Attributes = MemberAttributes.Public; classDec.Members.Add(classDec); foreach (DataColumn col in DataValues.Columns) { AddPropertyAndField(classDec, col.DataType, string.Empty, col.ColumnName); } AddPropertyAndField(classDec, null, "System.Collections.Generic.List<" + DataValues.TableName + ">", "ListOf" + DataValues.TableName); using (CSharpCodeProvider provider = new CSharpCodeProvider()) { //ICodeGenerator generator = provider.CreateGenerator(); CodeNamespace ns = new CodeNamespace("Terminals.Generated"); ns.Types.Add((CodeTypeDeclaration)classDec); CodeGeneratorOptions options = new CodeGeneratorOptions(); //options.BlankLinesBetweenMembers = true; string filename = System.IO.Path.GetTempFileName(); using (System.IO.StreamWriter sw = new System.IO.StreamWriter(filename, false)) { //generator.GenerateCodeFromNamespace(ns, sw, options); provider.GenerateCodeFromNamespace(ns, sw, options); //ICodeCompiler icc = provider.CreateCompiler(); CompilerParameters compileParams = new CompilerParameters(); compileParams.GenerateExecutable = false; compileParams.GenerateInMemory = true; //return icc.CompileAssemblyFromSource(compileParams, System.IO.File.ReadAllText(filename)).CompiledAssembly; CompilerResults icc = provider.CompileAssemblyFromSource(compileParams, System.IO.File.ReadAllText(filename)); return icc.CompiledAssembly; } } }
private string GetSourceFromCCU(CodeCompileUnit CCU) { CSharpCodeProvider cscp = new CSharpCodeProvider(); StringBuilder sb = new StringBuilder(); System.IO.StringWriter sw = new System.IO.StringWriter(sb); CodeGeneratorOptions options = new CodeGeneratorOptions(); options.BracingStyle = "C"; options.BlankLinesBetweenMembers = false; if (Generated) { cscp.GenerateCodeFromCompileUnit(CCU, sw, options); } else { cscp.GenerateCodeFromNamespace(CCU.Namespaces[0], sw, options); } return sb.ToString(); }
public static string GenerateCode(CodeObject codeObj) { var provider = new CSharpCodeProvider(); using (var stream = new MemoryStream()) using (var writer = new StreamWriter(stream)) { if (codeObj is CodeCompileUnit) { provider.GenerateCodeFromCompileUnit(codeObj as CodeCompileUnit, writer, null); } else if (codeObj is CodeExpression) { provider.GenerateCodeFromExpression(codeObj as CodeExpression, writer, null); } else if (codeObj is CodeStatement) { provider.GenerateCodeFromStatement(codeObj as CodeStatement, writer, null); } else if (codeObj is CodeTypeMember) { provider.GenerateCodeFromMember(codeObj as CodeTypeMember, writer, null); } else if (codeObj is CodeNamespace) { provider.GenerateCodeFromNamespace(codeObj as CodeNamespace, writer, null); } else { throw new InvalidOperationException(); } writer.Flush(); stream.Position = 0; using (var reader = new StreamReader(stream)) { return reader.ReadToEnd(); } } }
public void VerifyCtors() { CodeNamespace nsdecl = new CodeNamespace("My.Data"); CodeTypeDeclaration cdecl = new CodeTypeDeclaration("ResultSet"); CodeConstructor ctor = new CodeConstructor(); ctor.ReturnType = new CodeTypeReference("ResultSet"); ctor.Attributes = MemberAttributes.Public; cdecl.Members.Add(ctor); nsdecl.Types.Add(cdecl); CSharpCodeProvider provider = new CSharpCodeProvider(); provider.GenerateCodeFromNamespace(nsdecl, Console.Out, new System.CodeDom.Compiler.CodeGeneratorOptions()); }
/// <summary> /// Preia informatiile din documentul WSDL (contruieste si compileaza un proxy local pentru serviciul web). /// Pune la dispozitie toate metodele ce pot fi invocate prin acest proxy. /// </summary> private void DynamicInvocation() { try { txbMessage.Text = ""; Uri uri = new Uri(txbWSDLAddress.Text); txbMessage.Text += "Requesting WSDL\r\n"; WebRequest webRequest = WebRequest.Create(uri); System.IO.Stream requestStream = webRequest.GetResponse().GetResponseStream(); ServiceDescription serviceDescription = ServiceDescription.Read(requestStream); string serviceName = serviceDescription.Services[0].Name; trvMethods.Nodes.Add(serviceName); txbMessage.Text += "Generating Proxy\r\n"; ServiceDescriptionImporter serviceDescriptionImporter = new ServiceDescriptionImporter(); serviceDescriptionImporter.AddServiceDescription(serviceDescription, String.Empty, String.Empty); serviceDescriptionImporter.ProtocolName = "Soap"; serviceDescriptionImporter.CodeGenerationOptions = CodeGenerationOptions.GenerateProperties; txbMessage.Text += "Generating assembly\r\n"; CodeNamespace codeNameSpace = new CodeNamespace(); CodeCompileUnit codeCompileUnit = new CodeCompileUnit(); codeCompileUnit.Namespaces.Add(codeNameSpace); ServiceDescriptionImportWarnings serviceDescriptionImportWarnings = serviceDescriptionImporter.Import(codeNameSpace, codeCompileUnit); if (serviceDescriptionImportWarnings == 0) { StringWriter stringWriter = new StringWriter(); CSharpCodeProvider cSharpCodeProvider = new CSharpCodeProvider(); cSharpCodeProvider.GenerateCodeFromNamespace(codeNameSpace, stringWriter, new CodeGeneratorOptions()); txbMessage.Text += "Compiling assembly\r\n"; string[] assemblyReferences = new string[2] { "System.Web.Services.dll", "System.Xml.dll" }; CompilerParameters compileParameters = new CompilerParameters(assemblyReferences); compileParameters.GenerateExecutable = false; compileParameters.GenerateInMemory = true; compileParameters.TreatWarningsAsErrors = false; compileParameters.WarningLevel = 4; CompilerResults compilerResults = new CompilerResults(new TempFileCollection()); compilerResults = cSharpCodeProvider.CompileAssemblyFromDom(compileParameters, codeCompileUnit); Assembly assembly = compilerResults.CompiledAssembly; service = assembly.GetType(serviceName); txbMessage.Text += "Retrieving web service methods\r\n"; methodInfos = service.GetMethods(); foreach (MethodInfo methodInfo in methodInfos) { if (methodInfo.Name == "Discover") { break; } trvMethods.Nodes[0].Nodes.Add(methodInfo.Name); } trvMethods.Nodes[0].Expand(); txbMessage.Text += "Ready to invoke\r\n "; } else { txbMessage.Text += serviceDescriptionImportWarnings; } } catch (Exception e) { txbMessage.Text += "\r\n" + e.Message + "\r\n\r\n" + e.ToString(); } tabControl.SelectedTab = tabPageMessage; txbMessage.DeselectAll(); }
private string InvokeMethod(string wsdl_text,string MethodName,Object[] param1) { try { Uri uri = new Uri(wsdl_text); WebRequest webRequest = WebRequest.Create(uri); System.IO.Stream requestStream = webRequest.GetResponse().GetResponseStream(); // Get a WSDL file describing a service ServiceDescription sd = ServiceDescription.Read(requestStream); string sdName = sd.Services[0].Name; // Initialize a service description servImport ServiceDescriptionImporter servImport = new ServiceDescriptionImporter(); servImport.AddServiceDescription(sd, String.Empty, String.Empty); servImport.ProtocolName = "Soap"; servImport.CodeGenerationOptions = CodeGenerationOptions.GenerateProperties; CodeNamespace nameSpace = new CodeNamespace(); CodeCompileUnit codeCompileUnit = new CodeCompileUnit(); codeCompileUnit.Namespaces.Add(nameSpace); // Set Warnings ServiceDescriptionImportWarnings warnings = servImport.Import(nameSpace, codeCompileUnit); if (warnings == 0) { StringWriter stringWriter = new StringWriter(System.Globalization.CultureInfo.CurrentCulture); Microsoft.CSharp.CSharpCodeProvider prov = new Microsoft.CSharp.CSharpCodeProvider(); prov.GenerateCodeFromNamespace(nameSpace, stringWriter, new CodeGeneratorOptions()); // Compile the assembly with the appropriate references string[] assemblyReferences = new string[2] { "System.Web.Services.dll", "System.Xml.dll" }; CompilerParameters param = new CompilerParameters(assemblyReferences); param.GenerateExecutable = false; param.GenerateInMemory = true; param.TreatWarningsAsErrors = false; param.WarningLevel = 4; CompilerResults results = new CompilerResults(new TempFileCollection()); results = prov.CompileAssemblyFromDom(param, codeCompileUnit); Assembly assembly = results.CompiledAssembly; service = assembly.GetType(sdName); MethodInfo[] methodinfo = service.GetMethods(); string result = null; foreach (MethodInfo t in methodinfo) if (t.Name == MethodName) { //Invoke Method Object obj = Activator.CreateInstance(service); Object response = t.Invoke(obj, param1); Array myArrayList = response as Array; if (myArrayList != null) { List<Object> result_obj = new List<Object>(); foreach (var item in myArrayList) { foreach (var currentPropertyInformation in item.GetType().GetProperties()) { //currentPropertyInformation.GetValue(item, null); //Result.Text = Result.Text + currentPropertyInformation.Name + ":" + currentPropertyInformation.GetValue(item, null); result = currentPropertyInformation.GetValue(item, null).ToString(); } } } else if(response.GetType().ToString() != "System.String") { foreach (var currentPropertyInformation in response.GetType().GetProperties()) { //currentPropertyInformation.GetValue(item, null); //Result.Text = Result.Text + currentPropertyInformation.Name + ":" + currentPropertyInformation.GetValue(item, null); if (currentPropertyInformation.GetValue(response, null) != null) { result = result + currentPropertyInformation.Name + ":" + currentPropertyInformation.GetValue(response, null) + "|"; } else { result = result + currentPropertyInformation.Name + ":NULL,"; } } } if(response!=null && result==null) { result = response.ToString(); } break; } return result; } else { return null; } } catch (Exception ex) { return null; } }
static string GenerateCode(CodeNamespace ns) { CSharpCodeProvider provider = new CSharpCodeProvider(); StringWriter writer = new StringWriter(new StringBuilder()); provider.GenerateCodeFromNamespace(ns, writer, null); return writer.ToString(); }
/// <summary> /// Generates CSharp text from a namespace and writes it to a text writer with the given options. /// </summary> /// <param name="namespace">The namespace to generate text from.</param> /// <param name="writer">The text writer to write to.</param> /// <param name="options">The generation options.</param> public static void GenerateCSharpTo(this CodeNamespace @namespace, TextWriter writer, CodeGeneratorOptions options) { using (var provider = new CSharpCodeProvider()) { provider.GenerateCodeFromNamespace(@namespace, writer, options); } }
public void Run(string src, string dest) { // Load the schema to process. XmlSchema xsd; using (Stream stm = File.OpenRead(src)) xsd = XmlSchema.Read(stm, null); // Collection of schemas for the XmlSchemaImporter XmlSchemas xsds = new XmlSchemas(); xsds.Add(xsd); XmlSchemaImporter imp = new XmlSchemaImporter(xsds); // System.CodeDom namespace for the XmlCodeExporter to put classes in CodeNamespace ns = new CodeNamespace("NHibernate.Mapping.Hbm"); CodeCompileUnit ccu = new CodeCompileUnit(); XmlCodeExporter exp = new XmlCodeExporter(ns, ccu, ~CodeGenerationOptions.GenerateProperties); // Iterate schema items (top-level elements only) and generate code for each foreach (XmlSchemaObject item in xsd.Items) { if (item is XmlSchemaElement) { // Import the mapping first XmlTypeMapping map = imp.ImportTypeMapping(new XmlQualifiedName(((XmlSchemaElement)item).Name, xsd.TargetNamespace)); // Export the code finally exp.ExportTypeMapping(map); } } ns.Imports.Add(new CodeNamespaceImport("Ayende.NHibernateQueryAnalyzer.SchemaEditing")); AddRequiredTags(ns, xsd); // Code generator to build code with. CodeDomProvider generator = new CSharpCodeProvider(); // Generate untouched version using (StreamWriter sw = new StreamWriter(dest, false)) generator.GenerateCodeFromNamespace(ns, sw, new CodeGeneratorOptions()); }
public void CompileExpressions() { var csharp = new CSharpCodeProvider(); var w = new StreamWriter(new FileStream("compiled.cs", FileMode.Create)); var c = new CodeCommentStatement("This file is dynamically generated"); csharp.GenerateCodeFromStatement(c, w, null); var namespc = new CodeNamespace("Melon.Reports"); namespc.Imports.Add(new CodeNamespaceImport("System")); namespc.Imports.Add(new CodeNamespaceImport("System.Collections.Generic")); namespc.Imports.Add(new CodeNamespaceImport("Melon.Reports.Objects")); var ExpressionCalculatorClass = new CodeTypeDeclaration("ExpressionCalculator") { IsClass = true, TypeAttributes = TypeAttributes.Public }; namespc.Types.Add(ExpressionCalculatorClass); ExpressionCalculatorClass.BaseTypes.Add("Melon.Reports.AbstractCalculator"); ExpressionCalculatorClass.Members.Add(createConstructor()); foreach (var field in fields) { var f = new CodeMemberField(field.Type, field.Name) { Attributes = MemberAttributes.Public }; ExpressionCalculatorClass.Members.Add(f); } //especial variables ExpressionCalculatorClass.Members.Add(new CodeMemberField(typeof (int), "GlobalRecordCount") {Attributes = MemberAttributes.Public}); ExpressionCalculatorClass.Members.Add(new CodeMemberField(typeof (int), "PageNumber") {Attributes = MemberAttributes.Public}); /* * public object EvaluateVariableExpression(int hashcode){ * ..... * } */ var dynaCode = new StringBuilder("Object o = null; \n switch(i){\n"); foreach (var variable in variables.Values) { dynaCode.Append(Case(variable)); ExpressionCalculatorClass.Members.Add(createProperty(variable)); } dynaCode.Append(" }\nreturn o"); ExpressionCalculatorClass.Members.Add(createMethod(dynaCode, "EvaluateVariableExpression")); /* add expressions using the hash trick * * public virtual object EvaluateExpression(int i) { * Object o = null; * switch(i){ * case 13: * o = (System.String)System.DateTime.Today.ToShortDateString(); * break; * case ........ * .. * } * } */ dynaCode = new StringBuilder("Object o = null; \n switch(i){\n"); foreach (var ex in expressions) { dynaCode.Append(" case " + ex.GetHashCode() + ":\n" + " o = " + ex.Content + ";\n" + " break;\n"); } dynaCode.Append(" }\n return o"); ExpressionCalculatorClass.Members.Add(createMethod2(dynaCode, "EvaluateExpression")); var cu = new CodeCompileUnit(); cu.Namespaces.Add(namespc); csharp.GenerateCodeFromNamespace(namespc, w, null); w.Close(); var thisAsembly = Assembly.GetAssembly(GetType()).Location; //compilation var compparams = new CompilerParameters(new[] {"mscorlib.dll", thisAsembly}) {GenerateInMemory = true}; var ErrorMsg = ""; var cscompiler = csharp.CreateCompiler(); var compresult = cscompiler.CompileAssemblyFromDom(compparams, cu); if (compresult == null || compresult.Errors.Count > 0) { if (compresult != null) if (compresult.Errors.Count > 0) { foreach (CompilerError CompErr in compresult.Errors) { ErrorMsg = ErrorMsg + "Line number " + CompErr.Line + ", Error Number: " + CompErr.ErrorNumber + ", '" + CompErr.ErrorText + ";" + Environment.NewLine + Environment.NewLine; } } throw new Exception(ErrorMsg); } object o = compresult.CompiledAssembly.CreateInstance("Melon.Reports.ExpressionCalculator", true, BindingFlags.CreateInstance, null, new object[] {variables}, null, null); Console.WriteLine(compresult.CompiledAssembly.Location); if (o == null) { throw new ApplicationException(".NET implementation is broken."); } var test = compresult.CompiledAssembly.GetType("Melon.Reports.ExpressionCalculator"); compiledExpressions = o; compiledType = test; }
private static CompatibilityCheckResult CheckAgainsAppCode(DataTypeDescriptor dataTypeDescriptorToTest, bool includeDataTypeDescriptor) { List<string> filesToCompile = GetAppCodeFiles().ToList(); if (filesToCompile.Count == 0) return new CompatibilityCheckResult(); CSharpCodeProvider csCompiler = new CSharpCodeProvider(); List<Assembly> referencedAssemblies = new List<Assembly>(); Dictionary<string, List<CodeTypeDeclaration>> codeTypeDeclarations = new Dictionary<string, List<CodeTypeDeclaration>>(); foreach (DataTypeDescriptor dataTypeDescriptor in DataMetaDataFacade.GeneratedTypeDataTypeDescriptors) { if (!includeDataTypeDescriptor && (dataTypeDescriptor.DataTypeId == dataTypeDescriptorToTest.DataTypeId)) continue; DataTypeDescriptor dataTypeDescriptorToUse = dataTypeDescriptor; if (includeDataTypeDescriptor && (dataTypeDescriptor.DataTypeId == dataTypeDescriptorToTest.DataTypeId)) dataTypeDescriptorToUse = dataTypeDescriptorToTest; referencedAssemblies.AddRange(InterfaceCodeGenerator.GetReferencedAssemblies(dataTypeDescriptorToUse)); CodeTypeDeclaration codeTypeDeclaration = InterfaceCodeGenerator.CreateCodeTypeDeclaration(dataTypeDescriptorToUse); List<CodeTypeDeclaration> declarations; if (!codeTypeDeclarations.TryGetValue(dataTypeDescriptorToUse.Namespace, out declarations)) { declarations = new List<CodeTypeDeclaration>(); codeTypeDeclarations.Add(dataTypeDescriptorToUse.Namespace, declarations); } declarations.Add(codeTypeDeclaration); string tempFilePath = GetTempFileName(dataTypeDescriptorToUse); filesToCompile.Add(tempFilePath); using (FileStream file = File.Create(tempFilePath)) { using (var sw = new StreamWriter(file)) { CodeNamespace codeNamespace = new CodeNamespace(dataTypeDescriptorToUse.Namespace); codeNamespace.Types.Add(codeTypeDeclaration); csCompiler.GenerateCodeFromNamespace(codeNamespace, sw, new CodeGeneratorOptions()); } StringBuilder sb = new StringBuilder(); using (var sw = new StringWriter(sb)) { csCompiler.GenerateCodeFromMember(codeTypeDeclaration, sw, new CodeGeneratorOptions()); } } } filesToCompile.Sort(); CompilerParameters compilerParameters = new CompilerParameters(); compilerParameters.GenerateExecutable = false; compilerParameters.GenerateInMemory = true; compilerParameters.ReferencedAssemblies.AddRangeIfNotContained(referencedAssemblies.Select(f => f.Location).ToArray()); compilerParameters.ReferencedAssemblies.AddRangeIfNotContained(CodeGenerationManager.CompiledAssemblies.Select(f => f.Location).ToArray()); compilerParameters.AddAssemblyLocationsFromBin(); compilerParameters.AddLoadedAssemblies(false); compilerParameters.AddCommonAssemblies(); compilerParameters.RemoveGeneratedAssemblies(); CodeCompileUnit codeCompileUnit = new CodeCompileUnit(); foreach (var kvp in codeTypeDeclarations) { CodeNamespace codeNamespace = new CodeNamespace(kvp.Key); codeNamespace.Types.AddRange(kvp.Value.ToArray()); codeCompileUnit.Namespaces.Add(codeNamespace); } CSharpCodeProvider compiler = new CSharpCodeProvider(); CompilerResults compileResult = compiler.CompileAssemblyFromFile(compilerParameters, filesToCompile.ToArray()); if (compileResult.Errors.Count == 0) return new CompatibilityCheckResult(); // Checking for a missing assembly error, if it is present, that means that App_Code check isn't applicable due to circular reference foreach (CompilerError error in compileResult.Errors) { if (error.ErrorNumber == "CS0012" && error.ErrorText.Contains("Composite.Generated")) { return new CompatibilityCheckResult(); } } return new CompatibilityCheckResult(compileResult); }
/// <summary> /// Gets the compiled assemble. /// </summary> /// <param name="servImport">The serv import.</param> /// <returns></returns> private Assembly GetCompiledAssemble(ServiceDescriptionImporter servImport) { CodeNamespace ns = new CodeNamespace(); CodeCompileUnit ccu = new CodeCompileUnit(); ccu.Namespaces.Add(ns); servImport.Import(ns, ccu); StringWriter sw = new StringWriter(CultureInfo.CurrentCulture); CSharpCodeProvider prov = new CSharpCodeProvider(); prov.GenerateCodeFromNamespace(ns, sw, null); CompilerParameters param = new CompilerParameters(new String[]{ "System.dll", "System.Xml.dll", "System.Web.Services.dll", "System.Data.dll"}); param.GenerateExecutable = false; param.GenerateInMemory = true; param.TreatWarningsAsErrors = false; param.WarningLevel = 4; CompilerResults results = new CompilerResults(null); results = prov.CompileAssemblyFromSource(param, sw.ToString()); return results.CompiledAssembly; }
/// <summary> /// Actually compiles the code, throwing an exception on the first /// error. /// </summary> private ITemplate Compile(CodeNamespace cns) { // Set up the provider and generator CSharpCodeProvider provider = new CSharpCodeProvider(); CodeGeneratorOptions gOptions = new CodeGeneratorOptions(); CompilerParameters cOptions = new CompilerParameters(); // Add our own assembly (using base) to make sure it can // be found. We also have to add the Utility library for // Developer Studio (thanks iceh). (Closes #51) cOptions.ReferencedAssemblies.Add(GetType().Assembly.Location); cOptions.ReferencedAssemblies .Add(typeof(Logger).Assembly.Location); // Add the other assemblies foreach (Assembly refass in referencedAssemblies) { cOptions.ReferencedAssemblies.Add(refass.Location); } // Set up other options cOptions.GenerateInMemory = true; // Figure out the stream CompilerResults results = null; if (tempFile == null) { // Create directory into memory CodeCompileUnit cu = new CodeCompileUnit(); cu.Namespaces.Add(cns); if (compileAssembly) results = provider.CompileAssemblyFromDom(cOptions, cu); } else { // Actually write out the code to the stream StreamWriter writer = CreateStreamWriter(); provider.GenerateCodeFromNamespace(cns, writer, gOptions); writer.Close(); // Now compile it from the file if (compileAssembly) { results = provider.CompileAssemblyFromFile(cOptions, tempFile.FullName); } } // If we aren't compiling, just return null if (!compileAssembly) return null; // Process the results foreach (CompilerError ce in results.Errors) { if (ce.IsWarning) { Alert("{2} ({3}): {0}: {1}", ce.ErrorNumber, ce.ErrorText, ce.FileName, ce.Line); } else { Error("{2} ({3}): {0}: {1}", ce.ErrorNumber, ce.ErrorText, ce.FileName, ce.Line); } } if (results.Errors.HasErrors) throw new TemplateException( "The compiled template had errors"); // Load the assembly Assembly assembly = results.CompiledAssembly; string typeName = namespaceName + "." + className; Type type = assembly.GetType(typeName); // Make sure we can create it and assign it if (type == null) throw new TemplateException("Cannot create temporary class " + typeName); if (!typeof(ITemplate).IsAssignableFrom(type)) throw new TemplateException(extendsName + " does not extend " + "MfGames.Template.ITemplate"); // Get the constructor ConstructorInfo ci = type.GetConstructor(new Type[] { }); if (ci == null) throw new TemplateException( "Cannot create a default constructor"); // Create the object ITemplate template = (ITemplate) ci.Invoke(new object[] { }); template.TemplateFactory = this; // At this point, everything is good, so delete the temp if (tempFile != null && deleteTempFile) tempFile.Delete(); // Return it return template; }
/// <summary> /// Writes the class file. This method actually creates the physical /// class file and populates it accordingly. /// </summary> /// <param name="className">Name of the class file to be written.</param> /// <param name="codenamespace">The <see cref="CodeNamespace"/> which represents the /// file to be written.</param> private void WriteClassFile(string className, CodeNamespace codenamespace) { var csharpCodeProvider = new CSharpCodeProvider(); string sourceFile = this.OutputDirectory + this.buildSystem.DirectorySeparatorChar + className + "." + csharpCodeProvider.FileExtension; sourceFile = Utility.ScrubPathOfIllegalCharacters(sourceFile); var indentedTextWriter = new IndentedTextWriter(this.buildSystem.GetTextWriter(sourceFile, false), " "); var codeGenerationOptions = new CodeGeneratorOptions { BracingStyle = "C" }; csharpCodeProvider.GenerateCodeFromNamespace( codenamespace, indentedTextWriter, codeGenerationOptions); indentedTextWriter.Flush(); indentedTextWriter.Close(); }
private void DynamicInvocation(string wsUrl, TreeView tv, ref MethodInfo[] methodInfo) { try { Uri uri = new Uri(wsUrl); //txtUrl.Text); WebRequest webRequest = WebRequest.Create(uri); System.IO.Stream requestStream = webRequest.GetResponse().GetResponseStream(); // Get a WSDL file describing a service ServiceDescription sd = ServiceDescription.Read(requestStream); string sdName = sd.Services[0].Name; // Add in tree view TreeNode n = new TreeNode(sdName); tv.Nodes.Add(n); //treMethods.Nodes.Add(n); // Initialize a service description servImport ServiceDescriptionImporter servImport = new ServiceDescriptionImporter(); servImport.AddServiceDescription(sd, String.Empty, String.Empty); servImport.ProtocolName = "Soap"; servImport.CodeGenerationOptions = CodeGenerationOptions.GenerateProperties; CodeNamespace nameSpace = new CodeNamespace(); CodeCompileUnit codeCompileUnit = new CodeCompileUnit(); codeCompileUnit.Namespaces.Add(nameSpace); // Set Warnings ServiceDescriptionImportWarnings warnings = servImport.Import(nameSpace, codeCompileUnit); if (warnings == 0) { StringWriter stringWriter = new StringWriter(System.Globalization.CultureInfo.CurrentCulture); Microsoft.CSharp.CSharpCodeProvider prov = new Microsoft.CSharp.CSharpCodeProvider(); prov.GenerateCodeFromNamespace(nameSpace, stringWriter, new CodeGeneratorOptions()); // Compile the assembly with the appropriate references string[] assemblyReferences = new string[2] { "System.Web.Services.dll", "System.Xml.dll" }; CompilerParameters par = new CompilerParameters(assemblyReferences); par.GenerateExecutable = false; par.GenerateInMemory = true; par.TreatWarningsAsErrors = false; par.WarningLevel = 4; CompilerResults results = new CompilerResults(new TempFileCollection()); results = prov.CompileAssemblyFromDom(par, codeCompileUnit); Assembly assembly = results.CompiledAssembly; service = assembly.GetType(sdName); methodInfo = service.GetMethods(); foreach (MethodInfo t in methodInfo) { if (t.Name == "Discover") break; n = new TreeNode(t.Name); tv.Nodes[0].ChildNodes.Add(n); } tv.Nodes[0].Expand(); } else lblMsg.Text += warnings; } catch (Exception ex) { lblMsg.Text += "\r\n" + ex.Message + "\r\n\r\n" + ex.ToString(); ; } }
static void Main(string[] args) { Console.WriteLine("XML ITS1 Formatter Pregenerator Utility"); Console.WriteLine("Copyright (C) 2012, Mohawk College of Applied Arts and Technology"); ParameterParser<Parameters> parser = new ParameterParser<Parameters>(); try { var arguments = parser.Parse(args); if (arguments.ShowHelp) { ShowHelp(); return; } // Generate formatter utility MARC.Everest.Formatters.XML.ITS1.CodeGen.TypeFormatterCreator creator = new MARC.Everest.Formatters.XML.ITS1.CodeGen.TypeFormatterCreator(); // Create code namespace CodeNamespace ns = new CodeNamespace(arguments.TargetNs); // Load assembly Assembly rmimAssembly = Assembly.LoadFile(arguments.AssemblyFile); List<Type> rmimTypes = new List<Type>(); if (arguments.Interactions != null) foreach (var s in arguments.Interactions) rmimTypes.Add(rmimAssembly.GetTypes().First(o => o.Name == s)); else rmimTypes.AddRange(rmimAssembly.GetTypes()); // Validate parameters if (rmimTypes.Count == 0) throw new ArgumentException("Type array must have at least one element", "t"); // Create a list of types (a todo list) that represent the types we want to format List<Type> types = new List<Type>(200); // Iterate through types and create formatter // Iterate throgh the types foreach (Type type in rmimTypes) { if (type.Assembly != rmimAssembly) throw new InvalidOperationException("All types must belong to the same revision assembly"); GetUniqueTypes(type, types, true); } // Waith thread pool WaitThreadPool wtp = new WaitThreadPool(); try { // Create type definitions foreach (Type t in types) { // Check if we need to gen this type if (t.GetCustomAttributes(typeof(StructureAttribute), false).Length == 0 || s_formatterGenerated.Contains(t)) continue; s_formatterGenerated.Add(t); // Structure Attribute StructureAttribute sta = t.GetCustomAttributes(typeof(StructureAttribute), false)[0] as StructureAttribute; // Type formatter creator TypeFormatterCreator crtr = new TypeFormatterCreator(); // Reset event crtr.CodeTypeDeclarationCompleted += new CreateTypeFormatterCompletedDelegate(delegate(CodeTypeDeclaration result) { // Add to the code currently created if (result != null) lock (ns) ns.Types.Add(result); }); // Helper result wtp.QueueUserWorkItem(crtr.CreateTypeFormatter, t); } // Wait for final pool to clear wtp.WaitOne(); } finally { wtp.Dispose(); } if (ns.Types.Count == 0) { Console.WriteLine("Didn't create any formatter helpers..."); return; } // Setup compiler and referenced assemblies CSharpCodeProvider csharpCodeProvider = new CSharpCodeProvider(); using (TextWriter tw = File.CreateText(arguments.Output ?? "output.cs")) csharpCodeProvider.GenerateCodeFromNamespace(ns, tw, new System.CodeDom.Compiler.CodeGeneratorOptions() { IndentString = "\t" }); } catch (ArgumentNullException) { ShowHelp(); } catch (Exception e) { Console.WriteLine(e.ToString()); return; } finally { } #if DEBUG Console.ReadKey(); #endif }
private Assembly GetAssembly() { ServiceDescription sd = GetServiceDescription(); // ServiceDescriptionImporter provide means for generating client proxy classes for XML Web services CodeNamespace cns = new CodeNamespace(_Namespace); //ServiceDescriptionImporter sdi = new ServiceDescriptionImporter(); //sdi.AddServiceDescription(sd, null, null); //sdi.ProtocolName = "Soap"; //sdi.Import(cns, null); /// verificar -> se algum dia passar por aqui, notar se esta chamada tem alguma finalidade // Generate the proxy source code CSharpCodeProvider cscp = new CSharpCodeProvider(); StringBuilder sb = new StringBuilder(); StringWriter sw = new StringWriter(sb); cscp.GenerateCodeFromNamespace(cns, sw, null); string proxy = sb.ToString(); sw.Close(); // debug code !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! // StreamWriter tsw = File.CreateText(@"c:\temp\proxy.cs"); // tsw.Write(proxy); // tsw.Close(); // debug code !!!!!!!!!!!!!!!!!!!!!!!!!!!!!! // Create Assembly CompilerParameters cp = new CompilerParameters(); cp.ReferencedAssemblies.Add("System.dll"); cp.ReferencedAssemblies.Add("System.Xml.dll"); cp.ReferencedAssemblies.Add("System.Web.Services.dll"); cp.GenerateExecutable = false; cp.GenerateInMemory = false; // just loading into memory causes problems when instantiating cp.IncludeDebugInformation = false; CompilerResults cr = cscp.CompileAssemblyFromSource(cp, proxy); if(cr.Errors.Count > 0) { StringBuilder err = new StringBuilder(string.Format("WSDL proxy compile has {0} error(s).", cr.Errors.Count)); foreach (CompilerError ce in cr.Errors) { err.AppendFormat("\r\n{0} {1}", ce.ErrorNumber, ce.ErrorText); } throw new Exception(err.ToString()); } return Assembly.LoadFrom(cr.PathToAssembly); // We need an assembly loaded from the file system // or instantiation of object complains }
///// <summary> ///// Clears the cache. ///// </summary> ///// <param name="wsdlLocation">WSDL location.</param> //public static void ClearCache(string wsdlLocation) //{ // CompiledAssemblyCache.ClearCache(wsdlLocation); //} ///// <summary> ///// Clear all cached DLLs. ///// </summary> //public static void ClearAllCached() //{ // CompiledAssemblyCache.ClearAllCached(); //} /// <summary> /// Builds the assembly from WSDL. /// </summary> /// <param name="absoluteWsdlLocation">Absolute path to wsdl file.</param> /// /// <param name="wsdlContent">Actual content of wsdl file</param> /// <returns>Assembly containg proxy for service defined in <paramref name="absoluteWsdlLocation"/></returns> private Assembly BuildAssemblyFromWsdl(string absoluteWsdlLocation, string wsdlContent) { // Use an XmlTextReader to get the Web Service description StringReader wsdlStringReader = new StringReader(wsdlContent); XmlTextReader tr = new XmlTextReader(wsdlStringReader); ServiceDescription.Read(tr); tr.Close(); // WSDL service description importer CodeNamespace cns = new CodeNamespace(CodeConstants.CODENAMESPACE); sdi = new ServiceDescriptionImporter(); //sdi.AddServiceDescription(sd, null, null); // check for optional imports in the root WSDL CheckForImports(absoluteWsdlLocation); sdi.ProtocolName = protocolName; sdi.Import(cns, null); // change the base class // get all available Service classes - not only the default one ArrayList newCtr = new ArrayList(); foreach (CodeTypeDeclaration ctDecl in cns.Types) { if (ctDecl.BaseTypes.Count > 0) { if (ctDecl.BaseTypes[0].BaseType == CodeConstants.DEFAULTBASETYPE) { newCtr.Add(ctDecl); } } } foreach (CodeTypeDeclaration ctDecl in newCtr) { cns.Types.Remove(ctDecl); ctDecl.BaseTypes[0] = new CodeTypeReference(CodeConstants.CUSTOMBASETYPE); cns.Types.Add(ctDecl); } // source code generation CSharpCodeProvider cscp = new CSharpCodeProvider(); StringBuilder srcStringBuilder = new StringBuilder(); StringWriter sw = new StringWriter(srcStringBuilder, CultureInfo.CurrentCulture); if (schemas != null) { foreach (XmlSchema xsd in schemas) { if (XmlSchemas.IsDataSet(xsd)) { MemoryStream mem = new MemoryStream(); mem.Position = 0; xsd.Write(mem); mem.Position = 0; DataSet dataSet1 = new DataSet(); dataSet1.Locale = CultureInfo.InvariantCulture; dataSet1.ReadXmlSchema(mem); SDD.TypedDataSetGenerator.Generate(dataSet1, cns, cscp); } } } cscp.GenerateCodeFromNamespace(cns, sw, null); proxySource = srcStringBuilder.ToString(); sw.Close(); // assembly compilation string location = ""; if (HttpContext.Current != null) { location = HttpContext.Current.Server.MapPath("."); location += @"\bin\"; } CompilerParameters cp = new CompilerParameters(); cp.ReferencedAssemblies.Add("System.dll"); cp.ReferencedAssemblies.Add("System.Xml.dll"); cp.ReferencedAssemblies.Add("System.Web.Services.dll"); cp.ReferencedAssemblies.Add("System.Data.dll"); cp.ReferencedAssemblies.Add(Assembly.GetExecutingAssembly().Location); cp.GenerateExecutable = false; cp.GenerateInMemory = false; cp.IncludeDebugInformation = false; cp.TempFiles = new TempFileCollection(CompiledAssemblyCache.GetLibTempPath()); CompilerResults cr = cscp.CompileAssemblyFromSource(cp, proxySource); if (cr.Errors.Count > 0) throw new DynamicCompilationException(string.Format(CultureInfo.CurrentCulture, @"Building dynamic assembly failed: {0} errors", cr.Errors.Count)); Assembly compiledAssembly = cr.CompiledAssembly; return compiledAssembly; }
public string Build(string className, Type baseType, IEnumerable<string> imports) { imports = MergeRequiredImports(imports); var builder = new StringBuilder(); using (var writer = new StringWriter(builder)) { var compileUnit = new CodeCompileUnit(); var testNamespace = new CodeNamespace(); compileUnit.Namespaces.Add(testNamespace); testNamespace.Imports.AddRange( imports.Select(x => new CodeNamespaceImport(x)).ToArray()); var generator = new CSharpCodeProvider().CreateGenerator(writer); var options = new CodeGeneratorOptions(); var declaration = new CodeTypeDeclaration { Name = className, IsClass = true }; declaration.BaseTypes.Add(new CodeTypeReference(baseType)); declaration.Members.Add(RenderMethod); testNamespace.Types.Add(declaration); generator.GenerateCodeFromNamespace(testNamespace, writer, options); //TODO: implement IDisposable writer.Close(); } return builder.ToString(); }
/// <summary> /// Writes each types in each namespaces into individual files /// </summary> /// <param name="outputdir">name of directory to write to</param> public virtual void WriteTypes(string outputdir) { var cscp = new CSharpCodeProvider(); var opts = new CodeGeneratorOptions(); opts.BracingStyle = "C"; opts.IndentString = "\t"; opts.BlankLinesBetweenMembers = false; CodeNamespaceCollection nsc = CompileUnit.Namespaces; for (int i = 0; i < nsc.Count; i++) { var ns = nsc[i]; string dir = outputdir + "\\" + CodeGenUtil.Instance.UnMangle(ns.Name).Replace('.', '\\'); Directory.CreateDirectory(dir); var new_ns = new CodeNamespace(ns.Name); new_ns.Comments.Add(CodeGenUtil.Instance.FileComment); foreach (CodeNamespaceImport nci in CodeGenUtil.Instance.NamespaceImports) new_ns.Imports.Add(nci); var types = ns.Types; for (int j = 0; j < types.Count; j++) { var ctd = types[j]; string file = dir + "\\" + CodeGenUtil.Instance.UnMangle(ctd.Name) + ".cs"; using (var writer = new StreamWriter(file, false)) { new_ns.Types.Add(ctd); cscp.GenerateCodeFromNamespace(new_ns, writer, opts); new_ns.Types.Remove(ctd); } } } }
/// <summary> /// Gerar o source code do serviço /// </summary> private void GerarClasse() { #region Gerar o código da classe StringWriter writer = new StringWriter(CultureInfo.CurrentCulture); CSharpCodeProvider provider = new CSharpCodeProvider(); provider.GenerateCodeFromNamespace(GerarGrafo(), writer, null); #endregion string codigoClasse = writer.ToString(); #region Compilar o código da classe CompilerResults results = provider.CompileAssemblyFromSource(ParametroCompilacao(), codigoClasse); serviceAssemby = results.CompiledAssembly; #endregion }