|
public ExportTypeMapping ( |
||
| xmlTypeMapping | ||
| Résultat | void | |
public static CodeNamespace GenerateCode(Stream schemaStream, string classesNamespace)
{
// Open schema
XmlSchema schema = XmlSchema.Read(schemaStream, null);
XmlSchemas schemas = new XmlSchemas();
schemas.Add(schema);
schemas.Compile(null, true);
// Generate code
CodeNamespace code = new CodeNamespace(classesNamespace);
XmlSchemaImporter importer = new XmlSchemaImporter(schemas);
XmlCodeExporter exporter = new XmlCodeExporter(code);
foreach (XmlSchemaElement element in schema.Elements.Values) {
XmlTypeMapping mapping = importer.ImportTypeMapping(element.QualifiedName);
exporter.ExportTypeMapping(mapping);
}
// Modify generated code using extensions
schemaStream.Position = 0; // Rewind stream to the start
XPathDocument xPathDoc = new XPathDocument(schemaStream);
CodeGenerationContext context = new CodeGenerationContext(code, schema, xPathDoc);
new ExplicitXmlNamesExtension().ApplyTo(context);
new DocumentationExtension().ApplyTo(context);
new FixXmlTextAttributeExtension().ApplyTo(context);
new ArraysToGenericExtension().ApplyTo(context);
new CamelCaseExtension().ApplyTo(context);
new GetByIDExtension().ApplyTo(context);
return code;
}
public static CodeNamespace Process(string xsdFile,
string targetNamespace)
{
// Load the XmlSchema and its collection.
XmlSchema xsd;
using (FileStream fs = new FileStream("Untitled1.xsd", FileMode.Open))
{
xsd = XmlSchema.Read(fs, null);
xsd.Compile(null);
}
XmlSchemas schemas = new XmlSchemas();
schemas.Add(xsd);
// Create the importer for these schemas.
XmlSchemaImporter importer = new XmlSchemaImporter(schemas);
// System.CodeDom namespace for the XmlCodeExporter to put classes in.
CodeNamespace ns = new CodeNamespace(targetNamespace);
XmlCodeExporter exporter = new XmlCodeExporter(ns);
// Iterate schema top-level elements and export code for each.
foreach (XmlSchemaElement element in xsd.Elements.Values)
{
// Import the mapping first.
XmlTypeMapping mapping = importer.ImportTypeMapping(
element.QualifiedName);
// Export the code finally.
exporter.ExportTypeMapping(mapping);
}
return ns;
}
public static void GenerateCode(string xsdFilepath, string codeOutPath, string nameSpace)
{
FileStream stream = File.OpenRead(xsdFilepath);
XmlSchema xsd = XmlSchema.Read(stream, ValidationCallbackOne);
// Remove namespaceattribute from schema
xsd.TargetNamespace = null;
XmlSchemas xsds = new XmlSchemas { xsd };
XmlSchemaImporter imp = new XmlSchemaImporter(xsds);
//imp.Extensions.Add(new CustomSchemaImporterExtension());
CodeNamespace ns = new CodeNamespace(nameSpace);
XmlCodeExporter exp = new XmlCodeExporter(ns);
foreach (XmlSchemaObject item in xsd.Items)
{
if (!(item is XmlSchemaElement))
continue;
XmlSchemaElement xmlSchemaElement = (XmlSchemaElement)item;
XmlQualifiedName xmlQualifiedName = new XmlQualifiedName(xmlSchemaElement.Name, xsd.TargetNamespace);
XmlTypeMapping map = imp.ImportTypeMapping(xmlQualifiedName);
exp.ExportTypeMapping(map);
}
// Remove all the attributes from each type in the CodeNamespace, except
// System.Xml.Serialization.XmlTypeAttribute
RemoveAttributes(ns);
ToProperties(ns);
CodeCompileUnit compileUnit = new CodeCompileUnit();
compileUnit.Namespaces.Add(ns);
CSharpCodeProvider provider = new CSharpCodeProvider();
using (StreamWriter sw = new StreamWriter(codeOutPath, false))
{
CodeGeneratorOptions codeGeneratorOptions = new CodeGeneratorOptions();
provider.GenerateCodeFromCompileUnit(compileUnit, sw, codeGeneratorOptions);
}
}
private static void GenerateClasses(CodeNamespace code, XmlSchema schema)
{
XmlSchemas schemas = new XmlSchemas();
schemas.Add(schema);
XmlSchemaImporter importer = new XmlSchemaImporter(schemas);
CodeCompileUnit codeCompileUnit = new CodeCompileUnit();
CodeGenerationOptions options = CodeGenerationOptions.None;
XmlCodeExporter exporter = new XmlCodeExporter(code, codeCompileUnit, options);
foreach (XmlSchemaObject item in schema.Items)
{
XmlSchemaElement element = item as XmlSchemaElement;
if (element != null)
{
XmlQualifiedName name = new XmlQualifiedName(element.Name, schema.TargetNamespace);
XmlTypeMapping map = importer.ImportTypeMapping(name);
exporter.ExportTypeMapping(map);
}
}
}
private CodeNamespace GeneratedClassFromStream(Stream stream, string nameSpace)
{
XmlSchema xsd;
stream.Seek(0, SeekOrigin.Begin);
using (stream)
{
xsd = XmlSchema.Read(stream, null);
}
XmlSchemas xsds = new XmlSchemas();
xsds.Add(xsd);
xsds.Compile(null, true);
XmlSchemaImporter schemaImporter = new XmlSchemaImporter(xsds);
// create the codedom
CodeNamespace codeNamespace = new CodeNamespace(nameSpace);
XmlCodeExporter codeExporter = new XmlCodeExporter(codeNamespace);
List<XmlTypeMapping> maps = new List<XmlTypeMapping>();
foreach (XmlSchemaType schemaType in xsd.SchemaTypes.Values)
{
maps.Add(schemaImporter.ImportSchemaType(schemaType.QualifiedName));
}
foreach (XmlSchemaElement schemaElement in xsd.Elements.Values)
{
maps.Add(schemaImporter.ImportTypeMapping(schemaElement.QualifiedName));
}
foreach (XmlTypeMapping map in maps)
{
codeExporter.ExportTypeMapping(map);
}
this.RemoveUnusedStuff(codeNamespace);
return codeNamespace;
}
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 static CodeNamespace Process(string xsdSchema, string targetNamespace)
{
// Load the XmlSchema and its collection.
XmlSchema xsd;
using (var fs = new StringReader(xsdSchema))
{
xsd = XmlSchema.Read(fs, null);
xsd.Compile(null);
}
XmlSchemas schemas = new XmlSchemas();
schemas.Add(xsd);
// Create the importer for these schemas.
XmlSchemaImporter importer = new XmlSchemaImporter(schemas);
// System.CodeDom namespace for the XmlCodeExporter to put classes in.
CodeNamespace ns = new CodeNamespace(targetNamespace);
XmlCodeExporter exporter = new XmlCodeExporter(ns);
// Iterate schema top-level elements and export code for each.
foreach (XmlSchemaElement element in xsd.Elements.Values)
{
// Import the mapping first.
XmlTypeMapping mapping = importer.ImportTypeMapping(
element.QualifiedName);
// Export the code finally.
exporter.ExportTypeMapping(mapping);
}
// execute extensions
//var collectionsExt = new ArraysToCollectionsExtension();
//collectionsExt.Process(ns, xsd);
//var filedsExt = new FieldsToPropertiesExtension();
//filedsExt.Process(ns, xsd);
return ns;
}
/// <summary>
/// Generates the data contracts for given xsd file(s).
/// </summary>
public CodeNamespace GenerateCode()
{
CodeCompileUnit codeCompileUnit = new CodeCompileUnit();
CodeNamespace codeNamespace = new CodeNamespace(options.ClrNamespace);
codeCompileUnit.Namespaces.Add(codeNamespace);
// Build the code generation options.
GenerationOptions generationOptions = GenerationOptions.None;
if (options.GenerateProperties)
{
generationOptions |= GenerationOptions.GenerateProperties;
}
if (options.EnableDataBinding)
{
generationOptions |= GenerationOptions.EnableDataBinding;
}
if (options.GenerateOrderIdentifiers)
{
generationOptions |= GenerationOptions.GenerateOrder;
}
// Build the CodeDom object graph.
XmlCodeExporter codeExporter = new XmlCodeExporter(codeNamespace, codeCompileUnit, generationOptions, null);
CodeIdentifiers codeIdentifiers = new CodeIdentifiers();
ImportContext importContext = new ImportContext(codeIdentifiers, false);
XmlSchemaImporter schemaimporter = new XmlSchemaImporter(schemas, generationOptions, codeProvider, importContext);
for (int si = 0; si < schemas.Count; si++)
{
XmlSchema schema = schemas[si];
IEnumerator enumerator = schema.Elements.Values.GetEnumerator();
IEnumerator enumerator2 = schema.SchemaTypes.Values.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
XmlSchemaElement element = (XmlSchemaElement)enumerator.Current;
if (element.IsAbstract) continue;
XmlTypeMapping typemapping = schemaimporter.ImportTypeMapping(element.QualifiedName);
codeExporter.ExportTypeMapping(typemapping);
}
while (enumerator2.MoveNext())
{
XmlSchemaType type = (XmlSchemaType)enumerator2.Current;
if (CouldBeAnArray(type)) continue;
XmlTypeMapping typemapping = schemaimporter.ImportSchemaType(type.QualifiedName);
codeExporter.ExportTypeMapping(typemapping);
}
}
finally
{
IDisposable disposableobject = enumerator as IDisposable;
if (disposableobject != null)
{
disposableobject.Dispose();
}
IDisposable disposableobject2 = enumerator2 as IDisposable;
if (disposableobject2 != null)
{
disposableobject2.Dispose();
}
}
}
if (codeNamespace.Types.Count == 0)
{
throw new Exception("No types were generated.");
}
return codeNamespace;
}
public void Generate(Stream xsdInput, TextWriter output)
{
if (Options == null)
Options = new XsdCodeGeneratorOptions
{
UseLists = true,
CapitalizeProperties = true,
StripDebuggerStepThroughAttribute = true,
OutputNamespace = "Xsd2",
UseNullableTypes = true
};
if (Options.Imports != null)
{
foreach (var import in Options.Imports)
{
if (File.Exists(import))
{
ImportImportedSchema(import);
}
else if (Directory.Exists(import))
{
foreach (var file in Directory.GetFiles("*.xsd"))
ImportImportedSchema(file);
}
else
{
throw new InvalidOperationException(String.Format("Import '{0}' is not a file nor a directory.", import));
}
}
}
XmlSchema xsd = XmlSchema.Read(xsdInput, null);
xsds.Add(xsd);
xsds.Compile(null, true);
XmlSchemaImporter schemaImporter = new XmlSchemaImporter(xsds);
// create the codedom
CodeNamespace codeNamespace = new CodeNamespace(Options.OutputNamespace);
XmlCodeExporter codeExporter = new XmlCodeExporter(codeNamespace);
List<XmlTypeMapping> maps = new List<XmlTypeMapping>();
foreach (XmlSchemaElement schemaElement in xsd.Elements.Values)
{
if (!ElementBelongsToImportedSchema(schemaElement))
maps.Add(schemaImporter.ImportTypeMapping(schemaElement.QualifiedName));
}
foreach (XmlSchemaComplexType schemaElement in xsd.Items.OfType<XmlSchemaComplexType>())
{
maps.Add(schemaImporter.ImportSchemaType(schemaElement.QualifiedName));
}
foreach (XmlSchemaSimpleType schemaElement in xsd.Items.OfType<XmlSchemaSimpleType>())
{
maps.Add(schemaImporter.ImportSchemaType(schemaElement.QualifiedName));
}
foreach (XmlTypeMapping map in maps)
{
codeExporter.ExportTypeMapping(map);
}
ImproveCodeDom(codeNamespace, xsd);
if (OnValidateGeneratedCode != null)
OnValidateGeneratedCode(codeNamespace, xsd);
// Check for invalid characters in identifiers
CodeGenerator.ValidateIdentifiers(codeNamespace);
// output the C# code
CSharpCodeProvider codeProvider = new CSharpCodeProvider();
codeProvider.GenerateCodeFromNamespace(codeNamespace, output, new CodeGeneratorOptions());
}
public void ImportWildcardElementAsClass ()
{
var xss = new XmlSchemas ();
xss.Add (XmlSchema.Read (XmlReader.Create ("Test/XmlFiles/xsd/670945-1.xsd"), null));
xss.Add (XmlSchema.Read (XmlReader.Create ("Test/XmlFiles/xsd/670945-2.xsd"), null));
var imp = new XmlSchemaImporter (xss);
var xtm = imp.ImportSchemaType (new XmlQualifiedName ("SystemDateTime", "http://www.onvif.org/ver10/schema"));
var cns = new CodeNamespace ();
var exp = new XmlCodeExporter (cns);
exp.ExportTypeMapping (xtm);
var sw = new StringWriter ();
new CSharpCodeProvider ().GenerateCodeFromNamespace (cns, sw, null);
Assert.IsTrue (sw.ToString ().IndexOf ("class SystemDateTimeExtension") > 0, "#1");
}
public void ImportComplexDerivationByExtension ()
{
string xsd = @"<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema'>
<xs:element name='Root' type='DerivedType' />
<xs:complexType name='DerivedType'>
<xs:complexContent>
<xs:extension base='BaseType'>
<xs:attribute name='Foo' type='xs:string' />
</xs:extension>
</xs:complexContent>
</xs:complexType>
<xs:complexType name='BaseType'>
<xs:attribute name='Foo' type='xs:string' />
</xs:complexType>
</xs:schema>";
XmlSchemaImporter imp = CreateImporter (xsd);
CodeNamespace cns = new CodeNamespace ();
XmlCodeExporter exp = new XmlCodeExporter (cns);
exp.ExportTypeMapping (imp.ImportTypeMapping (new XmlQualifiedName ("Root")));
}
public void DefaultTypeTopLevelElementImportsAllComplexTypes ()
{
string xsd = @"
<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema'>
<xs:element name='Root' />
<xs:complexType name='FooType'>
<xs:sequence>
<xs:element name='Child1' type='xs:string' />
<xs:element name='Child2' type='xs:string' />
<xs:element name='Child3' type='xs:string' />
</xs:sequence>
</xs:complexType>
<xs:complexType name='BarType' />
</xs:schema>";
XmlSchemas xss = new XmlSchemas ();
xss.Add (XmlSchema.Read (new XmlTextReader (new StringReader (xsd)), null));
XmlSchemaImporter imp = new XmlSchemaImporter (xss);
CodeNamespace cns = new CodeNamespace ();
XmlCodeExporter exp = new XmlCodeExporter (cns);
exp.ExportTypeMapping (imp.ImportTypeMapping (new XmlQualifiedName ("Root")));
bool foo = false, bar = false;
foreach (CodeTypeDeclaration td in cns.Types) {
if (td.Name == "FooType")
foo = true;
else if (td.Name == "BarType")
bar = true;
}
Assert.IsTrue (foo, "FooType not found");
Assert.IsTrue (bar, "BarType not found");
}
CodeNamespace ExportCode (XmlTypeMapping map)
{
CodeNamespace codeNamespace = new CodeNamespace ();
XmlCodeExporter exp = new XmlCodeExporter (codeNamespace);
exp.ExportTypeMapping (map);
return codeNamespace;
}
/// <summary>
/// Generate code for the elements in the Schema
/// </summary>
/// <param name="xsd"></param>
/// <param name="importer"></param>
/// <param name="exporter"></param>
private void GenerateForElements(
XmlSchema xsd,
XmlSchemaImporter importer,
XmlCodeExporter exporter)
{
foreach (XmlSchemaElement element in xsd.Elements.Values)
{
Trace.TraceInformation("Generating for element: {0}", element.Name);
try
{
XmlTypeMapping mapping = importer.ImportTypeMapping(element.QualifiedName);
exporter.ExportTypeMapping(mapping);
}
catch (Exception ex)
{
Trace.TraceEvent(TraceEventType.Error, 10, ex.ToString());
}
}
}
public void ExportSimpleContentExtensionEnum ()
{
string xsd = @"
<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema' xmlns:b='urn:bar' targetNamespace='urn:bar'>
<xs:element name='Foo' type='b:DayOfWeek' />
<xs:complexType name='DayOfWeek'>
<xs:simpleContent>
<xs:extension base='b:WeekDay' />
</xs:simpleContent>
</xs:complexType>
<xs:simpleType name='WeekDay'>
<xs:restriction base='xs:string'>
<xs:enumeration value='Sunday'/>
<xs:enumeration value='Monday'/>
<xs:enumeration value='Tuesday'/>
<xs:enumeration value='Wednesday'/>
<xs:enumeration value='Thursday'/>
<xs:enumeration value='Friday'/>
<xs:enumeration value='Saturday'/>
</xs:restriction>
</xs:simpleType>
</xs:schema>";
XmlSchema xs = XmlSchema.Read (new StringReader (xsd), null);
XmlSchemas xss = new XmlSchemas ();
xss.Add (xs);
XmlSchemaImporter imp = new XmlSchemaImporter (xss);
XmlTypeMapping m = imp.ImportTypeMapping (new XmlQualifiedName ("Foo", "urn:bar"));
CodeNamespace cns = new CodeNamespace ();
XmlCodeExporter exp = new XmlCodeExporter (cns);
exp.ExportTypeMapping (m);
CodeTypeDeclaration enumType = null;
foreach (CodeTypeDeclaration ctd in cns.Types)
if (ctd.Name == "WeekDay")
enumType = ctd;
Assert.IsNotNull (enumType);
}
/// <summary>
/// Initiate code generation process
/// </summary>
/// <param name="generatorParams">Generator parameters</param>
/// <returns></returns>
internal static Result<CodeNamespace> Process(GeneratorParams generatorParams)
{
var ns = new CodeNamespace();
XmlReader reader = null;
try
{
#region Set generation context
GeneratorContext.GeneratorParams = generatorParams;
#endregion
#region Get XmlTypeMapping
XmlSchema xsd;
var schemas = new XmlSchemas();
reader = XmlReader.Create(generatorParams.InputFilePath);
xsd = XmlSchema.Read(reader, new ValidationEventHandler(Validate));
var schemaSet = new XmlSchemaSet();
schemaSet.Add(xsd);
schemaSet.Compile();
foreach (XmlSchema schema in schemaSet.Schemas())
{
schemas.Add(schema);
}
var exporter = new XmlCodeExporter(ns);
var generationOptions = CodeGenerationOptions.None;
if (generatorParams.Serialization.GenerateOrderXmlAttributes)
{
generationOptions = CodeGenerationOptions.GenerateOrder;
}
var importer = new XmlSchemaImporter(schemas, generationOptions, new ImportContext(new CodeIdentifiers(), false));
foreach (XmlSchemaElement element in xsd.Elements.Values)
{
var mapping = importer.ImportTypeMapping(element.QualifiedName);
exporter.ExportTypeMapping(mapping);
}
//Fixes/handles http://xsd2code.codeplex.com/WorkItem/View.aspx?WorkItemId=6941
foreach (XmlSchemaType type in xsd.Items.OfType<XmlSchemaType>())
{
var mapping = importer.ImportSchemaType(type.QualifiedName);
exporter.ExportTypeMapping(mapping);
}
#endregion
#region Execute extensions
var getExtensionResult = GeneratorFactory.GetCodeExtension(generatorParams);
if (!getExtensionResult.Success) return new Result<CodeNamespace>(ns, false, getExtensionResult.Messages);
var ext = getExtensionResult.Entity;
ext.Process(ns, xsd);
#endregion Execute extensions
return new Result<CodeNamespace>(ns, true);
}
catch (Exception e)
{
return new Result<CodeNamespace>(ns, false, e.Message, MessageType.Error);
}
finally
{
if (reader != null)
reader.Close();
}
}
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);
}
}
public ObjectCollection GenerateClasses(XmlSchema schema)
{
#region Generate the CodeDom from the XSD
CodeNamespace codeNamespace = new CodeNamespace("TestNameSpace");
XmlSchemas xmlSchemas = new XmlSchemas();
xmlSchemas.Add(schema);
XmlSchemaImporter schemaImporter = new XmlSchemaImporter(xmlSchemas);
XmlCodeExporter codeExporter = new XmlCodeExporter(
codeNamespace,
new CodeCompileUnit(),
CodeGenerationOptions.GenerateProperties);
foreach (XmlSchemaElement element in schema.Elements.Values)
{
try
{
XmlTypeMapping map = schemaImporter.ImportTypeMapping(element.QualifiedName);
codeExporter.ExportTypeMapping(map);
}
catch (Exception ex)
{
throw new Exception("Error Loading Schema: ", ex);
}
}
#endregion
#region Modify the CodeDom
foreach (ICodeModifier codeModifier in m_codeModifiers)
codeModifier.Execute(codeNamespace);
#endregion
#region Generate the code
CodeCompileUnit compileUnit = new CodeCompileUnit();
compileUnit.Namespaces.Add(codeNamespace);
CodeDomProvider provider = CodeDomProvider.CreateProvider("CSharp");
#if DEBUG
StringWriter sw = new StringWriter();
CodeGeneratorOptions options = new CodeGeneratorOptions();
options.VerbatimOrder = true;
provider.GenerateCodeFromCompileUnit(compileUnit, sw, options);
m_codeString = sw.ToString();
#endif
#endregion
#region Compile an assembly
CompilerParameters compilerParameters = new CompilerParameters();
#region add references to assemblies
// reference for
// System.CodeDom.Compiler
// System.CodeDom
// System.Diagnostics
compilerParameters.ReferencedAssemblies.Add("System.dll");
compilerParameters.ReferencedAssemblies.Add("mscorlib.dll");
// System.Xml
compilerParameters.ReferencedAssemblies.Add("system.xml.dll");
// reference to this assembly for the custom collection editor
compilerParameters.ReferencedAssemblies.Add(Assembly.GetExecutingAssembly().Location);
compilerParameters.ReferencedAssemblies.Add("System.Drawing.dll");
// System.ComponentModel
#endregion
compilerParameters.GenerateExecutable = false;
compilerParameters.GenerateInMemory = true;
CompilerResults results = provider.CompileAssemblyFromDom(compilerParameters, new CodeCompileUnit[] { compileUnit });
// handle the errors if there are any
if (results.Errors.HasErrors)
{
m_errorStrings = new StringCollection();
m_errorStrings.Add("Error compiling assembly:\r\n");
foreach (CompilerError error in results.Errors)
m_errorStrings.Add(error.ErrorText + "\r\n");
return null;
}
#endregion
#region Find the exported classes
Assembly assembly = results.CompiledAssembly;
Type[] exportedTypes = assembly.GetExportedTypes();
// try to create an instance of the exported types
ObjectCollection objectCollection = new ObjectCollection();
objectCollection.Clear();
foreach (Type type in exportedTypes)
{
object obj = Activator.CreateInstance(type);
objectCollection.Add(new ObjectItem(type.Name, obj));
}
#endregion
return objectCollection;
}
public Program(params string[] args)
{
XmlSchemas xsds = new XmlSchemas();
var i = 0;
while (!args[i].StartsWith("/o:") || i >= args.Length)
{
xsds.Add(GetSchema(args[i]));
i++;
}
var output = string.Empty;
if (args[i].StartsWith("/o:"))
{
output = args[i].Substring(3);
}
xsds.Compile(null, true);
XmlSchemaImporter schemaImporter = new XmlSchemaImporter(xsds, CodeGenerationOptions.GenerateOrder, null);
// create the codedom
var codeNamespace = new CodeNamespace("QbSync.QbXml.Objects");
codeNamespace.Imports.Add(new CodeNamespaceImport("System"));
codeNamespace.Imports.Add(new CodeNamespaceImport("System.Collections.Generic"));
codeNamespace.Imports.Add(new CodeNamespaceImport("System.Linq"));
CodeCompileUnit compileUnit = new CodeCompileUnit();
compileUnit.Namespaces.Add(codeNamespace);
var codeExporter = new XmlCodeExporter(codeNamespace, compileUnit, CodeGenerationOptions.GenerateProperties | CodeGenerationOptions.GenerateOrder);
foreach (XmlSchema xsd in xsds)
{
ArrayList maps = new ArrayList();
foreach (XmlSchemaType schemaType in xsd.SchemaTypes.Values)
{
maps.Add(schemaImporter.ImportSchemaType(schemaType.QualifiedName));
}
foreach (XmlSchemaElement schemaElement in xsd.Elements.Values)
{
maps.Add(schemaImporter.ImportTypeMapping(schemaElement.QualifiedName));
}
foreach (XmlTypeMapping map in maps)
{
codeExporter.ExportTypeMapping(map);
}
}
var typeEnhancer = new TypeEnhancer(codeNamespace, xsds);
typeEnhancer.Enhance();
// Add a comment at the top of the file
var x = fileComment.Split('\n').Select(m => new CodeCommentStatement(m)).ToArray();
codeNamespace.Comments.AddRange(x);
// Check for invalid characters in identifiers
CodeGenerator.ValidateIdentifiers(codeNamespace);
// output the C# code
CSharpCodeProvider codeProvider = new CSharpCodeProvider();
using (StringWriter writer = new StringWriter())
{
codeProvider.GenerateCodeFromNamespace(codeNamespace, writer, new CodeGeneratorOptions
{
BlankLinesBetweenMembers = true,
BracingStyle = "C",
ElseOnClosing = true,
IndentString = " "
});
string content = writer.GetStringBuilder().ToString();
if (string.IsNullOrEmpty(output))
{
Console.WriteLine(content);
Console.ReadLine();
}
else
{
File.WriteAllText(output, content);
}
}
}
private CodeCompileUnit GenerateTypesWithXmlSchemaImporter(XmlSchemaSet schemas)
{
CodeNamespace ns = new CodeNamespace(this.targetNamespace);
CodeCompileUnit unit = new CodeCompileUnit();
unit.Namespaces.Add(ns);
schemas.ValidationEventHandler += this.validationEventHandler;
try
{
// Validate schemas
schemas.Compile();
XmlSchemas xsds = new XmlSchemas();
foreach (XmlSchema xsd in schemas.Schemas())
{
xsds.Add(xsd);
}
foreach (XmlSchema schema in xsds)
{
XmlSchemaImporter importer = new XmlSchemaImporter(xsds);
XmlCodeExporter exporter = new XmlCodeExporter(ns, unit);
// export only elements
foreach (XmlSchemaElement schemaElement in schema.Elements.Values)
{
exporter.ExportTypeMapping(importer.ImportTypeMapping(schemaElement.QualifiedName));
}
CodeGenerator.ValidateIdentifiers(ns);
}
}
catch (ArgumentException argumentException)
{
throw new InvalidOperationException(argumentException.Message, argumentException.InnerException);
}
finally
{
schemas.ValidationEventHandler -= this.validationEventHandler;
}
return unit;
}
/// <summary>
/// Imports XML type definitions as .NET classes.
/// </summary>
/// <param name="schema">Compiled XML schema.</param>
/// <param name="schemaImporter">XML Schema Importer.</param>
/// <param name="codeExporter">XML Code Exporter.</param>
/// <param name="namespace">Namespace where .NET classes are generated.</param>
private static void ImportSchemaAsClasses(XmlSchema schema, XmlSchemaImporter schemaImporter, XmlCodeExporter codeExporter, CodeNamespace @namespace)
{
foreach (XmlSchemaElement element in schema.Elements.Values)
{
if (!element.IsAbstract)
{
XmlTypeMapping xmlTypeMapping = schemaImporter.ImportTypeMapping(element.QualifiedName);
codeExporter.ExportTypeMapping(xmlTypeMapping);
GenerateLoadMethod(xmlTypeMapping, @namespace);
}
}
}
private CodeNamespace GenerateSchemaTypes()
{
CodeNamespace cns = new CodeNamespace();
// add the schemas to a Schemas collection used by the XmlSchemImporter
XmlSchemas importSchemas = new XmlSchemas();
foreach (MetadataSection mds in metadataSet.MetadataSections)
{
XmlSchema xsd = mds.Metadata as XmlSchema;
if (xsd != null)
{
importSchemas.Add(xsd);
}
}
XmlSchemaImporter imp = new XmlSchemaImporter(importSchemas);
XmlCodeExporter exp = new XmlCodeExporter(cns);
foreach (XmlSchema xsd in importSchemas)
{
// 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));
// Finally, export the code
exp.ExportTypeMapping(map);
}
}
}
return cns;
}
public void GenerateClasses ()
{
if (namesp == null) namesp = "Schemas";
if (uri == null) uri = "";
string targetFile = "";
XmlSchemas schemas = new XmlSchemas();
foreach (string fileName in schemaNames)
{
StreamReader sr = new StreamReader (fileName);
schemas.Add (XmlSchema.Read (sr, new ValidationEventHandler (HandleValidationError)));
sr.Close ();
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"));
// Locate elements to generate
ArrayList qnames = new ArrayList ();
if (elements.Count > 0)
{
foreach (string name in elements)
qnames.Add (new XmlQualifiedName (name, uri));
}
else
{
foreach (XmlSchema schema in schemas) {
if (!schema.IsCompiled) schema.Compile (new ValidationEventHandler (HandleValidationError));
foreach (XmlSchemaElement el in schema.Elements.Values)
if (!qnames.Contains (el.QualifiedName))
qnames.Add (el.QualifiedName);
}
}
// Import schemas and generate the class model
XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
XmlCodeExporter sx = new XmlCodeExporter (codeNamespace, cunit);
ArrayList maps = new ArrayList();
foreach (XmlQualifiedName qname in qnames)
{
XmlTypeMapping tm = importer.ImportTypeMapping (qname);
if (tm != null) maps.Add (tm);
}
foreach (XmlTypeMapping tm in maps)
{
sx.ExportTypeMapping (tm);
}
// Generate the code
ICodeGenerator gen = provider.CreateGenerator();
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);
}
/// <summary>
/// Processes the schema.
/// </summary>
/// <param name="xsdFile">The full path to the WXS file to process.</param>
/// <param name="targetNamespace">The namespace to put generated classes in.</param>
/// <returns>The CodeDom tree generated from the schema.</returns>
public static CodeNamespace Process(string xsdFile, string targetNamespace, CodeDomProvider Provider)
{
// Load the XmlSchema and its collection.
//XmlSchema xsd;
//using ( FileStream fs = new FileStream( xsdFile, FileMode.Open ) )
//{
// xsd = XmlSchema.Read( fs, VH1 );
// xsd.Compile( VH2 );
//}
XmlSchemaSet set = new XmlSchemaSet();
XmlSchema xsd = set.Add(null, xsdFile);
set.Compile();
XmlSchemas schemas = new XmlSchemas();
schemas.Add(xsd);
// Create the importer for these schemas.
XmlSchemaImporter importer = new XmlSchemaImporter(schemas);
// System.CodeDom namespace for the XmlCodeExporter to put classes in.
CodeNamespace ns = new CodeNamespace(targetNamespace);
XmlCodeExporter exporter = new XmlCodeExporter(ns);
// Iterate schema top-level elements and export code for each.
foreach (XmlSchemaElement element in set.GlobalElements.Values) {
// Import the mapping first.
XmlTypeMapping mapping = importer.ImportTypeMapping(
element.QualifiedName);
// Export the code finally.
exporter.ExportTypeMapping(mapping);
}
#region Execute extensions
XPathNavigator nav;
using (FileStream fs = new FileStream(xsdFile, FileMode.Open, FileAccess.Read)) {
nav = new XPathDocument(fs).CreateNavigator();
}
XPathNodeIterator it = nav.Select(Extensions);
while (it.MoveNext()) {
Dictionary<string, string> values = ParsePEValue(it.Current.Value);
Type t = Type.GetType(values["extension-type"], true);
// Is the type an ICodeExtension?
Type iface = t.GetInterface(typeof(ICodeExtension).Name);
if (iface == null)
throw new ArgumentException(string.Format(Resources.ex_InvalidExtensionType, it.Current.Value));
ICodeExtension ext = (ICodeExtension)Activator.CreateInstance(t);
ext.Initialize(values);
// Run it!
ext.Process(ns, xsd, Provider);
}
#endregion Execute extensions
return ns;
}
public string Convert(CodeDomProvider codeProvider)
{
StringBuilder code = new StringBuilder();
List<XmlQualifiedName> arrayTypeList = BuildDataContractArrayTypeList();
try
{
CodeCompileUnit compileUnit = new CodeCompileUnit();
CodeNamespace namespace2 = new CodeNamespace();
compileUnit.Namespaces.Add(namespace2);
XmlCodeExporter codeExporter = new XmlCodeExporter(namespace2, compileUnit, codeProvider, CodeGenerationOptions.GenerateProperties, null);
// XmlSchemaImporter needs XmlSchemas and not XmlSchemaSet
XmlSchemas userSchemas = new XmlSchemas();
foreach (XmlSchema schema in schemas.Schemas())
{
userSchemas.Add(schema);
}
XmlSchemaImporter schemaImporter = new XmlSchemaImporter(userSchemas, CodeGenerationOptions.GenerateProperties, codeProvider, new ImportContext(new CodeIdentifiers(), false));
foreach (XmlSchema schema in userSchemas)
{
if (schema != null)
{
foreach (XmlSchemaElement element in schema.Elements.Values)
{
// Don't generate code for abstract elements or array types
if (!element.IsAbstract && !arrayTypeList.Contains(element.QualifiedName))
{
XmlTypeMapping mapping = schemaImporter.ImportTypeMapping(element.QualifiedName);
codeExporter.ExportTypeMapping(mapping);
}
}
}
}
CodeTypeDeclarationCollection types = namespace2.Types;
if ((types == null) || (types.Count == 0))
{
//RtlAwareMessageBox.Show(
PublicDI.log.error("The XML instance or XML Schema is valid, but no classes could be generated to match. Please ensure it contains a root element with some nested elements inside of it.");
//, "Error",
// MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1, 0);
}
else
{
CodeGenerator.ValidateIdentifiers(namespace2);
// Now we have to run Silverlight-specific fix-up
//DC
// ServiceContractGenerator generator = new ServiceContractGenerator(compileUnit);
// WcfSilverlightCodeGenerationExtension fixupExtension = new WcfSilverlightCodeGenerationExtension();
// fixupExtension.ClientGenerated(generator);
using (StringWriter writer = new StringWriter(code, CultureInfo.CurrentCulture))
{
foreach (CodeTypeDeclaration type in namespace2.Types)
{
codeProvider.GenerateCodeFromType(type, writer, null);
}
}
}
}
catch (Exception exception)
{
if (((exception is ThreadAbortException) || (exception is StackOverflowException)) || (exception is OutOfMemoryException))
{
throw;
}
//RtlAwareMessageBox.Show( //DC
PublicDI.log.error("The XML instance or XML Schema is valid, but no classes could be generated to match." + Environment.NewLine + Environment.NewLine + exception.Message);
//, "Error",
// MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1, 0);
}
return code.ToString();
}
private void ExportDataContract (MessagePartDescription md)
{
#if USE_DATA_CONTRACT_IMPORTER
if (xsd_data_importer == null)
xsd_data_importer = md.Importer;
#else
var mapping = md.XmlTypeMapping;
if (mapping == null)
return;
QName qname = new QName (mapping.TypeName, mapping.Namespace);
if (imported_names.ContainsKey (qname))
return;
CodeNamespace cns = new CodeNamespace ();
XmlCodeExporter xce = new XmlCodeExporter (cns);
xce.ExportTypeMapping (mapping);
List <CodeTypeDeclaration> to_remove = new List <CodeTypeDeclaration> ();
//Process the types just generated
//FIXME: Iterate and assign the types to correct namespaces
//At the end, add all those namespaces to the ccu
foreach (CodeTypeDeclaration type in cns.Types) {
string ns = GetXmlNamespace (type);
if (ns == null)
//FIXME: do what here?
continue;
QName type_name = new QName (type.Name, ns);
if (imported_names.ContainsKey (type_name)) {
//Type got reemitted, so remove it!
to_remove.Add (type);
continue;
}
if (ns == ms_arrays_ns) {
//Do not emit arrays as an independent type.
to_remove.Add (type);
continue;
}
imported_names [type_name] = type_name;
type.Comments.Clear ();
//Custom Attributes
type.CustomAttributes.Clear ();
if (type.IsEnum)
continue;
type.CustomAttributes.Add (
new CodeAttributeDeclaration (
new CodeTypeReference ("System.CodeDom.Compiler.GeneratedCodeAttribute"),
new CodeAttributeArgument (new CodePrimitiveExpression ("System.Runtime.Serialization")),
new CodeAttributeArgument (new CodePrimitiveExpression ("3.0.0.0"))));
type.CustomAttributes.Add (
new CodeAttributeDeclaration (
new CodeTypeReference ("System.Runtime.Serialization.DataContractAttribute")));
//BaseType and interface
type.BaseTypes.Add (new CodeTypeReference (typeof (object)));
type.BaseTypes.Add (new CodeTypeReference ("System.Runtime.Serialization.IExtensibleDataObject"));
foreach (CodeTypeMember mbr in type.Members) {
CodeMemberProperty p = mbr as CodeMemberProperty;
if (p == null)
continue;
if ((p.Attributes & MemberAttributes.Public) == MemberAttributes.Public) {
//FIXME: Clear all attributes or only XmlElementAttribute?
p.CustomAttributes.Clear ();
p.CustomAttributes.Add (new CodeAttributeDeclaration (
new CodeTypeReference ("System.Runtime.Serialization.DataMemberAttribute")));
p.Comments.Clear ();
}
}
//Fields
CodeMemberField field = new CodeMemberField (
new CodeTypeReference ("System.Runtime.Serialization.ExtensionDataObject"),
"extensionDataField");
field.Attributes = MemberAttributes.Private | MemberAttributes.Final;
type.Members.Add (field);
//Property
CodeMemberProperty prop = new CodeMemberProperty ();
prop.Type = new CodeTypeReference ("System.Runtime.Serialization.ExtensionDataObject");
prop.Name = "ExtensionData";
prop.Attributes = MemberAttributes.Public | MemberAttributes.Final;
//Get
prop.GetStatements.Add (new CodeMethodReturnStatement (
new CodeFieldReferenceExpression (
new CodeThisReferenceExpression (),
"extensionDataField")));
//Set
prop.SetStatements.Add (new CodeAssignStatement (
new CodeFieldReferenceExpression (
new CodeThisReferenceExpression (),
"extensionDataField"),
new CodePropertySetValueReferenceExpression ()));
type.Members.Add (prop);
}
foreach (CodeTypeDeclaration type in to_remove)
cns.Types.Remove (type);
ccu.Namespaces.Add (cns);
#endif
}
public void DuplicateIdentifiers ()
{
XmlSchema xs = XmlSchema.Read (File.OpenText ("Test/XmlFiles/xsd/82078.xsd"), null);
XmlSchemas xss = new XmlSchemas ();
xss.Add (xs);
XmlSchemaImporter imp = new XmlSchemaImporter (xss);
CodeNamespace cns = new CodeNamespace ();
XmlCodeExporter exp = new XmlCodeExporter (cns);
XmlQualifiedName qname = new XmlQualifiedName (
"Operation", "http://tempuri.org/");
exp.ExportTypeMapping (imp.ImportTypeMapping (qname));
CodeCompileUnit ccu = new CodeCompileUnit ();
ccu.Namespaces.Add (cns);
CodeDomProvider provider = new CSharpCodeProvider ();
ICodeCompiler compiler = provider.CreateCompiler ();
CompilerParameters options = new CompilerParameters ();
options.ReferencedAssemblies.Add ("System.dll");
options.ReferencedAssemblies.Add ("System.Xml.dll");
options.GenerateInMemory = true;
CompilerResults result = compiler.CompileAssemblyFromDom (options, ccu);
Assert.AreEqual (0, result.Errors.Count, "#1");
Assert.IsNotNull (result.CompiledAssembly, "#2");
}
private static void ImportSchemaAsClasses(XmlSchema schema, string uri, IList elements, XmlSchemaImporter schemaImporter, XmlCodeExporter codeExporter)
{
if (schema != null)
{
ArrayList list = new ArrayList();
foreach (XmlSchemaElement element in schema.Elements.Values)
{
bool flag;
if (element.IsAbstract || ((uri.Length != 0) && !(element.QualifiedName.Namespace == uri)))
{
continue;
}
if (elements.Count == 0)
{
flag = true;
}
else
{
flag = false;
foreach (string str in elements)
{
if (str == element.Name)
{
flag = true;
break;
}
}
}
if (flag)
{
list.Add(schemaImporter.ImportTypeMapping(element.QualifiedName));
}
}
foreach (XmlTypeMapping mapping in list)
{
codeExporter.ExportTypeMapping(mapping);
}
}
}
CodeNamespace ExportCode (Type type)
{
XmlReflectionImporter imp = new XmlReflectionImporter ();
XmlTypeMapping map = imp.ImportTypeMapping (type);
CodeNamespace codeNamespace = new CodeNamespace ();
XmlCodeExporter exp = new XmlCodeExporter (codeNamespace);
exp.ExportTypeMapping (map);
return codeNamespace;
}
/// <summary>
/// Generate code for all of the complex types in the schema
/// </summary>
/// <param name="xsd"></param>
/// <param name="importer"></param>
/// <param name="exporter"></param>
private void GenerateForComplexTypes(
XmlSchema xsd,
XmlSchemaImporter importer,
XmlCodeExporter exporter)
{
foreach (XmlSchemaObject type in xsd.SchemaTypes.Values)
{
XmlSchemaComplexType ct = type as XmlSchemaComplexType;
if (ct != null)
{
Trace.TraceInformation("Generating for Complex Type: {0}", ct.Name);
XmlTypeMapping mapping = importer.ImportSchemaType(ct.QualifiedName);
exporter.ExportTypeMapping(mapping);
}
}
}
