Linee guida relative alla serializzazioneSerialization guidelines

In questo documento vengono elencate le linee guida da tenere presenti quando si progetta un'API da serializzare.This document lists the guidelines to consider when designing an API to be serialized.

Avviso

La serializzazione binaria può rappresentare un pericolo.Binary serialization can be dangerous. Non deserializzare mai dati da un'origine non attendibile e non eseguire il round trip per i dati serializzati verso sistemi non sotto il proprio controllo.Never deserialize data from an untrusted source and never round-trip serialized data to systems not under your control.

In .NET sono disponibili tre tecnologie di serializzazione principali ottimizzate per vari scenari di serializzazione..NET offers three main serialization technologies that are optimized for various serialization scenarios. La tabella seguente elenca tali tecnologie e i principali tipi .NET correlati.The following table lists these technologies and the main .NET types related to these technologies.

TecnologiaTechnology Classi rilevantiRelevant Classes NoteNotes
Serializzazione dei contratti datiData Contract Serialization DataContractAttribute

DataMemberAttribute

DataContractSerializer

NetDataContractSerializer

DataContractJsonSerializer

ISerializable
Persistenza generaleGeneral persistence

Servizi WebWeb Services

JSONJSON
Serializzazione XMLXML Serialization XmlSerializer Formato XMLXML format
con controllo completowith full control
Serializzazione di runtime (binaria e SOAP)Runtime -Serialization (Binary and SOAP) SerializableAttribute

ISerializable

BinaryFormatter

SoapFormatter
Servizi remoti .NET.NET Remoting

Quando si progettano nuovi tipi, è necessario determinare le eventuali tecnologie che devono essere supportate da tali tipi.When you design new types, you should decide which, if any, of these technologies those types need to support. Le linee guida seguenti descrivono come effettuare la scelta e come fornire tale supporto.The following guidelines describe how to make that choice and how to provide such support. È importante tenere presente che queste linee guida non hanno lo scopo di indicare la tecnologia di serializzazione da utilizzare nell'implementazione dell'applicazione o della libreriaThese guidelines are not meant to help you choose which serialization technology you should use in the implementation of your application or library. poiché non sono correlate direttamente alla progettazione dell'API e pertanto esulano dall'ambito di questo argomento.Such guidelines are not directly related to API design and thus are not within the scope of this topic.

IndicazioniGuidelines

  • Prendere in seria considerazione la serializzazione quando si progettano nuovi tipi.DO think about serialization when you design new types.

    La serializzazione è un aspetto importante della progettazione per qualsiasi tipo poiché è possibile che i programmi debbano rendere persistenti o trasmettere istanze del tipo.Serialization is an important design consideration for any type, because programs might need to persist or transmit instances of the type.

Scelta della tecnologia di serializzazione corretta da supportareChoosing the right serialization technology to support

Un tipo specifico può supportare nessuna, una o più tecnologie di serializzazione.Any given type can support none, one, or more of the serialization technologies.

  • Considerare il supporto della serializzazione dei contratti di dati se è necessario rendere persistenti o usare in servizi Web istanze del tipo.CONSIDER supporting data contract serialization if instances of your type might need to be persisted or used in Web Services.

  • Considerare il supporto della serializzazione XML al posto di o in aggiunta alla serializzazione del contratto dati se è necessario disporre di maggiore controllo sul formato XML creato quando il tipo viene serializzato.CONSIDER supporting the XML serialization instead of or in addition to data contract serialization if you need more control over the XML format that is produced when the type is serialized.

    Questo aspetto può essere necessario in alcuni scenari di interoperabilità in cui è necessario utilizzare un costrutto XML non supportato dalla serializzazione dei contratti dati, ad esempio per creare attributi XML.This may be necessary in some interoperability scenarios where you need to use an XML construct that is not supported by data contract serialization, for example, to produce XML attributes.

  • Considerare il supporto della serializzazione di runtime se è necessario usare istanze del tipo all'esterno dei servizi remoti .NET.CONSIDER supporting runtime serialization if instances of your type need to travel across .NET Remoting boundaries.

  • Evitare il supporto della serializzazione runtime o XML per motivi di persistenza generaleAVOID supporting runtime serialization or XML serialization just for general persistence reasons. e dare la preferenza alla serializzazione dei contratti dati.Prefer data contract serialization instead

Supporto della serializzazione dei contratti di datiSupporting data contract serialization

Affinché i tipi supportino la serializzazione dei contratti dati, è necessario applicare DataContractAttribute al tipo e DataMemberAttribute ai membri (campi e proprietà) del tipo.Types can support data contract serialization by applying the DataContractAttribute to the type and the DataMemberAttribute to the members (fields and properties) of the type.

[DataContract]
class Person
{

    [DataMember]
    string LastName { get; set; }
    [DataMember]
    string FirstName { get; set; }

    public Person(string firstNameValue, string lastNameValue)
    {
        FirstName = firstNameValue;
        LastName = lastNameValue;
    }
}

<DataContract()> Public Class Person
    <DataMember()> Public Property LastName As String
    <DataMember()> Public Property FirstName As String

    Public Sub New(ByVal firstNameValue As String, ByVal lastNameValue As String)
        FirstName = firstNameValue
        LastName = lastNameValue
    End Sub

End Class
  1. Contrassegnare i membri dati del tipo come pubblici se il tipo può essere utilizzato in condizioni di attendibilità parziale.CONSIDER marking data members of your type public if the type can be used in partial trust. In condizioni di attendibilità totale i serializzatori dei contratti dati possono serializzare e deserializzare anche tipi e membri non pubblici, mentre in condizioni di attendibilità parziale possono essere serializzati o deserializzati solo i membri pubblici.In full trust, data contract serializers can serialize and deserialize nonpublic types and members, but only public members can be serialized and deserialized in partial trust.

  2. Implementare un metodo Getter e Setter su tutte le proprietà che dispongono di un elemento Data-MemberAttribute.DO implement a getter and setter on all properties that have Data-MemberAttribute. Affinché il tipo possa essere considerato serializzabile, i serializzatori dei contratti dati richiedono entrambi i metodi.Data contract serializers require both the getter and the setter for the type to be considered serializable. Se il tipo non verrà utilizzato in condizioni di attendibilità parziale, è possibile che una o entrambe le funzioni di accesso alle proprietà non siano pubbliche.If the type won’t be used in partial trust, one or both of the property accessors can be nonpublic.

    [DataContract]
    class Person2
    {
    
        string lastName;
        string firstName;
    
        public Person2(string firstName, string lastName)
        {
            this.lastName = lastName;
            this.firstName = firstName;
        }
    
        [DataMember]
        public string LastName
        { 
            // Implement get and set.
            get { return lastName; }
            private set { lastName = value; }
    
        }
    
        [DataMember]
        public string FirstName
        {
            // Implement get and set.
            get { return firstName; }
            private set { firstName = value; }
        }
    }
    
    <DataContract()> Class Person2
        Private lastNameValue As String
        Private firstNameValue As String
    
        Public Sub New(ByVal firstName As String, ByVal lastName As String)
            Me.lastNameValue = lastName
            Me.firstNameValue = firstName
        End Sub
    
        <DataMember()> Property LastName As String
            Get
                Return lastNameValue
            End Get
    
            Set(ByVal value As String)
                lastNameValue = value
            End Set
    
        End Property
    
        <DataMember()> Property FirstName As String
            Get
                Return firstNameValue
    
            End Get
            Set(ByVal value As String)
                firstNameValue = value
            End Set
        End Property
    
    End Class
    
  3. Utilizzare i callback di serializzazione per l'inizializzazione di istanze deserializzate.CONSIDER using the serialization callbacks for initialization of deserialized instances.

    Poiché i costruttori non vengono chiamati quando gli oggetti sono deserializzati,Constructors are not called when objects are deserialized. qualsiasi logica eseguita durante la costruzione normale deve essere implementata come uno dei callback di serializzazione.Therefore, any logic that executes during normal construction needs to be implemented as one of the serialization callbacks.

    [DataContract]
    class Person3
    {
        [DataMember]
        string lastName;
        [DataMember]
        string firstName;
        string fullName;
    
        public Person3(string firstName, string lastName)
        {
            // This constructor is not called during deserialization.
            this.lastName = lastName;
            this.firstName = firstName;
            fullName = firstName + " " + lastName;
        }
    
        public string FullName
        {
            get { return fullName; }
        }
    
        // This method is called after the object 
        // is completely deserialized. Use it instead of the
        // constructror.
        [OnDeserialized] 
        void OnDeserialized(StreamingContext context)
        {
            fullName = firstName + " " + lastName;
        }
    }
    
    <DataContract()> _
    Class Person3
        <DataMember()> Private lastNameValue As String
        <DataMember()> Private firstNameValue As String
        Dim fullNameValue As String
    
        Public Sub New(ByVal firstName As String, ByVal lastName As String)
            lastNameValue = lastName
            firstNameValue = firstName
            fullNameValue = firstName & " " & lastName
        End Sub
    
        Public ReadOnly Property FullName As String
            Get
                Return fullNameValue
            End Get
        End Property
    
        <OnDeserialized()> Sub OnDeserialized(ByVal context As StreamingContext)
            fullNameValue = firstNameValue & " " & lastNameValue
        End Sub
    End Class
    

    L'oggetto OnDeserializedAttribute è l'attributo di callback più comunemente utilizzato.The OnDeserializedAttribute attribute is the most commonly used callback attribute. Gli altri attributi della famiglia sono OnDeserializingAttribute,The other attributes in the family are OnDeserializingAttribute,
    OnSerializingAttribute, e OnSerializedAttribute.OnSerializingAttribute, and OnSerializedAttribute. Tali attributi possono essere utilizzati rispettivamente per contrassegnare callback eseguiti prima della deserializzazione, prima della serializzazione e dopo la serializzazione.They can be used to mark callbacks that get executed before deserialization, before serialization, and finally, after serialization, respectively.

  4. Considerare l'utilizzo di KnownTypeAttribute per indicare tipi concreti da utilizzare in caso di deserializzazione di un oggetto grafico complesso.CONSIDER using the KnownTypeAttribute to indicate concrete types that should be used when deserializing a complex object graph.

    Ad esempio, se un tipo di un membro dati deserializzato viene rappresentato da una classe astratta, sarà necessario specificare le informazioni sul tipo noto affinché il serializzatore sia in grado di decidere il tipo concreto per cui creare un'istanza e da assegnare al membro.For example, if a type of a deserialized data member is represented by an abstract class, the serializer will need the known type information to decide what concrete type to instantiate and assign to the member. Se il tipo noto non viene specificato tramite l'attributo, dovrà essere passato in modo esplicito al serializzatore, ad esempio passando tipi noti al costruttore relativo, o dovrà essere specificato nel file di configurazione.If the known type is not specified using the attribute, it will need to be passed to the serializer explicitly (you can do it by passing known types to the serializer constructor) or it will need to be specified in the configuration file.

    // The KnownTypeAttribute specifies types to be
    // used during serialization.
    [KnownType(typeof(USAddress))]
    [DataContract]
    class Person4
    {
    
        [DataMember]
        string fullNameValue;
        [DataMember]
        Address address; // Address is abstract
    
        public Person4(string fullName, Address address)
        {
            this.fullNameValue = fullName;
            this.address = address;
        }
    
        public string FullName
        {
            get { return fullNameValue; }
        }
    }
    
    [DataContract]
    public abstract class Address
    {
        public abstract string FullAddress { get; }
    }
    
    [DataContract]
    public class USAddress : Address
    {
    
        [DataMember]
        public string Street { get; set; }
        [DataMember]
        public string City { get; set; }
        [DataMember]
        public string State { get; set; }
        [DataMember]
        public string ZipCode { get; set; }
    
        public override string FullAddress
        {
            get
            {
                return Street + "\n" + City + ", " + State + " " + ZipCode;
            }
        }
    }
    
    <KnownType(GetType(USAddress)), _
    DataContract()> Class Person4
        <DataMember()> Property fullNameValue As String
        <DataMember()> Property addressValue As USAddress ' Address is abstract
    
        Public Sub New(ByVal fullName As String, ByVal address As Address)
            fullNameValue = fullName
            addressValue = address
        End Sub
    
        Public ReadOnly Property FullName() As String
            Get
                Return fullNameValue
            End Get
    
        End Property
    End Class
    
    <DataContract()> Public MustInherit Class Address
        Public MustOverride Function FullAddress() As String
    End Class
    
    <DataContract()> Public Class USAddress
        Inherits Address
        <DataMember()> Public Property Street As String
        <DataMember()> Public City As String
        <DataMember()> Public State As String
        <DataMember()> Public ZipCode As String
    
        Public Overrides Function FullAddress() As String
            Return Street & "\n" & City & ", " & State & " " & ZipCode
        End Function
    End Class
    

    Nei casi in cui l'elenco di tipi noti non sia noto staticamente (quando viene compilata la classe Person), KnownTypeAttribute può puntare anche a un metodo che restituisce un elenco di tipi noti in fase di esecuzione.In cases where the list of known types is not known statically (when the Person class is compiled), the KnownTypeAttribute can also point to a method that returns a list of known types at runtime.

  5. Prendere in considerazione la compatibilità con le versioni precedenti e successive quando si creano o si modificano tipi serializzabili.DO consider backward and forward compatibility when creating or changing serializable types.

    Tenere presente che i flussi serializzati di versioni future del tipo possono essere deserializzati nella versione corrente del tipo e viceversa.Keep in mind that serialized streams of future versions of your type can be deserialized into the current version of the type, and vice versa. È importante comprendere che nelle versioni future del tipo non è possibile modificare il nome, il tipo o l'ordine dei membri dati, anche privati e interni, a meno che non si presti particolare attenzione a mantenere il contratto utilizzando parametri espliciti per gli attributi del contratto dati. Quando si apportano modifiche ai tipi serializzabili, testare la compatibilità della serializzazione,Make sure you understand that data members, even private and internal, cannot change their names, types, or even their order in future versions of the type unless special care is taken to preserve the contract using explicit parameters to the data contract attributes.Test compatibility of serialization when making changes to serializable types. provando ad esempio a deserializzare la nuova versione in una versione precedente e viceversa.Try deserializing the new version into an old version, and vice versa.

  6. Considerare l'implementazione dell'interfaccia IExtensibleDataObject per consentire le sequenze di andata e ritorno tra versioni diverse del tipo.CONSIDER implementing IExtensibleDataObject interface to allow round-tripping between different versions of the type.

    L'interfaccia consente al serializzatore di verificare che durante le sequenze di andata e ritorno non venga perso alcun dato.The interface allows the serializer to ensure that no data is lost during round-tripping. Nella proprietà ExtensionData vengono archiviati tutti i dati della versione futura del tipo non conosciuto nella versione corrente.The ExtensionData property stores any data from the future version of the type that is unknown to the current version. Successivamente, quando la versione corrente viene serializzata e deserializzata in una versione futura, i dati aggiuntivi saranno disponibili nel flusso serializzato tramite il valore della proprietà ExtensionData.When the current version is subsequently serialized and deserialized into a future version, the additional data will be available in the serialized stream through the ExtensionData property value.

    // Implement the IExtensibleDataObject interface.
    [DataContract]
    class Person5 : IExtensibleDataObject
    {
        ExtensionDataObject serializationData;
        [DataMember]
        string fullNameValue;
    
        public Person5(string fullName)
        {
            this.fullNameValue = fullName;
        }
    
        public string FullName
        {
            get { return fullNameValue; }
        }
                
        ExtensionDataObject IExtensibleDataObject.ExtensionData
        {
            get 
            {                 
                return serializationData; 
            }
            set { serializationData = value; }
        }
    }
    
    <DataContract()> Class Person5
        Implements IExtensibleDataObject
        <DataMember()> Dim fullNameValue As String
    
        Public Sub New(ByVal fullName As String)
            fullName = fullName
        End Sub
    
        Public ReadOnly Property FullName
            Get
                Return fullNameValue
            End Get
        End Property
        Private serializationData As ExtensionDataObject
        Public Property ExtensionData As ExtensionDataObject Implements IExtensibleDataObject.ExtensionData
            Get
                Return serializationData
            End Get
            Set(ByVal value As ExtensionDataObject)
                serializationData = value
            End Set
        End Property
    End Class
    

    Per altre informazioni, vedere Contratti di dati compatibili con versioni successive.For more information, see Forward-Compatible Data Contracts.

Supporto della serializzazione XMLSupporting XML serialization

La serializzazione dei contratti dati è la tecnologia di serializzazione principale e predefinita in .NET Framework, anche se non supporta tutti gli scenari di serializzazione,Data contract serialization is the main (default) serialization technology in the .NET Framework, but there are serialization scenarios that data contract serialization does not support. ad esempio non consente di controllare completamente la forma del codice XML creato o utilizzato dal serializzatore.For example, it does not give you full control over the shape of XML produced or consumed by the serializer. Se è richiesto un controllo così dettagliato, è necessario usare la serializzazione XML nonché progettare i tipi in modo che supportino questa tecnologia di serializzazione.If such fine control is required, XML serialization has to be used, and you need to design your types to support this serialization technology.

  1. Evitare di progettare in maniera specifica i tipi per la serializzazione XML, a meno che non sia presente un motivo estremamente valido per controllare la forma del codice XML creato.AVOID designing your types specifically for XML Serialization, unless you have a very strong reason to control the shape of the XML produced. Questa tecnologia è stata sostituita dalla serializzazione dei contratti dati descritta nella sezione precedente.This serialization technology has been superseded by the Data Contract Serialization discussed in the previous section.

    In altre parole, non applicare attributi dallo spazio dei nomi System.Xml.Serialization ai nuovi tipi, a meno che non si sia certi che il tipo verrà utilizzato con la serializzazione XML.In other words, don’t apply attributes from the System.Xml.Serialization namespace to new types, unless you know that the type will be used with XML Serialization. L'esempio seguente mostra come è possibile usare System.Xml.Serialization per controllare la forma del codice XML creato.The following example shows how System.Xml.Serialization can be used to control the shape of the XML -produced.

    public class Address2
    {
        [System.Xml.Serialization.XmlAttribute] // Serialize as XML attribute, instead of an element.
        public string Name { get { return "Poe, Toni"; } set { } }
        [System.Xml.Serialization.XmlElement(ElementName = "StreetLine")] // Explicitly name the element.
        public string Street = "1 Main Street";        
    }
    
    Public Class Address2
        ' Supports XML Serialization.
        <System.Xml.Serialization.XmlAttribute()> _
        Public ReadOnly Property Name As String ' Serialize as XML attribute, instead of an element.
            Get
                Return "Poe, Toni"
            End Get
        End Property
        <System.Xml.Serialization.XmlElement(ElementName:="StreetLine")> _
        Public Street As String = "1 Main Street"  ' Explicitly names the element 'StreetLine'.
    End Class
    
  2. Considerare l'implementazione dell'interfaccia IXmlSerializable se si desidera maggiore controllo sulla forma del codice XML serializzato rispetto a quello offerto applicando gli attributi della serializzazione XML.CONSIDER implementing the IXmlSerializable interface if you want even more control over the shape of the serialized XML than what’s offered by applying the XML Serialization attributes. Due metodi per l'interfaccia ReadXml e WriteXml, consentono di controllare completamente il flusso XML serializzato.Two methods of the interface, ReadXml and WriteXml, allow you to fully control the serialized XML stream. È inoltre possibile controllare l'XML Schema generato per il tipo applicando l'attributo XmlSchemaProviderAttribute.You can also control the XML schema that gets generated for the type by applying the XmlSchemaProviderAttribute attribute.

Supporto della serializzazione di runtimeSupporting runtime serialization

La serializzazione di runtime è una tecnologia usata dai servizi remoti .NET.Runtime serialization is a technology used by .NET Remoting. Se si ritiene che i tipi verranno trasportati utilizzando i servizi remoti .NET, è necessario verificare che supportino la serializzazione di runtime.If you think your types will be transported using .NET Remoting, you need to make sure they support runtime serialization.

Il supporto di base per la serializzazione di runtime può essere fornito applicando l'attributo SerializableAttribute e scenari più avanzati prevedono l'implementazione di un semplice modello di runtime serializzabile (implementazione di ISerializable e specifica di un costruttore di serializzazione).The basic support for runtime serialization can be provided by applying the SerializableAttribute attribute, and more advanced scenarios involve implementing a simple runtime serializable pattern (implement -ISerializable and provide a serialization constructor).

  1. Considerare il supporto della serializzazione di runtime se i tipi verranno utilizzati con i servizi remoti .NET.CONSIDER supporting runtime serialization if your types will be used with .NET Remoting. Lo spazio dei nomi System.AddIn, ad esempio, usa i servizi remoti .NET e pertanto tutti i tipi scambiati tra i componenti aggiuntivi System.AddIn devono supportare la serializzazione di runtime.For example, the System.AddIn namespace uses .NET Remoting, and so all types exchanged between System.AddIn add-ins need to support runtime serialization.

    // Apply SerializableAttribute to support runtime serialization.
    [Serializable]
    public class Person6 
    {
        // Code not shown.
    }
    
    <Serializable()> Public Class Person6 ' Support runtime serialization with the SerializableAttribute.
    
        ' Code not shown.
    End Class
    
  2. Considerare l'implementazione del modello di runtime serializzabile se si vuole il controllo completo sul processo di serializzazione,CONSIDER implementing the runtime serializable pattern if you want complete control over the serialization process. ad esempio se si desidera trasformare i dati quando vengono serializzati o deserializzati.For example, if you want to transform data as it gets serialized or deserialized.

    Il modello è molto semplice.The pattern is very simple. È sufficiente implementare l'interfaccia ISerializable e specificare un costruttore speciale utilizzato quando l'oggetto viene deserializzato.All you need to do is implement the ISerializable interface and provide a special constructor that is used when the object is deserialized.

    // Implement the ISerializable interface for more control.
    [Serializable]
    public class Person_Runtime_Serializable : ISerializable
    {
        string fullName;
    
        public Person_Runtime_Serializable() { }
        protected Person_Runtime_Serializable(SerializationInfo info, StreamingContext context){
            if (info == null) throw new System.ArgumentNullException("info");
            fullName = (string)info.GetValue("name", typeof(string));
        }
        [SecurityPermission(SecurityAction.LinkDemand,
        Flags = SecurityPermissionFlag.SerializationFormatter)]
        void ISerializable.GetObjectData(SerializationInfo info,
                StreamingContext context) {
            if (info == null) throw new System.ArgumentNullException("info");
            info.AddValue("name", fullName);
        }
    
        public string FullName
        {
            get { return fullName; }
            set { fullName = value; }
        }
    }
    
    ' Implement the ISerializable interface for more control.
    <Serializable()> Public Class Person_Runtime_Serializable
        Implements ISerializable
    
        Private fullNameValue As String
    
        Public Sub New()
            ' empty constructor.
        End Sub
        Protected Sub New(ByVal info As SerializationInfo, _
                          ByVal context As StreamingContext)
            If info Is Nothing Then
                Throw New System.ArgumentNullException("info")
                FullName = CType(info.GetValue("name", GetType(String)), String)
            End If
        End Sub
    
        Private Sub GetObjectData(ByVal info As SerializationInfo, _
                                  ByVal context As StreamingContext) _
                              Implements ISerializable.GetObjectData
            If info Is Nothing Then
                Throw New System.ArgumentNullException("info")
                info.AddValue("name", FullName)
            End If
        End Sub
    
        Public Property FullName As String
    
            Get
                Return fullNameValue
            End Get
            Set(ByVal value As String)
                fullNameValue = value
    
            End Set
        End Property
    
    End Class
    
    
  3. Creare il costruttore di serializzazione in modo protetto e specificare due parametri digitati e denominati esattamente come indicato nell'esempio.DO make the serialization constructor protected and provide two parameters typed and named exactly as shown in the sample here.

    protected Person_Runtime_Serializable(SerializationInfo info, StreamingContext context){
    
    Protected Sub New(ByVal info As SerializationInfo, _
                      ByVal context As StreamingContext)
    
  4. Implementare i membri ISerializable in modo protetto.DO implement the ISerializable members explicitly.

    void ISerializable.GetObjectData(SerializationInfo info,
            StreamingContext context) {
    
    Private Sub GetObjectData(ByVal info As SerializationInfo, _
                              ByVal context As StreamingContext) _
                          Implements ISerializable.GetObjectData
    
  5. Applicare una richiesta di collegamento all'implementazione di ISerializable.GetObjectData.DO apply a link demand to ISerializable.GetObjectData implementation. per garantire che solo un nucleo completamente attendibile e il serializzatore di runtime dispongano dell'accesso al membro.This ensures that only fully trusted core and the runtime serializer have access to the member.

    [SecurityPermission(SecurityAction.LinkDemand,
    Flags = SecurityPermissionFlag.SerializationFormatter)]
    
    <Serializable()> Public Class Person_Runtime_Serializable2
        Implements ISerializable
        <SecurityPermission(SecurityAction.LinkDemand, Flags:=SecurityPermissionFlag.SerializationFormatter)> _
        Private Sub GetObjectData(ByVal info As System.Runtime.Serialization.SerializationInfo, _
                                 ByVal context As System.Runtime.Serialization.StreamingContext) _
                             Implements System.Runtime.Serialization.ISerializable.GetObjectData
            ' Code not shown.
        End Sub
    End Class
    

Vedere ancheSee also