XsdDataContractExporter Classe

Definição

public ref class XsdDataContractExporter

public class XsdDataContractExporter

type XsdDataContractExporter = class

Public Class XsdDataContractExporter

Herança

Object

XsdDataContractExporter

Exemplos

O exemplo seguinte cria uma instância do XsdDataContractExporter e chama o Export(Type) método.

using System;
using System.Xml;
using System.Runtime.Serialization;
using System.Xml.Schema;

public class Program
{
    public static void Main()
    {
        try
        {
            ExportXSD();
        }
        catch (Exception exc)
        {
            Console.WriteLine("Message: {0} StackTrace:{1}", exc.Message, exc.StackTrace);
        }
        finally
        {
            Console.ReadLine();
        }
    }

    static void ExportXSD()
    {
        XsdDataContractExporter exporter = new XsdDataContractExporter();
        if (exporter.CanExport(typeof(Employee)))
        {
            exporter.Export(typeof(Employee));
            Console.WriteLine("number of schemas: {0}", exporter.Schemas.Count);
            Console.WriteLine();
            XmlSchemaSet mySchemas = exporter.Schemas;

            XmlQualifiedName XmlNameValue = exporter.GetRootElementName(typeof(Employee));
            string EmployeeNameSpace = XmlNameValue.Namespace;

            foreach (XmlSchema schema in mySchemas.Schemas(EmployeeNameSpace))
            {
                schema.Write(Console.Out);
            }
        }
    }

    static void GetXmlElementName()
    {
        XsdDataContractExporter myExporter = new XsdDataContractExporter();
        XmlQualifiedName xmlElementName =myExporter.GetRootElementName(typeof(Employee));
        Console.WriteLine("Namespace: {0}", xmlElementName.Namespace);
        Console.WriteLine("Name: {0}", xmlElementName.Name);
        Console.WriteLine("IsEmpty: {0}", xmlElementName.IsEmpty);
    }

    [DataContract(Namespace = "www.Contoso.com/Examples/")]
    public class Employee
    {
        [DataMember]
        public string EmployeeName;
        [DataMember]
        private string ID;
    }
}

Imports System.Collections
Imports System.Xml
Imports System.Runtime.Serialization
Imports System.Xml.Schema

Public Class Program
    Public Shared Sub Main() 
        Try
            ExportXSD()
        Catch exc As Exception
            Console.WriteLine("Message: {0} StackTrace:{1}", exc.Message, exc.StackTrace)
        Finally
            Console.ReadLine()
        End Try
    
    End Sub 
    
    
    Shared Sub ExportXSD() 

        Dim exporter As New XsdDataContractExporter()

        ' Use the ExportOptions to add the Possessions type to the 
        ' collection of KnownTypes. 
        Dim eOptions As New ExportOptions()
        eOptions.KnownTypes.Add(GetType(Possessions))        
        exporter.Options = eOptions

        If exporter.CanExport(GetType(Employee)) Then
            exporter.Export(GetType(Employee))
            Console.WriteLine("number of schemas: {0}", exporter.Schemas.Count)
            Console.WriteLine()
            Dim mySchemas As XmlSchemaSet = exporter.Schemas
            
            Dim XmlNameValue As XmlQualifiedName = _
               exporter.GetRootElementName(GetType(Employee))
            Dim EmployeeNameSpace As String = XmlNameValue.Namespace
            
            Dim schema As XmlSchema
            For Each schema In  mySchemas.Schemas(EmployeeNameSpace)
                schema.Write(Console.Out)
            Next schema
        End If
    
    End Sub 
    
    
    Shared Sub GetXmlElementName() 
        Dim myExporter As New XsdDataContractExporter()
        Dim xmlElementName As XmlQualifiedName = myExporter. _
            GetRootElementName(GetType(Employee))
        Console.WriteLine("Namespace: {0}", xmlElementName.Namespace)
        Console.WriteLine("Name: {0}", xmlElementName.Name)
        Console.WriteLine("IsEmpty: {0}", xmlElementName.IsEmpty)
    
    End Sub 
    
    <DataContract([Namespace] := "www.Contoso.com/Examples/")>  _
    Public Class Employee

        <DataMember()>  _
        Public EmployeeName As String
        <DataMember()>  _
        Private ID As String
        ' This member may return a Possessions type.
        <DataMember> _
        public Miscellaneous As Hashtable 

    End Class 

    <DataContract> _
    Public Class Possessions

        <DataMember> _
        Public ItemName As String
    End Class

End Class

Observações

Use a XsdDataContractExporter classe quando tiver criado um serviço Web que incorpore dados representados por tipos CLR (Common Language Runtime) e quando precisar exportar esquemas XML para cada tipo a ser consumido por outros serviços Web. Ou seja, XsdDataContractExporter transforma um conjunto de tipos CLR em esquemas XML. (Para obter mais informações sobre os tipos que podem ser usados, consulte Tipos suportados pelo Data Contract Serializer.) Os esquemas podem então ser expostos por meio de um documento WSDL (Web Services Description Language) para uso por outras pessoas que precisam interoperar com seu serviço.

Por outro lado, se você estiver criando um serviço Web que deve interoperar com um serviço Web existente, use o XsdDataContractImporter para transformar esquemas XML e criar os tipos CLR que representam os dados em uma linguagem de programação selecionada.

O XsdDataContractExporter gera um XmlSchemaSet objeto que contém a coleção de esquemas. Acesse o conjunto de esquemas através da Schemas() propriedade.

Exportar esquemas para um XmlSchemaSet

Para criar uma instância da XmlSchemaSet classe que contém arquivos de esquema XML, você deve estar ciente do seguinte.

O conjunto de tipos que você está exportando é registrado como um conjunto interno de contratos de dados. Assim, você pode chamar o CanExport método várias vezes para adicionar novos tipos ao conjunto de esquemas sem degradar o desempenho, pois apenas os novos tipos serão adicionados ao conjunto. Durante a Export operação, os esquemas existentes são comparados com os novos esquemas que estão sendo adicionados. Se houver conflitos, uma exceção será lançada. Um conflito geralmente é detectado se dois tipos com contratos diferentes (membros diferentes), mas com o mesmo nome de contrato de dados, forem exportados pela mesma instância XsdDataContractExporter.

Utilizar o exportador

Uma maneira recomendada de usar essa classe é a seguinte:

1. Utilize uma das CanExport sobrecargas para verificar se o tipo ou conjunto de tipos especificados podem ser exportados. Use uma das sobrecargas adequadas às suas necessidades.

2. Chame o método correspondente Export .

3. Recupere os esquemas da propriedade Schemas.

Ver também

• DataContractSerializer
• XsdDataContractImporter
• Tipos suportados pelo Data Contract Serializer
• Serialização e desserialização