Serialisieren

Um die Daten von Klassen für die Speicherung und Wiederherstellung zu serialisieren, gibt verschiedene Möglichkeiten.
1. Einfache Serialisierung:
Die zu serialisierende Klasse wird mit dem Attribut [Serializable] versehen. Es werden alle Membervariablen serialisiert.
2. Benutzerdefinierte Serialisierung:
Wie 1. , die zu serialisierende Klasse implementiert aber die Schnittstelle ISerializable. Es muss

void GetObjectData ( SerializationInfo* info,
                     StreamingContext   context )

und der spezielle Deserialisierungs-Konstruktor

protected MyClass ( SerializationInfo* info,
                    StreamingContext   context )

implementiert werden. Damit kann die Serialisierung bzw. die Deserialisierung zusätzlich beeinflusst werden, um z.B. die Konsistenz der Daten zu garantieren. Der Zugriff auf vertrauliche Informationen über die Methode GetObjectData kann noch durch das Attribut

[ SecurityPermissionAttribute
  ( SecurityAction::Demand,
    SerializationFormatter = true )]

eingeschränkt werden. Beispiel:

  • [Serializable]
  • public __gc class Class2Serial
                      : public ISerializable
  • {
    • public:
    • String* serialVariable;
    • Class2Serial ( String* strVar )
    • {
      • serialVariable = strVar;
    • }
    • void GetObjectData (
                SerializationInfo* info,
                StreamingContext   context )
    • {
      • info->AddValue ( “serialVariable”,
                         serialVariable );
    • }
    • protected:
    • Class2Serial ( SerializationInfo* info,
                     StreamingContext   context)
    • {
      • serialVariable
           = info->GetString (
                    S”serialVariable” );
    • }
  • } ;

3. Deserialisieren von ausgeschlossenen Membervariablen
Um das Datenvolumen zum Serialisieren zu reduzieren, können nicht notwendigerweise zu serialisierende Daten, welche z.B. nur von anderen Variablen abhängig sind, von der Serialisierung ausgeschlossen werden. Bei der Deserialisierung muss natürlich dafür gesorgt werden, dass diese wieder hergestellt werden. Dies realisiert die in der Schnittstelle IDeserializationCallback enthaltene Methode

void OnDeserialization ( Object* sender ),

welche implemtiert werden muss. Diese wird dann nach dem Deserialisierungs-Konstruktor aufgerufen und stellt die Konsistenz der Daten her. Die Serialisierung erfolgt wie bei 2. mit GetObjectData, die Deserialisierung mit dem Deserialisierungs-Konstruktor.
Beispiel:

  • [Serializable]
  • public __gc class Class2Serial
                      : public IDeserializationCallback
  • {
    • public:
    • String* serialVariable;
    • [NonSerialized]
    • String* nonserialVariable;
    • public Class2Serial( String* strVar )
    • {
      • serialVariable    = strVar;
      • nonserialVariable = String::Concat(
                            S”Wert=”, strVar );
    • }
    • // Memberfunktion von IDeserializationCallback
    • void OnDeserialization ( Object* sender )
    • {
      • nonserialVariable = String::Concat(
                            S”Wert=”,
                            serialVariable );
    • }
    • // Methode von ISerializable zum Serialisieren
    • void GetObjectData (
                SerializationInfo* info,
                StreamingContext   context)
    • {
      • info->AddValue ( S”serialVariable”,
                         serialVariable );
    • }
    • // Deserialisierungs-Konstructor
    • protected:
    • Class2Serial ( SerializationInfo* info,
                     StreamingContext   context )
    • {
      • serialVariable
          = info->GetString (S”serialVariable”);
    • }
  • };

4. Serialisieren mit Surrogaten
Wenn Klassen implementiert werden, welche das Attribut [Serializable] nicht besitzen, muss eine Klasse implementiert werden, die die Schnittstelle ISerializationSurrogate einbezieht. Diese Klasse kann dann wie die vorgehenden Klassen serialisiert werden. Dazu sind die Methoden

void GetObjectData ( Object*            obj,
                     SerializationInfo* info,
                     StreamingContext   context )

und

Object* SetObjectData ( Object*             obj,
                        SerializationInfo*  info,
                        StreamingContext    context,
                        ISurrogateSelector* selector )

zu überschreiben.
Beispiel:

  • public __gc class Class2Serial
  • {
    • public:
    • String* serialVariable;
    • Class2Serial (String* strVar)
    • {
      • serialVariable = strVar;
    • }
  • } ;
  • public __gc class Class2SerialSurrogate
                      : public ISerializationSurrogate
  • {
    • public:
    • // Methode zum Serialisieren
    • void GetObjectData (
            Object*            obj,
            SerializationInfo* info,
            StreamingContext   context )
    • {
      • Class2Serial* classSerial
            = __try_cast<Class2Serial*>( obj ) ;
      • info->AddValue (
              S”serialVariable”,
              classSerial->serialVariable );
    • }
    • // Methode zur Deserialisierung
    • Object* SetObjectData (
                Object*             obj,
                SerializationInfo*  info,
                StreamingContext    context,
                ISurrogateSelector* selector )
    • {
      • Class2Serial* classSerial
            = __try_cast<Class2Serial*>( obj ) ;
      • classSerial->serialVariable
            = info->GetString (
                S”serialVariable” );
      • return classSerial;
    • }
  • } ;

5. Serialisieren von Werten aus verschiedenen Klassen
Der Benutzer kann bei dieser Variante bestimmen, welche Klasse für das Serialisieren verwendet werden soll. Dazu wird eine von SerializationBinder abgeleitete Klasse erstellt, welche eine überschriebene Methode

 

Type* BindToType ( String* assemblyName,
                   String* typeName )

enthält. Diese bindet dann die verschiedenen Klassen mit den unter gleichem Namen serialisierten Werten. Die Eigenschaft Binder des Formatters wird dann auf die jeweils zu verwendende Bindung eingestellt. Ebenso können die serialisierten Werte aus verschiedenen Assemblies verwendet werden.
Beispiel:

  • __sealed __gc class Class1ToClass2Binder
                  : public SerializationBinder
  • {
    • public:
    • Type* BindToType ( String* assemblyName,
                         String* typeName )
    • {
      • Type* type   = NULL;
      • String* strT = S”.Class2Serial”;
      • if ( String::Compare( strT,
                        typeName ) == 0 )
      • {
        • typeName = S”.Class2SerialBind”;
      • }
      • String* strTyp
          = String::Format(”{0}, {1}”,
                           typeName,
                           assemblyName);
      • type = Type::GetType( strTyp, true );
      • return type;
    • }
  • } ;

Die Anwendung der verschiedenen Serialisierungen erfolgt nach dem Schema:

  • Erzeugen eines Streams (z.B. FileStream)
  • Ereugen eines Formatters (z.B. BinaryFormatter oder SoapFormatter)
  • Zusätzlich bei der obigen Variante 4.
    • Erzeugen eines Objektes der Surrogaten-Klasse ( im Beispiel Class2SerialSurrogate )
    • Erzeugen eines Objektes der Klasse SurrogateSelector
    • Aufruf der Methode AddSurrogate
  • Zusätzlich bei der obigen Variante 5.
    • Zuweisen der Bindung
  • Serialisierungs-Methode aufrufen mit der Zuordnung von Stream und Objekt
    • bei den Beispielen 1.-3.: Serialize
    • im Beispiel 4.: SurrogateSelector

Beispiel: 

  • SoapFormatter* formatter  = new SoapFormatter ();
  • String*        path       = “Class1.soap”;
  • FileStream*    fileStream = new FileStream ( path,
                                    FileMode::Create );
  • try
  • {
    • Class2Serial* class1
         = new Class2Serial( S”Wert von class1″ );
    • Class2SerialSurrogate* class2
         = new Class2SerialSurrogate();
    • SurrogateSelector* sursel
         = new SurrogateSelector();
    • sursel->AddSurrogate(
              __typeof( Class2Serial ),
              StreamingContextStates::All,
              class2 );
    • formatter->SurrogateSelector = sursel;
    • formatter->Serialize( fileStream, class1 );
    • formatter->Serialize( fileStream, class2 );
  • }
  • catch( Exception* exc)
  • {
    • MessageBox::Show( exc->Message );
  • }
  • __finally
  • {
    • fileStream->Close();
  • }

Analog erfolgt die Deserialisierung:

  • Erzeugen eines Streams (z.B. FileStream)
  • Erzeugen eines Objektes der Klasse Class2Serial
  • Ereugen eines Formatters (z.B. BinaryFormatter oder SoapFormatter)
  • Aufruf der Deserialisierungs-Methode Deserialize um die Werte dem Objekt zuzuweisen

Beispielcode: 

  • FileStream* fileStream
           = new FileStream( S”speicher.dat”,
                             FileMode::Open );
  • Class2Serial* class1
           = new Class2Serial(S”ohne Inhalt”);
  • SoapFormatter* formatter
           = new SoapFormatter();
  • // Deserialisierung bei den Varianten 1.-3.
  • class1 = __try_cast<Class2Serial*>(
              formatter->Deserialize( fileStream ));
  • // Deserialisierung bei der Variante 4.
  • class1 = __try_cast<Class2Serial*>(
              formatter->Deserialize( fileStream ));
  • // Deserialisierung bei der Variante 5.
  • Class2SerialBind* class3 = NULL;
  • formatter->Binder = new Class1ToClass2Binder();
  • class3 = __try_cast<Class2SerialBind*>(
              formatter->Deserialize( fileStream ));
  • // Stream beenden
  • fileStream->Close();

Zusatzinformation zu den verwendeten Klassen:

  • SerializationInfo: Speichert alle Daten, welche zum Serialisieren erforderlich sind. Eigenschaften sind:
    AssemblyName, FullTypeName und MemberCount.
  • StreamingContext: Beschreibt die Quelle und das Ziel eines Streams und kann eines zusätzlichen Kontext
    speichern. Eigenschaften sind Context und State.
  • StreamingContextStates: Enumeration, welche den Quell- oder Zielkontext für den Stream charakterisiert.
  • BinaryFormatter: Behält die Typintgrität bei. Es kann ein Objekt in einen Stream, einen Datenträger, den
    Arbeitsspeicher oder über das Netzwerk serialisiert werden.
  • SoapFormatter: Behält die Typintegrität nicht bei. Die Verwendung von XML/SOAP erfolgt hauptsächlich zum
    Freigeben von Daten im Internet und um die Anwendung, welche mit den Daten arbeitet, nicht einzuschränken.

Einen Kommentar schreiben:


luvox period controindicazioni del femara alternative naturali al clomid clomid provoca corrimento diflucan tempo azione voltaren pastiglie senza ricetta plavix e impotenza prometrium 200 come si usa metoprolol toprol xl conversion voltaren dispers 600 voltaren retard prezzo panière allegra tupperware lasix in gravidanza voltaren tissugel voltaren gel blood sugar cosa mangiare a cipro nord viagra pepsi cola cialis 10 mg effetti voltaren generico prezzo hot propecia cinsel compare metformin to gliclazide cialis lo vendono in farmacia metoclopramide ileus glucophage chromium picolinate antibiotico augmentin sospensione clindamycin molluscum contagiosum metoprolol succinate 100 mg ter orlistat venta peru effetti collaterali di finasteride voltaren emulgel tendonitis risperdal fa male metoprolol tratament