Speichern und Serialisieren beliebiger Klassen

Question

Momentan habe ich mehrere Klassen, die ich serialisieren und auf Festplatte speichern möchte (das Format spielt keine Rolle). Alles, was ich wirklich speichern muss, sind ein paar Auswahlfelder von jedem. Diese Felder variieren von Klasse zu Klasse, aber sie sind alle öffentlich.

public class A { 
    public string stringField; 
    public int intField; 
    ... 
} 

public class B { 
    public float floatField; 
    public Object objectField; 
    ... 
} 

Mein Ansatz war es, eine einfache Container-Klasse haben, die ihnen diese Felder sowie laden speichern und serialisiert werden kann eine Instanz der Klasse mit den gespeicherten öffentlichen Bereichen für jede Klasse zurückzukehren.

Ich kann dies tun, indem ich eine Klasse mit passenden Feldern für die auf der Klasse, die ich speichern möchte, machen.

public class AStorage{ 
    public string stringFieldStorage; 
    public int intFieldStorage; 
    ... 

    public void StoreA(A a){ 
     stringFieldStorage = a.stringField; 
     intFieldStorage = a.intField; 
    }  

    public A GetA(){ 
     A a = new A(); 
     a.stringField = stringFieldStorage; 
     a.intField = intFieldStorage; 
     return a; 
    } 
} 

Dies funktioniert, aber es bedeutet, dass ich eine Menge von Klassen brauchen, und ich brauche sie Felder zu geben, je nachdem, was sie aus der Klasse erhalten wollen sie speichern.

Ich habe mit Reflektion untersucht, um die Felder und Namen zu greifen, und das ist einfach. Ich könnte sie dann in einen Dictonary<string, Object> geben, der durch den Feldnamen verschlüsselt wird und dann darauf verweisen. Aber das fühlt sich ein bisschen eklig an und hat mich dazu gebracht, mich zu fragen, ob ich überhaupt etwas falsch mache. Was sind die bewährten Methoden zum Speichern und Serialisieren von Klassen?

Answer 1

Viele Serializer unterstützen selective serialization, zum Beispiel durch Markieren einer Eigenschaft, die nicht mit dem NotSerializedAttribute (z. B. binärer Serializer) serialisiert werden sollte, oder durch das explizite Festlegen von Eigenschaften für die Serialisierung, z. DataMemberAttribute des DataContractSerializers.

Die Verwendung einer der beiden Methoden vermeidet die Notwendigkeit, eine separate Klasse nur für die Speicherung zu erstellen, und wird von .NET Framework vollständig unterstützt.

Answer 2

Nach ein paar fuzzing habe ich mich darauf festgelegt, mit Reflection einfach Felder nach Namen zu vergleichen. Auf diese Weise muss ich nur ein Feld erstellen, das in der Speicherklasse gespeichert werden soll. Ich muss auch kein manuelles Zuweisen durchführen, daher sieht es für meine Projektgröße ziemlich nachhaltig aus. Hier sind die zwei Methoden.

public void Store(Object source){ 
    var thisType = this.GetType(); 
    var sourceFields = source.GetType().GetFields (flags); 
    foreach (var field in sourceFields) { //get all properties via reflection 
     var instanceField = thisType.GetField (field.Name); 
     if(instanceField != null){ //check if this instance has the source's property 
      var value = field.GetValue(source); //get the value from the object 
      if(value != null){ 
       instanceField.SetValue(this, value); //put it into this instance 
      } 
     } 
    } 
} 

public T LoadIntoObject<T> (T target){ 
    var targetFields = target.GetType().GetFields(); 
    foreach (var field in targetFields) { 
     var instanceField = this.GetType().GetField (field.Name); 
     if(instanceField != null){ //check if this instance has the targets's property 
      var value = instanceField.GetValue(this); 
      if(value != null){ 
       field.SetValue(target, value); //put it into the target 
      } 
     } 
    } 
    return target; 
}