XsdDataContractExporter XsdDataContractExporter XsdDataContractExporter XsdDataContractExporter Class

Definición

Permite la transformación de un conjunto de tipos de .NET Framework que se usan en contratos de datos en un archivo de esquema XML (.xsd).Allows the transformation of a set of .NET Framework types that are used in data contracts into an XML schema file (.xsd).

public ref class XsdDataContractExporter
public class XsdDataContractExporter
type XsdDataContractExporter = class
Public Class XsdDataContractExporter
Herencia
XsdDataContractExporterXsdDataContractExporterXsdDataContractExporterXsdDataContractExporter

Ejemplos

En el ejemplo siguiente, se crea una instancia de XsdDataContractExporter y se llama al método Export(Type).The following example creates an instance of the XsdDataContractExporter and calls the Export(Type) method.

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

Comentarios

Use la clase XsdDataContractExporter cuando haya creado un servicio Web que incorpore datos representados por tipos de Common Language Runtime (CLR) y cuando necesite exportar esquemas XML para cada tipo que vayan a usar otros servicios Web.Use the XsdDataContractExporter class when you have created a Web service that incorporates data represented by common language runtime (CLR) types and when you need to export XML schemas for each type to be consumed by other Web services. Es decir, XsdDataContractExporter transforma un conjunto de tipos de CLR en esquemas XML.That is, XsdDataContractExporter transforms a set of CLR types into XML schemas. (Para obtener más información sobre los tipos que se pueden usar, vea tipos admitidos por el serializador de contrato de datos). Los esquemas se pueden exponer, a continuación, a través de un documento de lenguaje de descripción de servicios Web (WSDL) para que los puedan usar otros usuarios que necesiten interoperar con su servicio.(For more information about the types that can be used, see Types Supported by the Data Contract Serializer.) The schemas can then be exposed through a Web Services Description Language (WSDL) document for use by others who need to interoperate with your service.

Por el contrario, si está creando un servicio Web que debe interoperar con un servicio Web existente, use XsdDataContractImporter para transformar los esquemas XML y crear los tipos de CLR que representan los datos en un lenguaje de programación seleccionado.Conversely, if you are creating a Web service that must interoperate with an existing Web service, use the XsdDataContractImporter to transform XML schemas and create the CLR types that represent the data in a selected programming language.

XsdDataContractExporter genera un objeto XmlSchemaSet que contiene la colección de esquemas.The XsdDataContractExporter generates an XmlSchemaSet object that contains the collection of schemas. Obtenga acceso al conjunto de esquemas a través de la propiedad Schemas.Access the set of schemas through the Schemas property.

Nota

Para generar rápidamente archivos de definición del esquema XML (XSD) que otros servicios Web pueden usar, use XsdDataContractExporter.To quickly generate XML schema definition (XSD) files that other Web services can consume, use the XsdDataContractExporter.

Exportar esquemas a un XmlSchemaSetExporting Schemas Into an XmlSchemaSet

Para crear una instancia de la clase XmlSchemaSet que contiene archivos de esquema XML, deberá tener en cuenta lo siguiente.To create an instance of the XmlSchemaSet class that contains XML schema files, you should be aware of the following.

El conjunto de tipos que está exportando se registra como un conjunto interno de contratos de datos.The set of types you are exporting are recorded as an internal set of data contracts. De este modo, puede llamar varias veces al método CanExport para agregar tipos nuevos al conjunto de esquemas establecido sin que se reduzca el rendimiento porque sólo los tipos nuevos se agregarán al conjunto.Thus, you can call the CanExport method multiple times to add new types to the schema set without degrading performance because only the new types will be added to the set. Durante la operación Export, los esquemas existentes se comparan con los nuevos esquemas que se agregan.During the Export operation, the existing schemas are compared to the new schemas being added. Si hay conflictos, se producirá una excepción.If there are conflicts, an exception will be thrown. Normalmente se detecta un conflicto si una misma instancia XsdDataContractExporter exporta dos tipos con el mismo nombre de contrato de datos pero con contratos diferentes (miembros diferentes).A conflict is usually detected if two types with the same data contract name but different contracts (different members) are exported by the same XsdDataContractExporter instance.

Uso del exportadorUsing the Exporter

Una manera recomendada de usar esta clase es como sigue:A recommended way of using this class is as follows:

  1. Use una de las sobrecargas CanExport para determinar si se puede exportar el tipo o conjunto de tipos especificado.Use one of the CanExport overloads to determine whether the specified type or set of types can be exported. Use una de las sobrecargas que se ajuste a sus requisitos.Use one of the overloads that is appropriate to your requirements.

  2. Llame al método Export correspondiente.Call the corresponding Export method.

  3. Recupere los esquemas de la propiedad Schemas.Retrieve the schemas from the Schemas property.

Constructores

XsdDataContractExporter() XsdDataContractExporter() XsdDataContractExporter() XsdDataContractExporter()

Inicializa una nueva instancia de la clase XsdDataContractExporter.Initializes a new instance of the XsdDataContractExporter class.

XsdDataContractExporter(XmlSchemaSet) XsdDataContractExporter(XmlSchemaSet) XsdDataContractExporter(XmlSchemaSet) XsdDataContractExporter(XmlSchemaSet)

Inicializa una nueva instancia de la clase XsdDataContractExporter con el conjunto de esquemas especificado.Initializes a new instance of the XsdDataContractExporter class with the specified set of schemas.

Propiedades

Options Options Options Options

Obtiene o establece un ExportOptions que contiene opciones que se pueden establecer para la operación de exportación.Gets or sets an ExportOptions that contains options that can be set for the export operation.

Schemas Schemas Schemas Schemas

Obtiene la colección de esquemas XML exportados.Gets the collection of exported XML schemas.

Métodos

CanExport(ICollection<Assembly>) CanExport(ICollection<Assembly>) CanExport(ICollection<Assembly>) CanExport(ICollection<Assembly>)

Obtiene un valor que indica si se puede exportar el conjunto de tipos de Common Language Runtime (CLR) incluidos en un conjunto de ensamblados.Gets a value that indicates whether the set of .common language runtime (CLR) types contained in a set of assemblies can be exported.

CanExport(ICollection<Type>) CanExport(ICollection<Type>) CanExport(ICollection<Type>) CanExport(ICollection<Type>)

Obtiene un valor que indica si se puede exportar el conjunto tipos de Common Language Runtime (CLR) incluidos en un ICollection<T>.Gets a value that indicates whether the set of .common language runtime (CLR) types contained in a ICollection<T> can be exported.

CanExport(Type) CanExport(Type) CanExport(Type) CanExport(Type)

Obtiene un valor que indica si se puede exportar el tipo de Common Language Runtime (CLR) especificado.Gets a value that indicates whether the specified common language runtime (CLR) type can be exported.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Determina si el objeto especificado es igual al objeto actual.Determines whether the specified object is equal to the current object.

(Inherited from Object)
Export(ICollection<Assembly>) Export(ICollection<Assembly>) Export(ICollection<Assembly>) Export(ICollection<Assembly>)

Transforma los tipos contenidos en la colección especificada de ensamblados.Transforms the types contained in the specified collection of assemblies.

Export(ICollection<Type>) Export(ICollection<Type>) Export(ICollection<Type>) Export(ICollection<Type>)

Transforma los tipos contenidos en ICollection<T> pasados a este método.Transforms the types contained in the ICollection<T> passed to this method.

Export(Type) Export(Type) Export(Type) Export(Type)

Transforma el tipo .NET Framework.NET Framework especificado en un esquema del lenguaje de definición de esquemas XML (XSD).Transforms the specified .NET Framework.NET Framework type into an XML schema definition language (XSD) schema.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Sirve como la función hash predeterminada.Serves as the default hash function.

(Inherited from Object)
GetRootElementName(Type) GetRootElementName(Type) GetRootElementName(Type) GetRootElementName(Type)

Devuelve el nombre de nivel superior y el espacio de nombres para Type.Returns the top-level name and namespace for the Type.

GetSchemaType(Type) GetSchemaType(Type) GetSchemaType(Type) GetSchemaType(Type)

Devuelve un tipo de esquema XML para el tipo especificado.Returns the XML schema type for the specified type.

GetSchemaTypeName(Type) GetSchemaTypeName(Type) GetSchemaTypeName(Type) GetSchemaTypeName(Type)

Devuelve el nombre del contrato el espacio de nombres del contrato para el Type.Returns the contract name and contract namespace for the Type.

GetType() GetType() GetType() GetType()

Obtiene el Type de la instancia actual.Gets the Type of the current instance.

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crea una copia superficial del objeto Object actual.Creates a shallow copy of the current Object.

(Inherited from Object)
ToString() ToString() ToString() ToString()

Devuelve una cadena que representa el objeto actual.Returns a string that represents the current object.

(Inherited from Object)

Se aplica a

Consulte también: