IObjectReference.GetRealObject(StreamingContext) Método

Definición

Espacio de nombres:

System.Runtime.Serialization

Ensamblado:

System.Runtime.dll

Ensamblado:

mscorlib.dll

Ensamblado:

netstandard.dll

Devuelve el objeto real que se debe deserializar, en lugar del objeto especificado por la secuencia serializada.

C#

public object GetRealObject (System.Runtime.Serialization.StreamingContext context);

C#

[System.Security.SecurityCritical]
public object GetRealObject (System.Runtime.Serialization.StreamingContext context);

Parámetros

context

StreamingContext

StreamingContext desde donde se deserializa el objeto actual.

Devoluciones

Object

Objeto real que se coloca en el gráfico.

Atributos

SecurityCriticalAttribute

Excepciones

SecurityException

El llamador no dispone del permiso requerido. La llamada no funcionará en un servidor con un nivel de confianza medio.

Ejemplos

C#

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

// There should be only one instance of this type per AppDomain.
[Serializable]
public sealed class Singleton : ISerializable
{
    // This is the one instance of this type.
    private static readonly 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.
    public static Singleton GetSingleton()
    {
        return theOneObject;
    }

    // A method called when serializing a Singleton.
    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]
internal sealed class SingletonSerializationHelper : IObjectReference
{
    // This object has no fields (although it could).

    // GetRealObject is called after this object is deserialized.
    public Object GetRealObject(StreamingContext context)
    {
        // When deserializing this object, return a reference to
        // the Singleton object instead.
        return Singleton.GetSingleton();
    }
}

class App
{
    [STAThread]
    static void 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();
        }
    }
}

Comentarios

Este método es útil en una situación de comunicación remota en la que se serializa un objeto de creador de proxy, no en un objeto real. Cuando el objeto proxy-creator se deserializa, la deserialización llama a su GetRealObject método . En este punto, el objeto proxy-creator crea una nueva instancia del objeto proxy que hace referencia al objeto real original, quizás en un equipo remoto. Por último, la recolección de elementos no utilizados descarta y reclama el objeto proxy-creator.

Por ejemplo, considere cómo Type se serializan los objetos. En lugar de transmitir los datos del Type objeto , el sistema transmite un objeto titular con el nombre del objeto de tipo e información sobre el ensamblado donde se encuentra en un objeto que implementa IObjectReference. Cuando el nombre de tipo y el nombre del ensamblado están disponibles, la infraestructura de deserialización llama GetRealObject al objeto de titular que se ha transmitido. Este titular devuelve el Type objeto que se inserta en el gráfico.

Se aplica a