Exportar (0) Imprimir
Expandir todo

DataContractSerializer (Clase)

Actualización: noviembre 2007

Serializa y deserializa una instancia de un tipo en una secuencia o en un documento XML utilizando un contrato de datos proporcionado. Esta clase no puede heredarse.

Espacio de nombres:  System.Runtime.Serialization
Ensamblado:  System.Runtime.Serialization (en System.Runtime.Serialization.dll)

public sealed class DataContractSerializer : XmlObjectSerializer
public final class DataContractSerializer extends XmlObjectSerializer
public final class DataContractSerializer extends XmlObjectSerializer

Utilice la clase DataContractSerializer para serializar y deserializar instancias de un tipo en una secuencia o en un documento XML. Por ejemplo, puede crear un tipo denominado Person con propiedades que contienen datos esenciales, como un nombre y una dirección. A continuación puede crear y manipular una instancia de la clase Person y escribir todos sus valores de propiedad en un documento XML para recuperarlo posteriormente o en una secuencia XML para su transporte inmediato. Más importante, DataContractSerializer se utiliza para serializar y deserializar los datos enviados en mensajes Windows Communication Foundation (WCF). Aplique el atributo DataContractAttribute a las clases y el atributo DataMemberAttribute a los miembros de clase para especificar las propiedades y los campos que se serializan.

Para obtener una lista de los tipos que se pueden serializar, vea Tipos admitidos por el serializador de contrato de datos.

Para utilizar DataContractSerializer, cree primero una instancia de una clase y un objeto adecuado para escribir o leer el formato; por ejemplo, una instancia de XmlDictionaryWriter. A continuación, llame al método WriteObject para conservar los datos. Para recuperar los datos, cree un objeto adecuado para leer el formato de datos (como un XmlDictionaryReader para un documento XML) y llame al método ReadObject.

Para obtener más información acerca de cómo usar DataContractSerializer, vea Serialización y deserialización.

Puede establecer el tipo de un serializador del contrato de datos utilizando el elemento <dataContractSerializer> en un archivo de configuración de la aplicación del cliente.

Preparación de clases para serialización o deserialización

DataContractSerializer se utiliza en combinación con las clases DataContractAttribute y DataMemberAttribute. Para preparar una clase para la serialización, aplique DataContractAttribute a la clase. Para cada miembro de la clase que devuelve datos que desea serializar, aplique DataMemberAttribute. Puede serializar campos y propiedades sin tener en cuenta la accesibilidad: privado, protegido, interno, interno protegido o público.

Por ejemplo, su esquema especifica un Customer con una propiedad ID, pero ya tiene una aplicación existente que utiliza un tipo denominado Person con una propiedad Name. Para crear un tipo que cumple el contrato, primero aplique DataContractAttribute a la clase. A continuación, aplique DataMemberAttribute a cada campo o propiedad que desea serializar.

ms405768.alert_note(es-es,VS.90).gifNota:

Puede aplicar DataMemberAttribute a los miembros privados y públicos.

El formato final del XML no tiene por qué ser texto. Al contrario, DataContractSerializer escribe los datos como conjunto de información de XML, lo que le permite escribir los datos en cualquier formato reconocido por XmlReader y XmlWriter. Se recomienda que utilice las clases XmlDictionaryReader y XmlDictionaryWriter para leer y escribir porque ambas están optimizadas para trabajar con DataContractSerializer.

Si está creando una clase que tiene campos o propiedades que se deben rellenar antes de que se produzca la serialización o la deserialización, utilice atributos de devolución de llamada, como se describe en Devoluciones de llamadas en la serialización tolerante a versiones.

Agregar a la colección de tipos conocidos

Cuando se serializa o deserializa un objeto, se requiere que el tipo sea "conocido" por DataContractSerializer. Comience creando una instancia de una clase que implemente IEnumerable<T> (como List<T>) y agregando los tipos conocidos a la colección. A continuación, cree una instancia de DataContractSerializer utilizando una de las sobrecargas que toma IEnumerable<T> (por ejemplo, DataContractSerializer(Type, IEnumerable<Type>)).

ms405768.alert_note(es-es,VS.90).gifNota:

A diferencia de otros tipos primitivos, la estructura DateTimeOffset no es un tipo conocido de forma predeterminada, por lo que se debe agregar manualmente a la lista de tipos conocidos (vea Tipos conocidos de contratos de datos).

Compatibilidad con versiones posteriores

DataContractSerializer entiende contratos de datos que se han diseñado para ser compatibles con versiones futuras del contrato. Tales tipos implementan la interfaz IExtensibleDataObject. La interfaz contiene la propiedad ExtensionData que devuelve un objeto ExtensionDataObject. Para obtener más información, vea Contratos de datos compatibles con el reenvío.

Ejecutar bajo confianza parcial

Al crear instancias del objeto de destino durante la deserialización, DataContractSerializer no llama al constructor del objeto de destino. Si crea un tipo de [DataContract] que es accesible desde la confianza parcial (es decir, es público y está en un ensamblado al que se aplica el atributo AllowPartiallyTrustedCallers) y que realiza algunas acciones relacionadas con la seguridad, debe ser consciente de que no se llama al constructor. En particular, las técnicas siguientes no funcionan:

  • Durante la deserialización bajo confianza parcial, intentar restringir el acceso de confianza parcial haciendo el constructor interno o privado o agregando LinkDemand al constructor no tendrá ningún efecto.

  • Si codifica la clase que supone que el constructor se ha ejecutado, la clase puede entrar en un estado interno no válido que es explotable.

El código de ejemplo siguiente muestra un tipo denominado Person que es serializado por DataContractSerializer. El atributo DataContractAttribute se aplica a la clase y DataMemberAttribute se aplica a los miembros para indicar a DataContractSerializer qué debe serializar.

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


System.Object
  System.Runtime.Serialization.XmlObjectSerializer
    System.Runtime.Serialization.DataContractSerializer

Todos los miembros static (Shared en Visual Basic) públicos de este tipo son seguros para la ejecución de subprocesos. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.

Windows Vista, Windows XP SP2, Windows Server 2003

.NET Framework y .NET Compact Framework no admiten todas las versiones de cada plataforma. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

.NET Framework

Compatible con: 3.5, 3.0

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft