Exportar (0) Imprimir
Expandir Tudo
Este artigo foi traduzido por máquina. Coloque o ponteiro do mouse sobre as frases do artigo para ver o texto original. Mais informações.
Tradução
Original

Interface ISerializable

Permite um objeto controlar sua própria serialização e desserialização.

Namespace:  System.Runtime.Serialization
Assembly:  mscorlib (em mscorlib.dll)

[ComVisibleAttribute(true)]
public interface ISerializable

Qualquer classe que pode ser serializado deve ser marcada com o SerializableAttribute. Se precisar de uma classe controlar seu processo de serialização, ela pode implementar o ISerializable interface. The Formatter chamadas a GetObjectData em time de serialização e preenche a fornecido SerializationInfo com todos os dados necessários para representar o objeto. The Formatter cria um SerializationInfo com o tipo do objeto no gráfico. Objetos que precisam enviar proxies para si mesmos podem usar o FullTypeName e AssemblyName métodos em SerializationInfo Para alterar as informações transmitidas.

No caso de herança da classe, é possível serializar uma classe que derive de uma classe base que implementa ISerializable.Nesse caso, a classe derivada deve chamar a implementação de GetObjectData da classe base usando sua implementação de GetObjectData.Caso contrário, os dados a partir da classe base não serão serializados.

The ISerializable interface implica um construtor com o (Construtor de assinaturaSerializationInfo informações, StreamingContext contexto). Durante a desserialização, o construtor corrente é chamado somente depois que os dados no SerializationInfo tem sido desserializada, o formatador. Em geral, esse construtor deve ser protegido se a classe não está lacrada.

A ordem em que objetos são desserializados não pode ser garantida.Por exemplo, se um tipo faz referência a um tipo que não tenha sido desserializado ainda, uma exceção ocorrerá.Se você estiver criando tipos que possuem tais dependências, você pode contornar o problema, Implementando o IDeserializationCallback interface e o OnDeserialization método.

A arquitetura de serialização controla sistema autônomo tipos de objeto que se estendem MarshalByRefObject sistema autônomo mesmos tipos de estender Object. Esses tipos podem ser marcados com o SerializableAttribute e implementar o ISerializable interface sistema autônomo qualquer Outros tipo de objeto. Seu estado do objeto será capturado e persistente para o fluxo.

Quando esses tipos estão sendo usados por meio de System.Runtime.Remoting, a infra-estrutura do comunicação remota fornece um substituto preempts serialização típica e, em vez disso, serializa um proxy para o MarshalByRefObject. Um substituto é um auxiliar que sabe como serializar e desserializar objetos de um tipo específico.O proxy, invisível para o usuário na maioria dos casos, será do tipo ObjRef.

sistema autônomo um padrão de design geral seria incomum para uma classe ambos ser marcadas com o atributo pode ser serializado e estender MarshalByRefObject. Os desenvolvedores devem pensar cuidadosamente os possíveis cenários de serialização e a comunicação remota ao combinar essas duas características.Um exemplo onde isso pode ser aplicável é com um MemoryStream. Embora a classe base de MemoryStream (Stream) se estende da MarshalByRefObject, é possível capturar o estado de um MemoryStream e restauração em poderá. Portanto, talvez, seja significativo para serializar o estado deste fluxo em um banco de dados e restaurá-lo em algum momento posterior em time.No entanto, quando usado por meio de comunicação remota, um objeto desse tipo poderia ser intermediadas por proxy.

Para obter mais informações sobre a serialização de classes que estendem MarshalByRefObject, consulte RemotingSurrogateSelector. Para obter mais informações sobre como implementar ISerializable, consulte Serialização Personalizada.

Observações para Implementers:

Implemente esta interface para permitir que um objeto fazer parte de seu próprio serialização e desserialização.

O exemplo de código a seguir demonstra o uso do ISerializable interface para definir um comportamento de serialização personalizada para uma classe.

using System;
using System.Web;
using System.IO;
using System.Collections;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Serialization;
using System.Security.Permissions;


// There should be only one instance of this type per AppDomain.
[Serializable]
publicsealedclass Singleton : ISerializable 
{
    // This is the one instance of this type.privatestaticreadonly Singleton theOneObject = new Singleton();

    // Here are the instance fields.private string someString_value;
    private Int32 someNumber_value;

   public string SomeString
   {
       get{return someString_value;}
       set{someString_value = value;}
   }

   public Int32 SomeNumber
   {
       get{return someNumber_value;}
       set{someNumber_value = value;}
   }

    // Private constructor allowing this type to construct the Singleton.private Singleton() 
    { 
        // Do whatever is necessary to initialize the Singleton.
        someString_value = "This is a string field";
        someNumber_value = 123;
    }

    // A method returning a reference to the Singleton.publicstatic Singleton GetSingleton() 
    { 
        return theOneObject; 
    }

    // A method called when serializing a Singleton.
    [SecurityPermissionAttribute(SecurityAction.LinkDemand, 
    Flags=SecurityPermissionFlag.SerializationFormatter)]
    void ISerializable.GetObjectData(
        SerializationInfo info, StreamingContext context) 
    {
        // Instead of serializing this object, // serialize a SingletonSerializationHelp instead.
        info.SetType(typeof(SingletonSerializationHelper));
        // No other values need to be added.
    }

    // Note: ISerializable's special constructor is not necessary // because it is never called.
}


[Serializable]
internalsealedclass SingletonSerializationHelper : IObjectReference 
{
    // This object has no fields (although it could).// GetRealObject is called after this object is deserialized.public Object GetRealObject(StreamingContext context) 
    {
        // When deserialiing this object, return a reference to // the Singleton object instead.return Singleton.GetSingleton();
    }
}


class App 
{
    [STAThread]
    staticvoid Main() 
    {
        FileStream fs = new FileStream("DataFile.dat", FileMode.Create);

        try 
        {
            // Construct a BinaryFormatter and use it // to serialize the data to the stream.
            BinaryFormatter formatter = new BinaryFormatter();

            // Create an array with multiple elements refering to // the one Singleton object.
            Singleton[] a1 = { Singleton.GetSingleton(), Singleton.GetSingleton() };

            // This displays "True".
            Console.WriteLine(
                "Do both array elements refer to the same object? " + 
                (a1[0] == a1[1]));     

            // Serialize the array elements.
            formatter.Serialize(fs, a1);

            // Deserialize the array elements.
            fs.Position = 0;
            Singleton[] a2 = (Singleton[]) formatter.Deserialize(fs);

            // This displays "True".
            Console.WriteLine("Do both array elements refer to the same object? " 
                + (a2[0] == a2[1])); 

            // This displays "True".
            Console.WriteLine("Do all array elements refer to the same object? " 
                + (a1[0] == a2[0]));
        }   
        catch (SerializationException e) 
        {
            Console.WriteLine("Failed to serialize. Reason: " + e.Message);
            throw;
        }
        finally 
        {
            fs.Close();
        }
    }
}


Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP Starter Edition, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98

o.NET Framework e.NET Compact Framework não oferecem suporte a todas as versões de cada plataforma. Para obter uma lista de versões suportadas, consulte Requisitos de sistema do .NET framework.

.NET Framework

Compatível com: 3.5, 3.0, 2.0, 1.1, 1.0

Contribuições da comunidade

ADICIONAR
A Microsoft está realizando uma pesquisa online para saber sua opinião sobre o site do MSDN. Se você optar por participar, a pesquisa online lhe será apresentada quando você sair do site do MSDN.

Deseja participar?
Mostrar:
© 2015 Microsoft