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
}
