C# XmlSchemaImporter.ImportSchemaType方法代码示例

        private static void Main(string[] args)
        {
            XmlSchema rootSchema = GetSchemaFromFile("fpml-main-4-2.xsd");

            var schemaSet = new List<XmlSchemaExternal>();

            ExtractIncludes(rootSchema, ref schemaSet);

            var schemas = new XmlSchemas { rootSchema };

            schemaSet.ForEach(schemaExternal => schemas.Add(GetSchemaFromFile(schemaExternal.SchemaLocation)));

            schemas.Compile(null, true);

            var xmlSchemaImporter = new XmlSchemaImporter(schemas);

            var codeNamespace = new CodeNamespace("Hosca.FpML4_2");
            var xmlCodeExporter = new XmlCodeExporter(codeNamespace);

            var xmlTypeMappings = new List<XmlTypeMapping>();

            foreach (XmlSchemaType schemaType in rootSchema.SchemaTypes.Values)
                xmlTypeMappings.Add(xmlSchemaImporter.ImportSchemaType(schemaType.QualifiedName));
            foreach (XmlSchemaElement schemaElement in rootSchema.Elements.Values)
                xmlTypeMappings.Add(xmlSchemaImporter.ImportTypeMapping(schemaElement.QualifiedName));

            xmlTypeMappings.ForEach(xmlCodeExporter.ExportTypeMapping);

            CodeGenerator.ValidateIdentifiers(codeNamespace);

            foreach (CodeTypeDeclaration codeTypeDeclaration in codeNamespace.Types)
            {
                for (int i = codeTypeDeclaration.CustomAttributes.Count - 1; i >= 0; i--)
                {
                    CodeAttributeDeclaration cad = codeTypeDeclaration.CustomAttributes[i];
                    if (cad.Name == "System.CodeDom.Compiler.GeneratedCodeAttribute")
                        codeTypeDeclaration.CustomAttributes.RemoveAt(i);
                }
            }

            using (var writer = new StringWriter())
            {
                new CSharpCodeProvider().GenerateCodeFromNamespace(codeNamespace, writer, new CodeGeneratorOptions());

                //Console.WriteLine(writer.GetStringBuilder().ToString());

                File.WriteAllText(Path.Combine(rootFolder, "FpML4_2.Generated.cs"), writer.GetStringBuilder().ToString());
            }

            Console.ReadLine();
        }

        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;
        }

        /// <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();
            }
        }

        /// <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 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 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);
                }
            }
        }

		void resolveParticle (XmlSchemaImporter schema_importer, 
				XmlSchemaParticle particle, 
				List<MessagePartDescription> parts, 
				string ns, 
				int depth)
		{
			if (particle is XmlSchemaGroupBase) {
				//sequence, 
				//FIXME: others?
				if (depth <= 0)
					return;

				XmlSchemaGroupBase groupBase = particle as XmlSchemaGroupBase;
				foreach (XmlSchemaParticle item in groupBase.Items)
					resolveParticle (schema_importer, item, parts, ns, depth - 1);

				return;
			}

			XmlSchemaElement elem = particle as XmlSchemaElement;
			if (elem == null)
				return;

			MessagePartDescription msg_part = null;
			
			XmlSchemaComplexType ct = elem.ElementSchemaType as XmlSchemaComplexType;
			if (ct == null) {
				//Not a complex type
				XmlSchemaSimpleType simple = elem.ElementSchemaType as XmlSchemaSimpleType;
				msg_part = new MessagePartDescription (
						elem.Name, ns);
				if (elem.SchemaType != null)
					msg_part.XmlTypeMapping = schema_importer.ImportTypeMapping (elem.QualifiedName);
				else
					msg_part.XmlTypeMapping = schema_importer.ImportSchemaType (elem.SchemaTypeName);
				msg_part.TypeName = new QName (GetCLRTypeName (elem.SchemaTypeName), "");
				parts.Add (msg_part);

				return;
			}

			if (depth > 0) {
				resolveParticle (schema_importer, ct.ContentTypeParticle, parts, ns, depth - 1);
				return;
			}

			//depth <= 0
			msg_part = new MessagePartDescription (elem.Name, ns);
			if (elem.SchemaType != null)
				msg_part.XmlTypeMapping = schema_importer.ImportTypeMapping (elem.QualifiedName);
			else
				msg_part.XmlTypeMapping = schema_importer.ImportSchemaType (elem.SchemaTypeName);
			msg_part.TypeName = elem.SchemaTypeName;

			parts.Add (msg_part);
		}

        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());
        }

        /// <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);
                }
            }
        }