XsdDataContractExporter Classe

Definição

public ref class XsdDataContractExporter

public class XsdDataContractExporter

type XsdDataContractExporter = class

Public Class XsdDataContractExporter

Herança

Object

XsdDataContractExporter

Exemplos

O exemplo a XsdDataContractExporter seguir cria uma instância do método 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

Comentários

Use a XsdDataContractExporter classe quando você 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 compatíveis com o Serializador de Contrato de Dados.) Em seguida, os esquemas podem ser expostos por meio de um documento WSDL (Linguagem de Descrição dos Serviços Web) 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 por meio 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. Portanto, você pode chamar o CanExport método várias vezes para adicionar novos tipos ao conjunto de esquemas sem degradar o desempenho, pois somente 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 o mesmo nome de contrato de dados, mas com contratos diferentes (e diferentes membros), forem exportados pela mesma instância XsdDataContractExporter.

Utilize o exportador

Uma maneira recomendada de usar essa classe é a seguinte:

1. Use uma das CanExport sobrecargas para determinar se o tipo ou conjunto de tipos especificado pode ser exportado. Utilize uma das sobrecargas apropriadas à sua necessidade.

2. Chame o método correspondente Export .

3. Recupere os esquemas da propriedade Schemas.

Confira também

• DataContractSerializer
• XsdDataContractImporter
• Tipos compatíveis com o serializador de contrato de dados
• Serialização e desserialização