Exportar (0) Imprimir
Expandir todo

Exception.GetObjectData (Método)

Actualización: noviembre 2007

Cuando se reemplaza en una clase derivada, establece SerializationInfo con información sobre la excepción.

Espacio de nombres:  System
Ensamblado:  mscorlib (en mscorlib.dll)

[SecurityPermissionAttribute(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.SerializationFormatter)]
public virtual void GetObjectData(
	SerializationInfo info,
	StreamingContext context
)
/** @attribute SecurityPermissionAttribute(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.SerializationFormatter) */
public void GetObjectData(
	SerializationInfo info,
	StreamingContext context
)
public function GetObjectData(
	info : SerializationInfo, 
	context : StreamingContext
)

Parámetros

info
Tipo: System.Runtime.Serialization.SerializationInfo
Constructor SerializationInfo que contiene los datos serializados del objeto que hacen referencia a la excepción que se va a producir.
context
Tipo: System.Runtime.Serialization.StreamingContext
Enumeración StreamingContext que contiene información contextual sobre el origen o el destino.

Implementaciones

ISerializable.GetObjectData(SerializationInfo, StreamingContext)
_Exception.GetObjectData(SerializationInfo, StreamingContext)

ExcepciónCondición
ArgumentNullException

El parámetro info es una referencia nula (Nothing en Visual Basic).

GetObjectData establece SerializationInfo con todos los datos del objeto de excepción destinados a la serialización. Durante la deserialización, la excepción se reconstituye a partir de la información SerializationInfo transmitida en la secuencia.

En el siguiente ejemplo de código se define una clase serializable derivada Exception que implementa GetObjectData, se realizan pequeños cambios en dos propiedades y, a continuación, se llama a la clase base para llevar a cabo la serialización. En el ejemplo se fuerza un error de división por 0 y luego se crea una instancia de la excepción derivada. El código serializa la instancia en un archivo, deserializa el archivo en una nueva excepción que produce y, después, detecta y muestra los datos de la excepción.

// Example for the Exception( SerializationInfo, StreamingContext )
// constructor and the Exception.GetObjectData( SerializationInfo, 
// StreamingContext ) method.
using System;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Soap;
using System.Security.Permissions;

namespace NDP_UE_CS
{
    // Define a serializable derived exception class.
    [Serializable()]
    class SecondLevelException : Exception, ISerializable
    {
        // This public constructor is used by class instantiators.
        public SecondLevelException( string message, Exception inner ) :
            base( message, inner )
        {
            HelpLink = "http://MSDN.Microsoft.com";
            Source = "Exception_Class_Samples";
        }

        // This protected constructor is used for deserialization.
        protected SecondLevelException( SerializationInfo info, 
            StreamingContext context ) :
                base( info, context )
        { }

        // GetObjectData performs a custom serialization.
        [SecurityPermissionAttribute(SecurityAction.Demand,SerializationFormatter=true)]
        public override void GetObjectData( SerializationInfo info, 
            StreamingContext context ) 
        {
            // Change the case of two properties, and then use the 
            // method of the base class.
            HelpLink = HelpLink.ToLower( );
            Source = Source.ToUpper( );

            base.GetObjectData( info, context );
        }
    }

    class SerializationDemo 
    {
        public static void Main() 
        {
            Console.WriteLine( 
                "This example of the Exception constructor " +
                "and Exception.GetObjectData\nwith Serialization" +
                "Info and StreamingContext parameters " +
                "generates \nthe following output.\n" );

            try
            {
                // This code forces a division by 0 and catches the 
                // resulting exception.
                try
                {
                    int  zero = 0;
                    int  ecks = 1 / zero;
                }
                catch( Exception ex )
                {
                    // Create a new exception to throw again.
                    SecondLevelException newExcept =
                        new SecondLevelException( 
                            "Forced a division by 0 and threw " +
                            "another exception.", ex );

                    Console.WriteLine( 
                        "Forced a division by 0, caught the " +
                        "resulting exception, \n" +
                        "and created a derived exception:\n" );
                    Console.WriteLine( "HelpLink: {0}", 
                        newExcept.HelpLink );
                    Console.WriteLine( "Source:   {0}", 
                        newExcept.Source );

                    // This FileStream is used for the serialization.
                    FileStream stream = 
                        new FileStream( "NewException.dat", 
                            FileMode.Create );

                    try
                    {
                        // Serialize the derived exception.
                        SoapFormatter formatter = 
                            new SoapFormatter( null,
                                new StreamingContext( 
                                    StreamingContextStates.File ) );
                        formatter.Serialize( stream, newExcept );

                        // Rewind the stream and deserialize the 
                        // exception.
                        stream.Position = 0;
                        SecondLevelException deserExcept = 
                            (SecondLevelException)
                                formatter.Deserialize( stream );

                        Console.WriteLine( 
                            "\nSerialized the exception, and then " +
                            "deserialized the resulting stream " +
                            "into a \nnew exception. " +
                            "The deserialization changed the case " +
                            "of certain properties:\n" );

                        // Throw the deserialized exception again.
                        throw deserExcept;
                    }
                    catch( SerializationException se )
                    {
                        Console.WriteLine( "Failed to serialize: {0}", 
                            se.ToString( ) );
                    }
                    finally
                    {
                        stream.Close( );
                    }
                }
            }
            catch( Exception ex )
            {
                Console.WriteLine( "HelpLink: {0}", ex.HelpLink );
                Console.WriteLine( "Source:   {0}", ex.Source );

                Console.WriteLine( );
                Console.WriteLine( ex.ToString( ) );
            }
        }
    }
}

/*
This example of the Exception constructor and Exception.GetObjectData
with SerializationInfo and StreamingContext parameters generates
the following output.

Forced a division by 0, caught the resulting exception,
and created a derived exception:

HelpLink: http://MSDN.Microsoft.com
Source:   Exception_Class_Samples

Serialized the exception, and then deserialized the resulting stream into a
new exception. The deserialization changed the case of certain properties:

HelpLink: http://msdn.microsoft.com
Source:   EXCEPTION_CLASS_SAMPLES

NDP_UE_CS.SecondLevelException: Forced a division by 0 and threw another except
ion. ---> System.DivideByZeroException: Attempted to divide by zero.
   at NDP_UE_CS.SerializationDemo.Main()
   --- End of inner exception stack trace ---
   at NDP_UE_CS.SerializationDemo.Main()
*/


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

.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, 2.0, 1.1, 1.0

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft