public Assembly CompileSource(params string[] references)
{
try
{
//CodeDomProvider cpd = new CSharpCodeProvider(new Dictionary<string, string>() { { "CompilerVersion", "v4.0" } });
CodeDomProvider cpd = new CSharpCodeProvider();
ICodeGenerator codeGenerator = cpd.CreateGenerator();
StringBuilder generateCode = new StringBuilder();
StringWriter codeWriter = new StringWriter(generateCode);
CodeGeneratorOptions options = new CodeGeneratorOptions
{
BracingStyle = "C"
};
codeGenerator.GenerateCodeFromCompileUnit(TargetUnit, codeWriter, options);
string thisCode = generateCode.ToString();
CompilerParameters cp = new CompilerParameters();
foreach (string refer in references)
{
cp.ReferencedAssemblies.Add(refer);
}
cp.GenerateExecutable = false;
CompilerResults cr = cpd.CompileAssemblyFromSource(cp, thisCode);
return(cr.CompiledAssembly);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
return(null);
}
static void CompileLocations(string outputFile)
{
CodeCompileUnit unit = new CodeCompileUnit();
CodeNamespace ns = new CodeNamespace("Desklet.Weather");
unit.Namespaces.Add(ns);
ns.Imports.Add(new CodeNamespaceImport("System"));
ns.Imports.Add(new CodeNamespaceImport("System.Collections.Generic"));
MainClass = new CodeTypeDeclaration("Locations");
MainClass.TypeAttributes = TypeAttributes.Class | TypeAttributes.Sealed | TypeAttributes.Public;
MainClass.IsPartial = true;
ns.Types.Add(MainClass);
CodeMemberMethod buildData = new CodeMemberMethod();
buildData.Name = "BuildData";
GenerateBuildData(buildData);
MainClass.Members.Add(buildData);
CodeDomProvider provider = new CSharpCodeProvider();
ICodeGenerator gen = provider.CreateGenerator();
TextWriter tw = new IndentedTextWriter(new StreamWriter(outputFile, false), "\t");
gen.GenerateCodeFromCompileUnit(unit, tw, new CodeGeneratorOptions());
tw.Close();
}
public CodeGenerationResult GenerateProjectCode(string file, string namespaceName, CodeDomProvider provider, GenerationOptions options, params Project[] projects)
{
ArrayList files = new ArrayList();
CodeGenerationResult res = GenerateProjectCode(options, projects);
ICodeGenerator gen = provider.CreateGenerator();
string basePath = Path.GetDirectoryName(file);
string ext = Path.GetExtension(file);
foreach (SteticCompilationUnit unit in res.Units)
{
string fname;
if (unit.Name.Length == 0)
{
fname = file;
}
else
{
fname = Path.Combine(basePath, unit.Name) + ext;
}
files.Add(fname);
unit.Name = fname;
StreamWriter fileStream = new StreamWriter(fname);
try {
gen.GenerateCodeFromCompileUnit(unit, fileStream, new CodeGeneratorOptions());
} finally {
fileStream.Close();
}
}
return(res);
}
public static string CreateCode(
Type proxyType,
ICodeGenerator generator,
XmlRpcProxyCodeGenOptions options)
{
if (options == null)
{
throw new ArgumentNullException(
"options",
"The options parameter cannot be null");
}
CodeCompileUnit ccu = CreateCodeCompileUnit(proxyType, generator, options);
CodeGeneratorOptions cgo = new CodeGeneratorOptions();
cgo.BlankLinesBetweenMembers = true;
cgo.BracingStyle = "C";
StringWriter sw = new StringWriter(CultureInfo.InvariantCulture);
generator.GenerateCodeFromCompileUnit(ccu, sw, cgo);
string ret = sw.ToString();
return(ret);
}
static void Main(string[] args)
{
Console.WriteLine("What string do you want the custom program to display?");
string message = Console.ReadLine();
Console.WriteLine("How many times do you want the program to display this message?");
int nDisplays = int.Parse(Console.ReadLine());
CodeCompileUnit unit = GenerateProgram(message, nDisplays);
// Set up options for source code style
CodeGeneratorOptions opts = new CodeGeneratorOptions();
opts.BracingStyle = "C";
opts.IndentString = "\t";
// Create code generator and write code file
CSharpCodeProvider cscp = new CSharpCodeProvider();
ICodeGenerator gen = cscp.CreateGenerator();
StreamWriter sw = new StreamWriter("MyCode.cs");
gen.GenerateCodeFromCompileUnit(unit, sw, opts);
sw.Close();
CompilerParameters compilerParams = new CompilerParameters();
compilerParams.GenerateExecutable = true;
compilerParams.OutputAssembly = "MyCode.exe";
ICodeCompiler compiler = cscp.CreateCompiler();
compiler.CompileAssemblyFromFile(compilerParams, "MyCode.cs");
}
public static void GenerateProjectCode(string file, CodeDomProvider provider, GenerationOptions options, ProjectBackend[] projects)
{
CodeGenerationResult res = GenerateProjectCode(options, projects);
ICodeGenerator gen = provider.CreateGenerator();
string basePath = Path.GetDirectoryName(file);
foreach (SteticCompilationUnit unit in res.Units)
{
string fname;
if (unit.Name.Length == 0)
{
fname = file;
}
else
{
fname = Path.Combine(basePath, unit.Name);
}
StreamWriter fileStream = new StreamWriter(fname);
try {
gen.GenerateCodeFromCompileUnit(unit, fileStream, new CodeGeneratorOptions());
} finally {
fileStream.Close();
}
}
}
public string Generate(ICodeGenerator codeGen)
{
StringWriter w = new StringWriter();
codeGen.GenerateCodeFromCompileUnit(this.compileUnit, w, null);
return(w.ToString());
}
void GenerateCode(HttpContext context, string langId)
{
context.Response.ContentType = "text/plain; charset=utf-8";
CodeNamespace codeNamespace = new CodeNamespace();
CodeCompileUnit codeUnit = new CodeCompileUnit();
codeUnit.Namespaces.Add(codeNamespace);
ServiceDescriptionImporter importer = new ServiceDescriptionImporter();
foreach (ServiceDescription sd in GetDescriptions())
{
importer.AddServiceDescription(sd, null, null);
}
foreach (XmlSchema sc in GetSchemas())
{
importer.Schemas.Add(sc);
}
importer.Import(codeNamespace, codeUnit);
if (langId == null || langId == "")
{
langId = "cs";
}
CodeDomProvider provider = GetProvider(langId);
ICodeGenerator generator = provider.CreateGenerator();
CodeGeneratorOptions options = new CodeGeneratorOptions();
generator.GenerateCodeFromCompileUnit(codeUnit, context.Response.Output, options);
}
// </Snippet2>
private void OutputGraph()
{
// Create string writer to output to textbox
StringWriter sw = new StringWriter();
// Create appropriate CodeProvider
System.CodeDom.Compiler.CodeDomProvider cp;
switch (language)
{
case 2: // VB
cp = CodeDomProvider.CreateProvider("VisualBasic");
break;
case 3: // JScript
cp = CodeDomProvider.CreateProvider("JScript");
break;
default: // CSharp
cp = CodeDomProvider.CreateProvider("CSharp");
break;
}
// Create a code generator that will output to the string writer
ICodeGenerator cg = cp.CreateGenerator(sw);
// Generate code from the compile unit and outputs it to the string writer
cg.GenerateCodeFromCompileUnit(cu, sw, new CodeGeneratorOptions());
// Output the contents of the string writer to the textbox
this.textBox1.Text = sw.ToString();
}
public string Generate(ICodeGenerator codeGen)
{
StringWriter writer1 = new StringWriter();
codeGen.GenerateCodeFromCompileUnit(compileUnit, writer1, null);
return(writer1.ToString());
}
/// <summary>
/// 生成并输出类文件.
/// </summary>
/// <param name="codeClass">用于生成类的一些基本信息.</param>
/// <param name="filePath">保存文到该文件.</param>
/// <param name="overwrite">若源代码文件存在时是否覆盖.</param>
public void WriteTo(string filePath, bool overwrite = false)
{
if (File.Exists(filePath))
{
if (overwrite)
{
File.Delete(filePath);
}
else
{
return;
}
}
using (StreamWriter codeWriter = new StreamWriter(File.Open(filePath, FileMode.OpenOrCreate, FileAccess.ReadWrite)))
{
CSharpCodeProvider provider = new CSharpCodeProvider();
ICodeGenerator generator = provider.CreateGenerator(codeWriter);
CodeGeneratorOptions options = new CodeGeneratorOptions
{
BlankLinesBetweenMembers = true,
BracingStyle = "C"
};
// 生成 using 引用
generator.GenerateCodeFromCompileUnit(new CodeSnippetCompileUnit(BuildCompileUnit()),
codeWriter, options);
// 将命名空间中的代码生成到文件.
generator.GenerateCodeFromNamespace(codeNamespace, codeWriter, options);
}
if (ResetOnAfterWrite)
{
codeNamespace = null;
}
}
public static String GenerateFullClass(ICollection <String> references, ICollection <String> imports, String CodeNamespace, String className, string methodBody, String method = "Method")
{
CodeCompileUnit unit = new CodeCompileUnit();
if (references != null)
{
foreach (var item in references)
{
unit.ReferencedAssemblies.Add(item);
}
}
CodeNamespace customEntityRoot = new CodeNamespace(CodeNamespace); //Create a namespace
unit.Namespaces.Add(customEntityRoot);
if (imports != null)
{
foreach (var item in imports)
{
customEntityRoot.Imports.Add(new CodeNamespaceImport(item));
}
}
CodeTypeDeclaration derived = new CodeTypeDeclaration(className);
customEntityRoot.Types.Add(derived);
CodeConstructor derivedClassConstructor = new CodeConstructor();
derivedClassConstructor.Attributes = MemberAttributes.Public;
derived.Members.Add(derivedClassConstructor);
CodeMemberMethod derivedMethod = new CodeMemberMethod();
derivedMethod.Attributes = MemberAttributes.Public;
derivedMethod.Name = method;
derivedMethod.ReturnType = new CodeTypeReference(typeof(void));
CodeSnippetStatement code = new CodeSnippetStatement(methodBody);
derivedMethod.Statements.Add(code);
derived.Members.Add(derivedMethod);
CSharpCodeProvider codeProvider = new CSharpCodeProvider();
ICodeGenerator codeGenerator = codeProvider.CreateGenerator();
StringBuilder generatedCode = new StringBuilder();
StringWriter codeWriter = new StringWriter(generatedCode);
CodeGeneratorOptions options = new CodeGeneratorOptions();
options.BracingStyle = "C";
codeGenerator.GenerateCodeFromCompileUnit(unit, codeWriter, options);
return(generatedCode.ToString());
}
public virtual void GenerateCodeFromCompileUnit(CodeCompileUnit compileUnit,
TextWriter writer, CodeGeneratorOptions options)
{
ICodeGenerator cg = CreateGenerator();
if (cg == null)
{
throw GetNotImplemented();
}
cg.GenerateCodeFromCompileUnit(compileUnit, writer, options);
}
public String ToCode(CodeCompileUnit compileunit, CodeDomProvider provider, IDomainMap domainMap)
{
StringBuilder sb = new StringBuilder();
StringWriter sw = new StringWriter(sb);
IndentedTextWriter tw = new IndentedTextWriter(sw, " ");
ICodeGenerator gen = provider.CreateGenerator(tw);
gen.GenerateCodeFromCompileUnit(compileunit, tw,
new CodeGeneratorOptions());
string code = sb.ToString();
if (domainMap != null)
{
foreach (ICodeMap codeMap in domainMap.CodeMaps)
{
if (provider is CSharpCodeProvider && codeMap.CodeLanguage == CodeLanguage.CSharp)
{
code = GetDomainCodeMap(domainMap, codeMap) + code;
}
else if (provider is VBCodeProvider && codeMap.CodeLanguage == CodeLanguage.VB)
{
code = GetDomainCodeMap(domainMap, codeMap) + code;
}
// if (provider is DelphiCodeProvider && codeMap.CodeLanguage == CodeLanguage.Delphi)
// {
// code = GetDomainCodeMap(code, classMap, codeMap) + code;
// }
}
foreach (IClassMap classMap in domainMap.ClassMaps)
{
foreach (ICodeMap codeMap in classMap.CodeMaps)
{
if (provider is CSharpCodeProvider && codeMap.CodeLanguage == CodeLanguage.CSharp)
{
code = InsertCodeMap(code, classMap, codeMap);
}
else if (provider is VBCodeProvider && codeMap.CodeLanguage == CodeLanguage.VB)
{
code = InsertCodeMap(code, classMap, codeMap);
}
// if (provider is DelphiCodeProvider && codeMap.CodeLanguage == CodeLanguage.Delphi)
// {
// code = InsertCodeMap(code, classMap, codeMap);
// }
}
}
}
return(code);
}
private void writeCode(CodeDomProvider provider, StreamWriter sw)
{
//Create a code generator
ICodeGenerator generator = provider.CreateGenerator();
//Default options are fine
CodeGeneratorOptions options = new CodeGeneratorOptions();
//Build the code and display it
generator.GenerateCodeFromCompileUnit(compileUnit, sw, options);
sw.Flush();
}
public String GetCode()
{
CSharpCodeProvider codeProvider = new CSharpCodeProvider();
ICodeGenerator codeGenerator = codeProvider.CreateGenerator();
StringBuilder generatedCode = new StringBuilder();
StringWriter codeWriter = new StringWriter(generatedCode);
CodeGeneratorOptions options = new CodeGeneratorOptions();
options.BracingStyle = "C";
codeGenerator.GenerateCodeFromCompileUnit(CodeCompileUnit, codeWriter, options);
return(generatedCode.ToString());
}
protected void OptionallyWriteCodeToDisk(string codeOutputFilename, CodeCompileUnit codeCompileUnit, CSharpCodeProvider provider)
{
if (codeOutputFilename != "")
{
TextWriter writer = File.CreateText(Path.Combine(MyDirectory, codeOutputFilename));
ICodeGenerator codeGenerator = provider.CreateGenerator(writer);
CodeGeneratorOptions options = GetCodeGeneratorOptions();
codeGenerator.GenerateCodeFromCompileUnit(codeCompileUnit, writer, options);
writer.Close();
}
}
public void GenerateDataset()
{
if (namesp == null)
{
namesp = "";
}
if (uri == null)
{
uri = "";
}
string targetFile = "";
DataSet dataset = new DataSet();
foreach (string fileName in schemaNames)
{
dataset.ReadXmlSchema(fileName);
if (targetFile == "")
{
targetFile = Path.GetFileNameWithoutExtension(fileName);
}
else
{
targetFile += "_" + Path.GetFileNameWithoutExtension(fileName);
}
}
targetFile += "." + provider.FileExtension;
CodeCompileUnit cunit = new CodeCompileUnit();
CodeNamespace codeNamespace = new CodeNamespace(namesp);
cunit.Namespaces.Add(codeNamespace);
codeNamespace.Comments.Add(new CodeCommentStatement("\nThis source code was auto-generated by MonoXSD\n"));
// Generate the code
ICodeGenerator gen = provider.CreateGenerator();
TypedDataSetGenerator.Generate(dataset, codeNamespace, gen);
string genFile = Path.Combine(outputDir, targetFile);
StreamWriter sw = new StreamWriter(genFile, false);
gen.GenerateCodeFromCompileUnit(cunit, sw, new CodeGeneratorOptions());
sw.Close();
Console.WriteLine("Written file " + genFile);
}
protected override string CreateProxyFile(DotNetProject dotNetProject, FilePath basePath, string proxyNamespace, string referenceName)
{
// Setup the proxy namespace and compile unit
ICodeGenerator codeGen = GetProvider(dotNetProject).CreateGenerator();
CodeNamespace codeNamespace = new CodeNamespace(proxyNamespace);
CodeConstructor urlConstructor = new CodeConstructor();
CodeCompileUnit codeUnit = new CodeCompileUnit();
codeUnit.Namespaces.Add(codeNamespace);
// Setup the importer and import the service description into the code unit
ServiceDescriptionImporter importer = Library.ReadServiceDescriptionImporter(protocol);
importer.Import(codeNamespace, codeUnit);
// Add the new Constructor with Url as a paremeter
// Search for the class which inherit SoapHttpClientProtocol (Which is the Service Class)
foreach (CodeTypeDeclaration declarationType in codeUnit.Namespaces[0].Types)
{
if (declarationType.IsClass)
{
if (declarationType.BaseTypes.Count > 0)
{
// Is a Service Class
if (declarationType.BaseTypes [0].BaseType.IndexOf("SoapHttpClientProtocol") > -1)
{
// Create new public constructor with the Url as parameter
urlConstructor.Attributes = MemberAttributes.Public;
urlConstructor.Parameters.Add(new CodeParameterDeclarationExpression("System.String", "url"));
urlConstructor.Statements.Add(new CodeAssignStatement(
new CodePropertyReferenceExpression(new CodeThisReferenceExpression(),
"Url"),
new CodeVariableReferenceExpression("url")));
declarationType.Members.Add(urlConstructor);
}
}
}
}
// Generate the code and save the file
string fileSpec = Path.Combine(basePath, dotNetProject.LanguageBinding.GetFileName(referenceName));
StreamWriter writer = new StreamWriter(fileSpec);
codeGen.GenerateCodeFromCompileUnit(codeUnit, writer, new CodeGeneratorOptions());
writer.Close();
return(fileSpec);
}
public static string ToCode(CodeCompileUnit compileunit, CodeDomProvider provider)
{
StringBuilder sb = new StringBuilder();
StringWriter sw = new StringWriter(sb);
IndentedTextWriter tw = new IndentedTextWriter(sw, " ");
ICodeGenerator gen = provider.CreateGenerator(tw);
gen.GenerateCodeFromCompileUnit(compileunit, tw,
new CodeGeneratorOptions());
string code = sb.ToString();
return(code);
}
//根据CodeDOM产生程序代码，代码文件就是GenCodeHello.cs
private string GenerateCode(CodeCompileUnit code)
{
CSharpCodeProvider cprovider = new CSharpCodeProvider();
//当然换个Microsoft.VisualBasic.VBCodeProvider就产生VB.NET的代码
ICodeGenerator gen = cprovider.CreateGenerator();
// 也可以直接用字符串来存储源代码
StringBuilder sb = new StringBuilder();
StringWriter strW = new StringWriter(sb);
// 将源代码存储起来
gen.GenerateCodeFromCompileUnit(code, strW, new CodeGeneratorOptions());
return(sb.ToString());
}
private static void writeCode(CodeCompileUnit compileUnit)
{
//Create a code generator that can output VB source
CodeDomProvider provider = new VBCodeProvider();
ICodeGenerator generator = provider.CreateGenerator();
//Default options are file
CodeGeneratorOptions options = new CodeGeneratorOptions();
//Keep the output in memory
StringWriter output = new StringWriter();
//Build the code and display it
generator.GenerateCodeFromCompileUnit(compileUnit, output, options);
Console.WriteLine("\nThe following VB source was generated\n\n");
Console.WriteLine(output.ToString());
}
public String ToCodeFile(CodeCompileUnit compileunit, CodeDomProvider provider, string fileName)
{
#if NET2
String sourceFile;
if (provider.FileExtension[0] == '.')
{
sourceFile = fileName + provider.FileExtension;
}
else
{
sourceFile = fileName + "." + provider.FileExtension;
}
IndentedTextWriter tw = new IndentedTextWriter(
new StreamWriter(sourceFile, false), " ");
provider.GenerateCodeFromCompileUnit(compileunit, tw,
new CodeGeneratorOptions());
tw.Close();
return(sourceFile);
#else
ICodeGenerator gen = provider.CreateGenerator();
String sourceFile;
if (provider.FileExtension[0] == '.')
{
sourceFile = fileName + provider.FileExtension;
}
else
{
sourceFile = fileName + "." + provider.FileExtension;
}
IndentedTextWriter tw = new IndentedTextWriter(
new StreamWriter(sourceFile, false), " ");
gen.GenerateCodeFromCompileUnit(compileunit, tw,
new CodeGeneratorOptions());
tw.Close();
return(sourceFile);
#endif
}
public string GeneratorCode()
{
CSharpCodeProvider codeProvider = new CSharpCodeProvider();
ICodeGenerator codeGenerator = codeProvider.CreateGenerator();
StringBuilder generatedCode = new StringBuilder();
using (StringWriter codeWriter = new StringWriter(generatedCode))
{
CodeGeneratorOptions options = new CodeGeneratorOptions();
options.BracingStyle = "C";//Keep the braces on the line following the statement or declaration that they are associated with
codeGenerator.GenerateCodeFromCompileUnit(unit, codeWriter, options);
}
this._code = generatedCode.ToString();
return(_code);
}
//////////////////////////////////Генерация////////////////////////////////////
private static void GENERATE_CODE_SERVER(CodeDomProvider provider,
CodeCompileUnit compileunit)
{
String sourceFile;
///////////////Файл "TEST_CODEDOM.cs"//////////////////////////////////////
sourceFile = "TEST_CODEDOM." + provider.FileExtension;
/////////Получаем ICodeGenerator от CodeDomProvider////////////////////////
ICodeGenerator gen = provider.CreateGenerator();
///Создаем IndentedTextWriter, построенный с StreamWriter исходного кода///
IndentedTextWriter tw = new IndentedTextWriter(new StreamWriter(sourceFile,
false), " ");
//////Генерируем исходный код, используя кодо-генератор////////////////////
gen.GenerateCodeFromCompileUnit(compileunit, tw, new CodeGeneratorOptions());
//////////////////Закрываем выходной файл//////////////////////////////////
tw.Close();
}
public string Convert(XamlReader reader, CodeDomProvider cscProvider)
{
MainCodeClassName = string.Empty;
StringBuilder sb = new StringBuilder();
StringWriter stringWriter = new StringWriter(sb);
NamespacesToUse = new SortedDictionary <string, object>();
// TODO: XamlXmlReader can sometimes be null, if there is misformed XML in the first sections of XML
_schemaContext = reader != null ? reader.SchemaContext : new XamlSchemaContext();
CodeDomDomWriter codeDomDomWriter = new CodeDomDomWriter(_schemaContext);
// Load XAML into a specialized XAML DOM, for analysis and processing
Debug.WriteLine("Building codeDOM from XAML...");
while (reader.Read())
{
codeDomDomWriter.WriteNode(reader);
}
Debug.WriteLine("codeDOM complete.");
CodeDomObjectNode objectNode = (CodeDomObjectNode)codeDomDomWriter.Result;
//DumpNodeTree(objectNode);
// Initialize CodeDom constructs
ICodeGenerator cscg = cscProvider.CreateGenerator(stringWriter);
ccu = new CodeCompileUnit();
CodeNamespace cns = new CodeNamespace();
ccu.Namespaces.Add(cns);
// Go process XAML DOM
CodeMemberMethod initMethod = CreateInitializeMethod(cns, objectNode);
GenerateUsings(cns, objectNode);
CreateClass(cns, objectNode, initMethod);
AddPublicObjectMembers();
// Create code from codeDOM
cscg.GenerateCodeFromCompileUnit(ccu, stringWriter, new CodeGeneratorOptions());
string returnText = sb.ToString();
return(returnText);
}
static void Main()
{
Console.WriteLine("What string do you want the custom program to display?");
string message = Console.ReadLine();
Console.WriteLine("How many times do you want the program to display this message?");
int nDisplays = int.Parse(Console.ReadLine());
CodeCompileUnit unit = GenerateProgram(message, nDisplays);
// Set up options for source code style
CodeGeneratorOptions opts = new CodeGeneratorOptions();
opts.BracingStyle = "C";
opts.IndentString = "\t";
// Create code generators and write code files
CodeDomProvider[] providers = new CodeDomProvider[3];
providers[0] = new CSharpCodeProvider();
providers[1] = new VBCodeProvider();
providers[2] = new JScriptCodeProvider();
// providers[3] = new VJSharpCodeProvider();
string[] fileNames = { "MyCodeCS.cs", "MyCodeVB.vb", "MyCodeJS.js" };
for (int i = 0; i < providers.Length; i++)
{
ICodeGenerator gen = providers[i].CreateGenerator();
StreamWriter sw = new StreamWriter(fileNames[i]);
gen.GenerateCodeFromCompileUnit(unit, sw, opts);
sw.Close();
}
string[] assemblyFileNames = { "MyCodeCS.exe", "MyCodeVB.exe",
"MyCodeJS.exe" };
CompilerParameters compilerParams = new CompilerParameters();
compilerParams.GenerateExecutable = true;
for (int i = 0; i < providers.Length; i++)
{
ICodeCompiler compiler = providers[i].CreateCompiler();
compilerParams.OutputAssembly = assemblyFileNames[i];
compiler.CompileAssemblyFromFile(compilerParams, fileNames[i]);
}
}
/// <summary>
/// Constructor for the XsdGen class.
/// </summary>
/// <param name="args">Command-line arguments passed to the program.</param>
private XsdGen(string[] args)
{
this.ParseCommandlineArgs(args);
// show usage information
if (this.showHelp)
{
Console.WriteLine("usage: XsdGen.exe <schema>.xsd <outputFile> <namespace> [<commonNamespace>]");
return;
}
// ensure that the schema file exists
if (!File.Exists(this.xsdFile))
{
throw new ApplicationException(String.Format("Schema file does not exist: '{0}'.", this.xsdFile));
}
XmlSchema document = null;
using (StreamReader xsdFileReader = new StreamReader(this.xsdFile))
{
document = XmlSchema.Read(xsdFileReader, new ValidationEventHandler(this.ValidationHandler));
}
CodeCompileUnit codeCompileUnit = StronglyTypedClasses.Generate(document, this.outputNamespace, this.commonNamespace);
using (CSharpCodeProvider codeProvider = new CSharpCodeProvider())
{
ICodeGenerator generator = codeProvider.CreateGenerator();
CodeGeneratorOptions options = new CodeGeneratorOptions();
options.BlankLinesBetweenMembers = true;
options.BracingStyle = "C";
options.IndentString = " ";
using (StreamWriter csharpFileWriter = new StreamWriter(this.outFile))
{
generator.GenerateCodeFromCompileUnit(codeCompileUnit, csharpFileWriter, options);
}
}
}
///
/// <summary/>
///
void WriteCodeUnit(CodeCompileUnit codeUnit, string serviceName)
{
CodeDomProvider provider = GetProvider();
ICodeGenerator generator = provider.CreateGenerator();
CodeGeneratorOptions options = new CodeGeneratorOptions();
string filename;
if (outFilename != null)
{
filename = outFilename;
}
else
{
filename = serviceName + "." + provider.FileExtension;
}
Console.WriteLine("Writing file '{0}'", filename);
StreamWriter writer = new StreamWriter(filename);
generator.GenerateCodeFromCompileUnit(codeUnit, writer, options);
writer.Close();
}
/// <summary>
/// Generate the actual C# code.
/// </summary>
/// <param name="codeCompileUnit">The code DOM.</param>
/// <param name="destClassFile">Destination C# source file.</param>
public static void GenerateCSharpCode(CodeCompileUnit codeCompileUnit, string destClassFile)
{
// generate the code with the C# code provider
CSharpCodeProvider provider = new CSharpCodeProvider();
// obtain an ICodeGenerator from the CodeDomProvider class
ICodeGenerator gen = provider.CreateGenerator();
// create a TextWriter to a StreamWriter to the output file
using (StreamWriter sw = new StreamWriter(destClassFile))
{
using (IndentedTextWriter tw = new IndentedTextWriter(sw, " "))
{
CodeGeneratorOptions options = new CodeGeneratorOptions();
// code generation options
options.BlankLinesBetweenMembers = true;
options.BracingStyle = "C";
// generate source code using the code generator
gen.GenerateCodeFromCompileUnit(codeCompileUnit, tw, options);
}
}
}
private void GenerateCode(ServiceDescriptionCollection sources, XmlSchemas schemas, string uriToWSDL,
ICodeGenerator codeGen, string fileExtension)
{
proxyCode = " <ERROR> ";
StringWriter writer1 = null;
compileUnit = new CodeCompileUnit();
ServiceDescriptionImporter importer1 = new ServiceDescriptionImporter();
importer1.Schemas.Add(schemas);
foreach (ServiceDescription description1 in sources)
{
importer1.AddServiceDescription(description1, "", "");
}
importer1.Style = ServiceDescriptionImportStyle.Client;
Protocol protocol1 = WsdlProperties.Protocol;
importer1.ProtocolName = WsdlProperties.Protocol.ToString();
CodeNamespace namespace1 = new CodeNamespace(proxyNamespace);
compileUnit.Namespaces.Add(namespace1);
ServiceDescriptionImportWarnings warnings1 = importer1.Import(namespace1, compileUnit);
try
{
try
{
writer1 = new StringWriter();
}
catch
{
throw;
}
MemoryStream stream1 = null;
if (schemas.Count > 0)
{
compileUnit.ReferencedAssemblies.Add("System.Data.dll");
foreach (XmlSchema schema1 in schemas)
{
string text1 = null;
try
{
text1 = schema1.TargetNamespace;
if (XmlSchemas.IsDataSet(schema1))
{
if (stream1 == null)
{
stream1 = new MemoryStream();
}
stream1.Position = 0;
stream1.SetLength((long) 0);
schema1.Write(stream1);
stream1.Position = 0;
DataSet set1 = new DataSet();
set1.ReadXmlSchema(stream1);
TypedDataSetGenerator.Generate(set1, namespace1, codeGen);
}
continue;
}
catch
{
throw;
}
}
}
try
{
GenerateVersionComment(compileUnit.Namespaces[0]);
ChangeBaseType(compileUnit);
codeGen.GenerateCodeFromCompileUnit(compileUnit, writer1, null);
}
catch (Exception exception1)
{
if (writer1 != null)
{
writer1.Write("Exception in generating code");
writer1.Write(exception1.Message);
}
throw new InvalidOperationException("Error generating ", exception1);
}
}
finally
{
proxyCode = writer1.ToString();
if (writer1 != null)
{
writer1.Close();
}
}
}
public string Generate(ICodeGenerator codeGen)
{
StringWriter writer1 = new StringWriter();
codeGen.GenerateCodeFromCompileUnit(compileUnit, writer1, null);
return writer1.ToString();
}
void ImportSchemasAsClasses(
string outputdir,
ICodeGenerator codeGen,
string fileExtension,
IList fileNames,
string ns,
string uri,
IList elements) {
XmlSchemas schemasToCompile = new XmlSchemas();
XmlSchemas userSchemas = new XmlSchemas();
string outputSchemaName = "";
// Create parent schema
XmlSchema parent = new XmlSchema();
foreach (string fileName in fileNames) {
schemasToCompile.Add(ReadSchema(fileName, false));
userSchemas.Add(ReadSchema(fileName, true));
outputSchemaName += Path.ChangeExtension(fileName,"").Replace('.','_');
}
Hashtable includeSchemas = new Hashtable();
foreach (XmlSchema schema in schemasToCompile) {
CollectIncludes(schema, includeSchemas, false);
}
Compile(schemasToCompile);
includeSchemas = new Hashtable();
foreach (XmlSchema schema in userSchemas) {
CollectIncludes(schema, includeSchemas, true);
}
try {
outputSchemaName = outputSchemaName.Substring(0, outputSchemaName.Length - 1);
XmlSchemaImporter schemaImporter = new XmlSchemaImporter(userSchemas);
CodeCompileUnit codeCompileUnit = new CodeCompileUnit();
CodeNamespace codeNamespace = new CodeNamespace(ns);
codeCompileUnit.Namespaces.Add(codeNamespace);
GenerateVersionComment(codeNamespace);
XmlCodeExporter codeExporter = new XmlCodeExporter(codeNamespace, codeCompileUnit);
AddImports(codeNamespace, GetNamespacesForTypes(new Type[] { typeof(XmlAttributeAttribute) }));
for (int i = 0; i < userSchemas.Count; i++) {
XmlSchema schema = userSchemas[i];
for (int j = 0; j < schema.Items.Count; j++) {
object item = schema.Items[j];
if (item is XmlSchemaElement) {
XmlSchemaElement element = (XmlSchemaElement)item;
if (!element.IsAbstract) {
if (uri.Length == 0 ||
schema.TargetNamespace == uri) {
bool found;
if (elements.Count == 0) {
found = true;
}
else {
found = false;
foreach (string e in elements) {
if (e == element.Name) {
found = true;
break;
}
}
}
if (found) {
XmlTypeMapping xmlTypeMapping = schemaImporter.ImportTypeMapping(new XmlQualifiedName(element.Name, schema.TargetNamespace));
codeExporter.ExportTypeMapping(xmlTypeMapping);
}
}
}
}
}
}
CodeTypeDeclarationCollection classes = codeNamespace.Types;
if (classes == null || classes.Count == 0) {
Console.WriteLine(Res.GetString(Res.NoClassesGenerated));
}
else {
TextWriter writer = CreateOutputWriter(outputdir, outputSchemaName, fileExtension);
codeGen.GenerateCodeFromCompileUnit(codeCompileUnit, writer, null);
writer.Close();
}
}
catch (Exception e) {
throw new InvalidOperationException(Res.GetString(Res.ErrGenerateClassesForSchema, outputSchemaName), e);
}
}
private static void SaveCompileUnit(ICodeGenerator codegen, CodeCompileUnit cu, string fileName)
{
try
{
try
{
if (File.Exists(fileName))
{
File.Delete(fileName);
}
}
catch
{
}
FileStream stream = new FileStream(fileName, FileMode.OpenOrCreate, FileAccess.ReadWrite);
StreamWriter w = new StreamWriter(stream, new UTF8Encoding(false));
codegen.GenerateCodeFromCompileUnit(cu, w, null);
w.Flush();
w.Close();
stream.Close();
GeneratedSources.Add(fileName);
}
catch (Exception)
{
}
}
public static string CreateCode(
Type proxyType,
ICodeGenerator generator,
XmlRpcProxyCodeGenOptions options)
{
if (options == null)
{
throw new ArgumentNullException(
"options",
"The options parameter cannot be null");
}
CodeCompileUnit ccu = CreateCodeCompileUnit(proxyType, options);
var cgo = new CodeGeneratorOptions();
cgo.BlankLinesBetweenMembers = true;
cgo.BracingStyle = "C";
using (var sw = new StringWriter(CultureInfo.InvariantCulture))
{
generator.GenerateCodeFromCompileUnit(ccu, sw, cgo);
return sw.ToString();
}
}
private void GenerateCode(ServiceDescriptionCollection sources, XmlSchemas schemas, string uriToWSDL, ICodeGenerator codeGen, string fileExtension)
{
this.proxyCode = " <ERROR> ";
StringWriter w = null;
this.compileUnit = new CodeCompileUnit();
ServiceDescriptionImporter importer = new ServiceDescriptionImporter();
importer.Schemas.Add(schemas);
foreach (ServiceDescription description in sources)
{
importer.AddServiceDescription(description, "", "");
}
importer.Style = ServiceDescriptionImportStyle.Client;
Protocol protocol = this.WsdlProperties.Protocol;
importer.ProtocolName = this.WsdlProperties.Protocol.ToString();
CodeNamespace namespace2 = new CodeNamespace(this.proxyNamespace);
this.compileUnit.Namespaces.Add(namespace2);
ServiceDescriptionImportWarnings warnings = importer.Import(namespace2, this.compileUnit);
try
{
try
{
w = new StringWriter();
}
catch
{
throw;
}
MemoryStream stream = null;
if (schemas.Count > 0)
{
this.compileUnit.ReferencedAssemblies.Add("System.Data.dll");
foreach (XmlSchema schema in schemas)
{
string targetNamespace = null;
try
{
targetNamespace = schema.TargetNamespace;
if (XmlSchemas.IsDataSet(schema))
{
if (stream == null)
{
stream = new MemoryStream();
}
stream.Position = 0L;
stream.SetLength(0L);
schema.Write(stream);
stream.Position = 0L;
DataSet dataSet = new DataSet();
dataSet.ReadXmlSchema(stream);
TypedDataSetGenerator.Generate(dataSet, namespace2, codeGen);
}
continue;
}
catch
{
throw;
}
}
}
try
{
GenerateVersionComment(this.compileUnit.Namespaces[0]);
this.ChangeBaseType(this.compileUnit);
codeGen.GenerateCodeFromCompileUnit(this.compileUnit, w, null);
}
catch (Exception exception)
{
if (w != null)
{
w.Write("Exception in generating code");
w.Write(exception.Message);
}
throw new InvalidOperationException("Error generating ", exception);
}
}
finally
{
this.proxyCode = w.ToString();
if (w != null)
{
w.Close();
}
}
}
public string Generate(ICodeGenerator codeGen)
{
StringWriter w = new StringWriter();
codeGen.GenerateCodeFromCompileUnit(this.compileUnit, w, null);
return w.ToString();
}
