DataContractSerializer Classe

Definição

Serializa e desserializa uma instância de um tipo em um fluxo XML ou em um documento usando um contrato de dados fornecido.Serializes and deserializes an instance of a type into an XML stream or document using a supplied data contract. Essa classe não pode ser herdada.This class cannot be inherited.

public ref class DataContractSerializer sealed : System::Runtime::Serialization::XmlObjectSerializer
public sealed class DataContractSerializer : System.Runtime.Serialization.XmlObjectSerializer
type DataContractSerializer = class
    inherit XmlObjectSerializer
Public NotInheritable Class DataContractSerializer
Inherits XmlObjectSerializer
Herança
DataContractSerializer

Exemplos

O código de exemplo a seguir mostra um Person tipo chamado que é serializado DataContractSerializerpelo.The following example code shows a type named Person that is serialized by the DataContractSerializer. O DataContractAttribute atributo é aplicado à classe e o DataMemberAttribute é aplicado aos membros para instruir o DataContractSerializer que serializar.The DataContractAttribute attribute is applied to the class, and the DataMemberAttribute is applied to members to instruct the DataContractSerializer what to serialize.

namespace DataContractSerializerExample
{
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Runtime.Serialization;
    using System.Xml;

    // You must apply a DataContractAttribute or SerializableAttribute
    // to a class to have it serialized by the DataContractSerializer.
    [DataContract(Name = "Customer", Namespace = "http://www.contoso.com")]
    class Person : IExtensibleDataObject
    {
        [DataMember()]
        public string FirstName;
        [DataMember]
        public string LastName;
        [DataMember()]
        public int ID;

        public Person(string newfName, string newLName, int newID)
        {
            FirstName = newfName;
            LastName = newLName;
            ID = newID;
        }

        private ExtensionDataObject extensionData_Value;

        public ExtensionDataObject ExtensionData
        {
            get
            {
                return extensionData_Value;
            }
            set
            {
                extensionData_Value = value;
            }
        }
    }

    public sealed class Test
    {
        private Test() { }

        public static void Main()
        {
            try
            {
                WriteObject("DataContractSerializerExample.xml");
                ReadObject("DataContractSerializerExample.xml");

            }

            catch (SerializationException serExc)
            {
                Console.WriteLine("Serialization Failed");
                Console.WriteLine(serExc.Message);
            }
            catch (Exception exc)
            {
                Console.WriteLine(
                "The serialization operation failed: {0} StackTrace: {1}",
                exc.Message, exc.StackTrace);
            }

            finally
            {
                Console.WriteLine("Press <Enter> to exit....");
                Console.ReadLine();
            }
        }

        public static void WriteObject(string fileName)
        {
            Console.WriteLine(
                "Creating a Person object and serializing it.");
            Person p1 = new Person("Zighetti", "Barbara", 101);
            FileStream writer = new FileStream(fileName, FileMode.Create);
            DataContractSerializer ser =
                new DataContractSerializer(typeof(Person));
            ser.WriteObject(writer, p1);
            writer.Close();
        }

        public static void ReadObject(string fileName)
        {
            Console.WriteLine("Deserializing an instance of the object.");
            FileStream fs = new FileStream(fileName,
            FileMode.Open);
            XmlDictionaryReader reader =
                XmlDictionaryReader.CreateTextReader(fs, new XmlDictionaryReaderQuotas());
            DataContractSerializer ser = new DataContractSerializer(typeof(Person));

            // Deserialize the data and read it from the instance.
            Person deserializedPerson =
                (Person)ser.ReadObject(reader, true);
            reader.Close();
            fs.Close();
            Console.WriteLine(String.Format("{0} {1}, ID: {2}",
            deserializedPerson.FirstName, deserializedPerson.LastName,
            deserializedPerson.ID));
        }
    }
' You must apply a DataContractAttribute or SerializableAttribute
' to a class to have it serialized by the DataContractSerializer.
<DataContract(Name := "Customer", [Namespace] := "http://www.contoso.com")>  _
Class Person
    Implements IExtensibleDataObject
    <DataMember()>  _
    Public FirstName As String
    <DataMember()>  _
    Public LastName As String
    <DataMember()>  _
    Public ID As Integer
    
    Public Sub New(ByVal newfName As String, ByVal newLName As String, ByVal newID As Integer) 
        FirstName = newfName
        LastName = newLName
        ID = newID
    End Sub 
    
    Private extensionData_Value As ExtensionDataObject
    
    Public Property ExtensionData() As ExtensionDataObject Implements _
       IExtensibleDataObject.ExtensionData
        Get
            Return extensionData_Value
        End Get
        Set
            extensionData_Value = value
        End Set
    End Property
End Class 


NotInheritable Public Class Test
    
    Private Sub New() 
    
    End Sub 
     
    Public Shared Sub Main() 
        Try
            WriteObject("DataContractSerializerExample.xml")
            ReadObject("DataContractSerializerExample.xml")
        
        Catch serExc As SerializationException
            Console.WriteLine("Serialization Failed")
            Console.WriteLine(serExc.Message)
        Catch exc As Exception
            Console.WriteLine("The serialization operation failed: {0} StackTrace: {1}", exc.Message, exc.StackTrace)
        
        Finally
            Console.WriteLine("Press <Enter> to exit....")
            Console.ReadLine()
        End Try
    End Sub 
    
    Public Shared Sub WriteObject(ByVal fileName As String) 
        Console.WriteLine("Creating a Person object and serializing it.")
        Dim p1 As New Person("Zighetti", "Barbara", 101)
        Dim writer As New FileStream(fileName, FileMode.Create)
        Dim ser As New DataContractSerializer(GetType(Person))
        ser.WriteObject(writer, p1)
        writer.Close()
    End Sub 

    Public Shared Sub ReadObject(ByVal fileName As String) 
        Console.WriteLine("Deserializing an instance of the object.")
        Dim fs As New FileStream(fileName, FileMode.Open)
        Dim reader As XmlDictionaryReader = _
            XmlDictionaryReader.CreateTextReader(fs, New XmlDictionaryReaderQuotas())
        Dim ser As New DataContractSerializer(GetType(Person))
        
        ' Deserialize the data and read it from the instance.
        Dim deserializedPerson As Person = CType(ser.ReadObject(reader, True), Person)
        reader.Close()
        fs.Close()
        Console.WriteLine(String.Format("{0} {1}, ID: {2}", deserializedPerson.FirstName, deserializedPerson.LastName, deserializedPerson.ID))
    End Sub 
End Class 

Comentários

Use a DataContractSerializer classe para serializar e desserializar instâncias de um tipo em um fluxo ou documento XML.Use the DataContractSerializer class to serialize and deserialize instances of a type into an XML stream or document. Por exemplo, você pode criar um tipo chamado Person com propriedades que contêm dados essenciais, como um nome e um endereço.For example, you can create a type named Person with properties that contain essential data, such as a name and address. Em seguida, você pode criar e manipular uma instância Person da classe e gravar todos os seus valores de propriedade em um documento XML para recuperação posterior ou em um fluxo XML para transporte imediato.You can then create and manipulate an instance of the Person class and write all of its property values in an XML document for later retrieval, or in an XML stream for immediate transport. Mais importante, o DataContractSerializer é usado para serializar e desserializar dados enviados em mensagens Windows Communication Foundation (WCF).Most important, the DataContractSerializer is used to serialize and deserialize data sent in Windows Communication Foundation (WCF) messages. Aplique o DataContractAttribute atributo às classes e o atributo DataMemberAttribute aos membros da classe para especificar propriedades e campos serializados.Apply the DataContractAttribute attribute to classes, and the DataMemberAttribute attribute to class members to specify properties and fields that are serialized.

Para obter uma lista de tipos que podem ser serializados, consulte tipos com suporte pelo serializador de contrato de dados.For a list of types that can be serialized, see Types Supported by the Data Contract Serializer.

Para usar o DataContractSerializer, primeiro crie uma instância de uma classe e um objeto apropriado para gravar ou ler o formato; por exemplo, uma instância XmlDictionaryWriterdo.To use the DataContractSerializer, first create an instance of a class and an object appropriate to writing or reading the format; for example, an instance of the XmlDictionaryWriter. Em seguida, WriteObject chame o método para manter os dados.Then call the WriteObject method to persist the data. Para recuperar dados, crie um objeto apropriado para ler o formato de dados (como um XmlDictionaryReader para um documento XML) e chame o ReadObject método.To retrieve data, create an object appropriate to reading the data format (such as an XmlDictionaryReader for an XML document) and call the ReadObject method.

Para obter mais informações sobre como DataContractSerializerusar o, consulte serialização edesserialização.For more information about using the DataContractSerializer, see Serialization and Deserialization.

Você pode definir o tipo de um serializador de contrato de <dados> usando o elemento DataContractSerializer em um arquivo de configuração de aplicativo cliente.You can set the type of a data contract serializer using the <dataContractSerializer> element in a client application configuration file.

Preparando classes para serialização ou desserializaçãoPreparing Classes for Serialization or Deserialization

O DataContractSerializer é usado em combinação com as DataContractAttribute classes DataMemberAttribute e.The DataContractSerializer is used in combination with the DataContractAttribute and DataMemberAttribute classes. Para preparar uma classe para serialização, aplique o DataContractAttribute à classe.To prepare a class for serialization, apply the DataContractAttribute to the class. Para cada membro da classe que retorna dados que você deseja serializar, aplique o DataMemberAttribute.For each member of the class that returns data that you want to serialize, apply the DataMemberAttribute. Você pode serializar campos e propriedades, independentemente da acessibilidade: particular, protegido, interno, protegido interno ou público.You can serialize fields and properties, regardless of accessibility: private, protected, internal, protected internal, or public.

Por exemplo, seu esquema especifica um Customer com uma ID Propriedade, mas você já tem um aplicativo existente que usa um tipo chamado Person com uma Name propriedade.For example, your schema specifies a Customer with an ID property, but you already have an existing application that uses a type named Person with a Name property. Para criar um tipo que esteja de acordo com o contrato, primeiro aplique o DataContractAttribute à classe.To create a type that conforms to the contract, first apply the DataContractAttribute to the class. Em seguida, DataMemberAttribute aplique o a cada campo ou propriedade que você deseja serializar.Then apply the DataMemberAttribute to every field or property that you want to serialize.

Observação

Você pode aplicar o DataMemberAttribute a membros públicos e privados.You can apply the DataMemberAttribute to both private and public members.

O formato final do XML não precisa ser texto.The final format of the XML need not be text. Em vez disso DataContractSerializer , o grava os dados como um XML infoset, que permite que você grave os dados em qualquer formato reconhecido XmlReader pelo XmlWritere pelo.Instead, the DataContractSerializer writes the data as an XML infoset, which allows you to write the data to any format recognized by the XmlReader and XmlWriter. É recomendável que você use as XmlDictionaryReader classes XmlDictionaryWriter e para ler e gravar, pois ambas são otimizadas para funcionar com DataContractSerializero.It is recommended that you use the XmlDictionaryReader and XmlDictionaryWriter classes to read and write, because both are optimized to work with the DataContractSerializer.

Se você estiver criando uma classe que tem campos ou propriedades que devem ser preenchidas antes que a serialização ou desserialização ocorra, use os atributos de retorno de chamada, conforme descrito em retornos de chamada de serialização tolerantes à versão.If you are creating a class that has fields or properties that must be populated before the serialization or deserialization occurs, use callback attributes, as described in Version-Tolerant Serialization Callbacks.

Adicionando à coleção de tipos conhecidosAdding to the Collection of Known Types

Ao serializar ou desserializar um objeto, é necessário que o tipo seja "conhecido" para o DataContractSerializer.When serializing or deserializing an object, it is required that the type is "known" to the DataContractSerializer. Comece criando uma instância de uma classe que implementa IEnumerable<T> ( List<T>como) e adicionando os tipos conhecidos à coleção.Begin by creating an instance of a class that implements IEnumerable<T> (such as List<T>) and adding the known types to the collection. Em seguida, crie uma instância DataContractSerializer do usando uma das sobrecargas que usa o IEnumerable<T> (por exemplo, DataContractSerializer(Type, IEnumerable<Type>).Then create an instance of the DataContractSerializer using one of the overloads that takes the IEnumerable<T> (for example, DataContractSerializer(Type, IEnumerable<Type>).

Observação

Ao contrário de outros tipos primitivos, a DateTimeOffset estrutura não é um tipo conhecido por padrão, portanto, ela deve ser adicionada manualmente à lista de tipos conhecidos (consulte tipos conhecidos de contrato de dados).Unlike other primitive types, the DateTimeOffset structure is not a known type by default, so it must be manually added to the list of known types (see Data Contract Known Types).

Compatibilidade com versões posterioresForward Compatibility

O DataContractSerializer compreende os contratos de dados que foram projetados para serem compatíveis com as versões futuras do contrato.The DataContractSerializer understands data contracts that have been designed to be compatible with future versions of the contract. Esses tipos implementam IExtensibleDataObject a interface.Such types implement the IExtensibleDataObject interface. A interface apresenta a ExtensionData propriedade que retorna um ExtensionDataObject objeto.The interface features the ExtensionData property that returns an ExtensionDataObject object. Para obter mais informações, consulte Contratos de dados compatíveis por encaminhamento.For more information, see Forward-Compatible Data Contracts.

Executando com confiança parcialRunning under Partial Trust

Ao instanciar o objeto de destino durante a desserialização DataContractSerializer , o não chama o construtor do objeto de destino.When instantiating the target object during deserialization, the DataContractSerializer does not call the constructor of the target object. Se você criar um tipo [DataContract] que é acessível de confiança parcial (ou seja, é público e em um assembly que tem o AllowPartiallyTrustedCallers atributo aplicado) e que executa algumas ações relacionadas à segurança, você deve estar ciente de que o construtor não é denomina.If you author a [DataContract] type that is accessible from partial trust (that is, it is public and in an assembly that has the AllowPartiallyTrustedCallers attribute applied) and that performs some security-related actions, you must be aware that the constructor is not called. Em particular, as seguintes técnicas não funcionam:In particular, the following techniques do not work:

  • Se você tentar restringir o acesso de confiança parcial tornando o construtor interno ou privado, ou adicionando um LinkDemand ao construtor, nenhum deles terá nenhum efeito durante a desserialização sob confiança parcial.If you try to restrict partial trust access by making the constructor internal or private, or by adding a LinkDemand to the constructor -- neither of these have any effect during deserialization under partial trust.

  • Se você codificar a classe que assume que o Construtor foi executado, a classe poderá entrar em um estado interno inválido que possa ser explorado.If you code the class that assumes the constructor has run, the class may get into an invalid internal state that is exploitable.

Construtores

DataContractSerializer(Type)

Inicializa uma nova instância da classe DataContractSerializer para serializar ou desserializar um objeto do tipo especificado.Initializes a new instance of the DataContractSerializer class to serialize or deserialize an object of the specified type.

DataContractSerializer(Type, DataContractSerializerSettings)

Inicializa uma nova instância da classe DataContractSerializer para serializar ou desserializar um objeto do tipo e das configurações especificadas.Initializes a new instance of the DataContractSerializer class to serialize or deserialize an object of the specified type and settings.

DataContractSerializer(Type, IEnumerable<Type>)

Inicializa uma nova instância da classe DataContractSerializer para serializar ou desserializar um objeto do tipo especifico e uma coleção de tipos conhecidos que podem existir no grafo do objeto.Initializes a new instance of the DataContractSerializer class to serialize or deserialize an object of the specified type, and a collection of known types that may be present in the object graph.

DataContractSerializer(Type, IEnumerable<Type>, Int32, Boolean, Boolean, IDataContractSurrogate)

Inicializa uma nova instância da classe DataContractSerializer para serializar ou desserializar um objeto do tipo especificado.Initializes a new instance of the DataContractSerializer class to serialize or deserialize an object of the specified type. Esse método também especifica uma lista de tipos conhecidos que podem estar presentes no grafo de objeto, o número máximo de itens de grafo a serem serializados, os parâmetros para ignorar dados inesperados, a decisão de usar ou não constructos XML não padrão para preservar os dados de referência do objeto no grafo e um substituto para a serialização personalizada.This method also specifies a list of known types that may be present in the object graph, the maximum number of graph items to serialize, parameters to ignore unexpected data, whether to use non-standard XML constructs to preserve object reference data in the graph, and a surrogate for custom serialization.

DataContractSerializer(Type, IEnumerable<Type>, Int32, Boolean, Boolean, IDataContractSurrogate, DataContractResolver)

Inicializa uma nova instância da classe DataContractSerializer para serializar ou desserializar um objeto do tipo especificado.Initializes a new instance of the DataContractSerializer class to serialize or deserialize an object of the specified type. Esse método também especifica uma lista de tipos conhecidos que podem estar presentes no grafo de objeto, o número máximo de itens de grafo a serem serializados, os parâmetros para ignorar dados inesperados, a decisão de usar ou não constructos XML não padrão para preservar os dados de referência do objeto no grafo, um substituto para a serialização personalizada e uma alternativa para mapear declarações xsi:type em tempo de execução.This method also specifies a list of known types that may be present in the object graph, the maximum number of graph items to serialize, parameters to ignore unexpected data, whether to use non-standard XML constructs to preserve object reference data in the graph, a surrogate for custom serialization, and an alternative for mapping xsi:type declarations at run time.

DataContractSerializer(Type, String, String)

Inicializa uma nova instância da classe DataContractSerializer para serializar ou desserializar um objeto do tipo especificado usando o namespace e o elemento raiz XML fornecidos.Initializes a new instance of the DataContractSerializer class to serialize or deserialize an object of the specified type using the supplied XML root element and namespace.

DataContractSerializer(Type, String, String, IEnumerable<Type>)

Inicializa uma nova instância da classe DataContractSerializer para serializar ou desserializar um objeto do tipo especificado.Initializes a new instance of the DataContractSerializer class to serialize or deserialize an object of the specified type. Esse método também especifica o elemento XML raiz e o namespace em dois parâmetros de cadeia de caracteres, bem como uma lista de tipos conhecidos que podem estar presentes no grafo do objeto.This method also specifies the root XML element and namespace in two string parameters as well as a list of known types that may be present in the object graph.

DataContractSerializer(Type, String, String, IEnumerable<Type>, Int32, Boolean, Boolean, IDataContractSurrogate)

Inicializa uma nova instância da classe DataContractSerializer para serializar ou desserializar um objeto do tipo especificado.Initializes a new instance of the DataContractSerializer class to serialize or deserialize an object of the specified type. Esse método também especifica uma lista de tipos conhecidos que podem estar presentes no grafo de objeto, o número máximo de itens de grafo a serem serializados, os parâmetros para ignorar dados inesperados, a decisão de usar ou não constructos XML não padrão para preservar os dados de referência do objeto no grafo, um substituto para a serialização personalizada e o namespace e o elemento XML que contêm o conteúdo.This method also specifies a list of known types that may be present in the object graph, the maximum number of graph items to serialize, parameters to ignore unexpected data, whether to use non-standard XML constructs to preserve object reference data in the graph, a surrogate for custom serialization, and the XML element and namespace that contain the content.

DataContractSerializer(Type, String, String, IEnumerable<Type>, Int32, Boolean, Boolean, IDataContractSurrogate, DataContractResolver)

Inicializa uma nova instância da classe DataContractSerializer para serializar ou desserializar um objeto do tipo especificado.Initializes a new instance of the DataContractSerializer class to serialize or deserialize an object of the specified type. Esse método também especifica uma lista de tipos conhecidos que podem estar presentes no grafo de objeto, o número máximo de itens de grafo a serem serializados, os parâmetros para ignorar dados inesperados, a decisão de usar ou não constructos XML não padrão para preservar os dados de referência do objeto no grafo, um substituto para a serialização personalizada, o elemento XML e o namespace que contêm o conteúdo e uma alternativa para mapear declarações xsi:type em tempo de execução.This method also specifies a list of known types that may be present in the object graph, the maximum number of graph items to serialize, parameters to ignore unexpected data, whether to use non-standard XML constructs to preserve object reference data in the graph, a surrogate for custom serialization, the XML element and namespace that contains the content, and an alternative for mapping xsi:type declarations at run time.

DataContractSerializer(Type, XmlDictionaryString, XmlDictionaryString)

Inicializa uma nova instância da classe DataContractSerializer para serializar ou desserializar um objeto do tipo especificado usando o namespace e o elemento raiz XML por meio de parâmetros do tipo XmlDictionaryString.Initializes a new instance of the DataContractSerializer class to serialize or deserialize an object of the specified type using the XML root element and namespace specified through the parameters of type XmlDictionaryString.

DataContractSerializer(Type, XmlDictionaryString, XmlDictionaryString, IEnumerable<Type>)

Inicializa uma nova instância da classe DataContractSerializer para serializar ou desserializar um objeto do tipo especificado.Initializes a new instance of the DataContractSerializer class to serialize or deserialize an object of the specified type. Esse método também especifica o elemento XML raiz e o namespace em dois parâmetros XmlDictionaryString, bem como uma lista de tipos conhecidos que podem estar presentes no grafo do objeto.This method also specifies the root XML element and namespace in two XmlDictionaryString parameters as well as a list of known types that may be present in the object graph.

DataContractSerializer(Type, XmlDictionaryString, XmlDictionaryString, IEnumerable<Type>, Int32, Boolean, Boolean, IDataContractSurrogate)

Inicializa uma nova instância da classe DataContractSerializer para serializar ou desserializar um objeto do tipo especificado.Initializes a new instance of the DataContractSerializer class to serialize or deserialize an object of the specified type. Esse método também especifica uma lista de tipos conhecidos que podem estar presentes no grafo de objeto, o número máximo de itens de grafo a serem serializados, os parâmetros para ignorar dados inesperados, a decisão de usar ou não constructos XML não padrão para preservar os dados de referência do objeto no grafo, um substituto para a serialização personalizada e parâmetros do XmlDictionaryString que especificam o namespace e o elemento XML que contêm o conteúdo.This method also specifies a list of known types that may be present in the object graph, the maximum number of graph items to serialize, parameters to ignore unexpected data, whether to use non-standard XML constructs to preserve object reference data in the graph, a surrogate for custom serialization, and parameters of XmlDictionaryString that specify the XML element and namespace that contain the content.

DataContractSerializer(Type, XmlDictionaryString, XmlDictionaryString, IEnumerable<Type>, Int32, Boolean, Boolean, IDataContractSurrogate, DataContractResolver)

Inicializa uma nova instância da classe DataContractSerializer para serializar ou desserializar um objeto do tipo especificado.Initializes a new instance of the DataContractSerializer class to serialize or deserialize an object of the specified type. Esse método também especifica uma lista de tipos conhecidos que podem estar presentes no grafo de objeto, o número máximo de itens de grafo a serem serializados, os parâmetros para ignorar dados inesperados, a decisão de usar ou não constructos XML não padrão para preservar os dados de referência do objeto no grafo, um substituto para a serialização personalizada, parâmetros desse XmlDictionaryString que especificam o elemento XML e o namespace que contêm o conteúdo e uma alternativa para mapear declarações xsi:type em tempo de execução.This method also specifies a list of known types that may be present in the object graph, the maximum number of graph items to serialize, parameters to ignore unexpected data, whether to use non-standard XML constructs to preserve object reference data in the graph, a surrogate for custom serialization, parameters of XmlDictionaryString that specify the XML element and namespace that contains the content, and an alternative for mapping xsi:type declarations at run time.

Propriedades

DataContractResolver

Obtém o componente usado para mapear dinamicamente declarações xsi:type de tipos de contrato conhecidos.Gets the component used to dynamically map xsi:type declarations to known contract types.

DataContractSurrogate

Obtém um tipo substituto que pode ampliar o processo de serialização ou desserialização.Gets a surrogate type that can extend the serialization or deserialization process.

IgnoreExtensionDataObject

Obtém um valor que especifica se deve ignorar os dados fornecidos por uma extensão da classe quando a classe está sendo serializada ou desserializada.Gets a value that specifies whether to ignore data supplied by an extension of the class when the class is being serialized or deserialized.

KnownTypes

Obtém uma coleção de tipos que podem estar presentes no grafo de objeto serializado usando essa instância do DataContractSerializer.Gets a collection of types that may be present in the object graph serialized using this instance of the DataContractSerializer.

MaxItemsInObjectGraph

Obtém o número máximo de itens em um grafo de objeto a serem serializados ou desserializados.Gets the maximum number of items in an object graph to serialize or deserialize.

PreserveObjectReferences

Obtém um valor que especifica se constructos XML não padrão devem ser usados para preservar os dados de referência de objeto.Gets a value that specifies whether to use non-standard XML constructs to preserve object reference data.

SerializeReadOnlyTypes

Obtém um valor que especifica se tipos de somente leitura são serializados.Gets a value that specifies whether read-only types are serialized.

Métodos

Equals(Object)

Determina se o objeto especificado é igual ao objeto atual.Determines whether the specified object is equal to the current object.

(Herdado de Object)
GetHashCode()

Serve como a função de hash padrão.Serves as the default hash function.

(Herdado de Object)
GetType()

Obtém o Type da instância atual.Gets the Type of the current instance.

(Herdado de Object)
IsStartObject(XmlDictionaryReader)

Determina se o XmlDictionaryReader está posicionado em um objeto que pode ser desserializado.Determines whether the XmlDictionaryReader is positioned on an object that can be deserialized.

IsStartObject(XmlReader)

Determina se o XmlReader está posicionado em um objeto que pode ser desserializado.Determines whether the XmlReader is positioned on an object that can be deserialized.

MemberwiseClone()

Cria uma cópia superficial do Object atual.Creates a shallow copy of the current Object.

(Herdado de Object)
ReadObject(Stream)

Lê o fluxo XML ou o documento com um Stream e retorna o objeto desserializado.Reads the XML stream or document with a Stream and returns the deserialized object.

(Herdado de XmlObjectSerializer)
ReadObject(XmlDictionaryReader)

Lê o documento ou o fluxo XML com um XmlDictionaryReader e retorna o objeto desserializado.Reads the XML document or stream with an XmlDictionaryReader and returns the deserialized object.

(Herdado de XmlObjectSerializer)
ReadObject(XmlDictionaryReader, Boolean)

Lê o fluxo XML com um XmlDictionaryReader e retorna o objeto desserializado e também especifica se uma verificação é feita para verificar o nome do objeto antes de ler seu valor.Reads the XML stream with an XmlDictionaryReader and returns the deserialized object, and also specifies whether a check is made to verify the object name before reading its value.

ReadObject(XmlDictionaryReader, Boolean, DataContractResolver)

Lê um documento ou fluxo de documentos XML e retorna o objeto desserializado.Reads an XML document or document stream and returns the deserialized object. O método inclui um parâmetro para especificar se o nome do objeto é verificado e validado e um resolvedor para mapear declarações xsi:type em tempo de execução.The method includes a parameter to specify whether the object name is verified is validated, and a resolver for mapping xsi:type declarations at runtime.

ReadObject(XmlReader)

Lê o fluxo XML com um XmlReader e retorna o objeto desserializado.Reads the XML stream with an XmlReader and returns the deserialized object.

ReadObject(XmlReader, Boolean)

Lê o fluxo XML com um XmlReader e retorna o objeto desserializado e também especifica se uma verificação é feita para verificar o nome do objeto antes de ler seu valor.Reads the XML stream with an XmlReader and returns the deserialized object, and also specifies whether a check is made to verify the object name before reading its value.

ToString()

Retorna uma cadeia de caracteres que representa o objeto atual.Returns a string that represents the current object.

(Herdado de Object)
WriteEndObject(XmlDictionaryWriter)

Grava o elemento XML de fechamento usando um XmlDictionaryWriter.Writes the closing XML element using an XmlDictionaryWriter.

WriteEndObject(XmlWriter)

Grava o elemento XML de fechamento usando um XmlWriter.Writes the closing XML element using an XmlWriter.

WriteObject(Stream, Object)

Grava o conteúdo completo (início, conteúdo e final) do objeto no documento XML ou fluxo com o Stream especificado.Writes the complete content (start, content, and end) of the object to the XML document or stream with the specified Stream.

(Herdado de XmlObjectSerializer)
WriteObject(XmlDictionaryWriter, Object)

Grava o conteúdo completo (início, conteúdo e final) do objeto no documento XML ou fluxo com o XmlDictionaryWriter especificado.Writes the complete content (start, content, and end) of the object to the XML document or stream with the specified XmlDictionaryWriter.

(Herdado de XmlObjectSerializer)
WriteObject(XmlDictionaryWriter, Object, DataContractResolver)

Grava todos os dados de objeto (elemento XML inicial, conteúdo e elemento XML de fechamento) para um documento ou fluxo XML usando o XmlDictionaryWriter especificado.Writes all the object data (starting XML element, content, and enclosing element) to an XML document or stream using the specified XmlDictionaryWriter. O método inclui um resolvedor para mapear declarações xsi:type em tempo de execução.The method includes a resolver for mapping xsi:type declarations at runtime.

WriteObject(XmlWriter, Object)

Grava todos os dados de objeto (elemento XML de abertura, conteúdo e elemento XML de fechamento) em um documento ou fluxo XML com um XmlWriter.Writes all the object data (starting XML element, content, and closing element) to an XML document or stream with an XmlWriter.

WriteObjectContent(XmlDictionaryWriter, Object)

Grava o conteúdo de XML usando um XmlDictionaryWriter.Writes the XML content using an XmlDictionaryWriter.

WriteObjectContent(XmlWriter, Object)

Grava o conteúdo de XML usando um XmlWriter.Writes the XML content using an XmlWriter.

WriteStartObject(XmlDictionaryWriter, Object)

Grava o elemento XML de abertura usando um XmlDictionaryWriter.Writes the opening XML element using an XmlDictionaryWriter.

WriteStartObject(XmlWriter, Object)

Grava o elemento XML de abertura usando um XmlWriter.Writes the opening XML element using an XmlWriter.

Métodos de Extensão

GetSerializationSurrogateProvider(DataContractSerializer)

Retorna o provedor de serialização alternativo para esse serializador.Returns the surrogate serialization provider for this serializer.

SetSerializationSurrogateProvider(DataContractSerializer, ISerializationSurrogateProvider)

Especifica um provedor de serialização alternativo para esse DataContractSerializer.Specifies a surrogate serialization provider for this DataContractSerializer.

Aplica-se a

Acesso thread-safe

As instâncias dessa classe são thread-safe, exceto quando a instância é usada com uma implementação IDataContractSurrogate do DataContractResolverou do.Instances of this class are thread safe except when the instance is used with an implementation of the IDataContractSurrogate or DataContractResolver.

Veja também