Klassenstruktur clonen

  • VB.NET
  • .NET (FX) 4.0

Es gibt 20 Antworten in diesem Thema. Der letzte Beitrag () ist von cl10k.

    Klassenstruktur clonen

    Hallo,

    ich möchte eine unabhängige "Momentaufnahme" der Daten einer umfangreichen Klassenstruktur anlegen.

    Meine erste Anlaufstelle war dieses Tutorial aus dem Jahre 2003. Dort wird einmal der Weg über MemberwiseClone (ein Shallow-Clone reicht mir nicht aus) und einmal per Serialisieren/Deserialisieren* (funktioniert wie gewünscht) beschrieben.

    Eigentlich möchte ich nur wissen, ob das* immer noch Stand der Technik ist.

    lg
    Christian

    So, ich habe mich jetzt mal ein wenig in das Thema eingelesen und ausgetestet. Zum Erstellen eines Clones nutze ich folgende Funktion:

    VB.NET-Quellcode

    1. Function DeepClone(Of T)(ByRef orig As T) As T
    2. 'http://stackoverflow.com/questions/15584053/deep-copy-of-an-object
    4. If (Object.ReferenceEquals(orig, Nothing)) Then Return Nothing
    6. Dim formatter As New BinaryFormatter()
    7. Dim stream As New MemoryStream()
    9. formatter.Serialize(stream, orig)
    10. stream.Seek(0, SeekOrigin.Begin)
    12. Return CType(formatter.Deserialize(stream), T)
    14. End Function


    So ganz ohne Probleme läuft es aber natürlich nicht. Meine Klassen sind nicht für Serialisierung vorbereitet. Entsprechend fliegen eine ganze Menge:


    An unhandled exception of type 'System.Runtime.Serialization.SerializationException' occurred in mscorlib.dll

    Additional information: Der Typ "TestCloning.Form2+cls_rad" in Assembly "TestCloning, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" ist nicht als serialisierbar gekennzeichnet.


    Ich könnte jetzt beigehen und überall die <Serializable()> & <NonSerialized> Tags nachtragen.

    Meine Klassenstruktur ist aber relativ umfangreich. Da kommen locker 50 Teilklassen zusammen. Tatsächlich benötige ich gar nicht alles davon für meinen Clone, sondern allenfalls ein paar Dutzend Eigenschaften. Anstatt jetzt alles durchzupflügen und überall ganz feingliedrig die Tags zu setzen, würde ich mir das Leben gern leicht machen.

    Kann ich einzelne Klasseneigenschaften als Serialisierbar kennzeichnen (also in Umkehrung zu <NonSerialized>) und kann ich meiner Funktion sagen, nicht "getaggte" Elemente zu ignorieren?

    cl10k schrieb:

    würde ich mir das Leben gern leicht machen.
    Dann erstell einfach eine leere Insdtanz und übertrage die relevanten Daten.
    Allerdings ist das nicht zukunftssicher, denn iwann musst Du das erweitern, und da ist es tatsächlich besser, Du implementierst clonbare Klassen und ein anständiges Clonen.
    Wenn Du über Reflection gehst, kannst Du zumindest alle Properties iterativ clonen.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    cl10k schrieb:

    Meine Klassenstruktur ist aber relativ umfangreich. Da kommen locker 50 Teilklassen zusammen. Tatsächlich benötige ich gar nicht alles davon für meinen Clone, sondern allenfalls ein paar Dutzend Eigenschaften. Anstatt jetzt alles durchzupflügen und überall ganz feingliedrig die Tags zu setzen, würde ich mir das Leben gern leicht machen.
    Letztendlich kommt man beim Klonen um Feingliedrigkeit nicht herum - zumindest gibts kein Patentrezept.

    Sondern beim Klonen musste halt programmieren, wie geklont werden soll, denn "Klon" kann mal dieses mal jenes bedeuten.
    Serialisierung kann schoma viel abdecken, aber wie du siehst, nicht alles.
    Gut möglich, dass du nicht umhin kommst, ISerializable selbst zu implementieren, und dann Property für Property Angaben angeben, was am Klon mit-geklont wird, und was weggelassen werden kann.

    Übrigens ein etwas anderes Konzept verbreiter ich hier:
    ComplexConverter: alles in einen String und zurück
    ist mit Fleiß umstritten, aber für dich nützlich kann grade @hal2000s Alternative sein, die demonstriert nämlich eine ISerializable-Implementation.

    Jdfs mein Konzept ist grade kein Klon, sondern es muss ein "unbeschriebenes Blatt" zu instanzieren möglich sein, und dessen Properties werden alle - ganz feingliedrig - gesetzt.
    Wie gesagt: Das ist kein Klonen, bei dem eine neues Objekt entsteht, sondern es ist ein Befüllen.
    Und während beim Serialisieren quasi das ganze Objekt in eine Datei umgewandelt wird, wird beim ComplexConverter nur die Befüllung umgewandelt.
    Also wenn dein Kram wirklich kompliziert wird, dann dürfte der Thread für dich interessant sein, ob du dich nu für ISerialzable entscheidest oder für ComplexConverter.

    Da bin ich wieder^^

    Ich habe jetzt mal ein wenig mit ISerializable herumgespielt, aber die "Magie" erschließt sich mir noch nicht...

    Um den Kram auszutesten, habe ich eine primitive Klassenstruktur Auto mit mehreren Unterklassen erstellt, die meinem Anwendungsfall recht ähnlich ist. Alle Klassen haben Eigenschaften die mich für den Clone interessieren und Eigenschaften die für den Clone ohne Belang sind (alle Bla... properties).

    Um klar zu definieren, was serialisiert werden soll, existieren in cls_Auto ein angepasster Konstruktor und eine entsprechende GetObjectDataInfo-Methode. Das funktioniert soweit auch. Ich kann in cls_Auto angeben, welche Eigenschaften, auch von Unterklassen, serialisiert werden sollen.

    Trotzdem kommt es mir so vor, als das ich bisher nur an der Oberfläche kratze und mich ziemlich ungelenk anstelle. Was kann man besser machen?

    Vor allem interessiert mich folgendes: Ich würde gern direkt in den Unterklassen angeben was serialisiert werden soll. So habe ich z.B. in cls_Getriebe einen entsprechenden Konstruktor und GetObjectDataInfo implementiert, diese werden aber vollständig ignoriert. Serialisiert wird nur, was ich in cls_Auto.GetObjectDataInfo und cls_Auto.New angegeben habe. Wie macht man es richtig?

    Und nebenbei, was machen die Surogatoren die Hal2000 hier einsetzt?
    ----
    Kurz zum angehängten Code:
    Ein einfaches Form mit 3 Buttons. Buttons1 und 3 zeigen einfach die Klassenproperties von Auto1 und Auto2 im Output Window an. Button2 ruft die Clone-Funktion auf. (Alles quick&dirty)


    Spoiler anzeigen

    VB.NET-Quellcode

    1. Imports System.Runtime.Serialization
    2. Imports System.Runtime.Serialization.Formatters.Binary
    3. Imports System.IO
    5. Public Class Form3
    7. Public Auto1 As New cls_Auto
    8. Public Auto2 As New cls_Auto
    10. #Region "Buttons"
    12. Private Sub btn_ShowAuto1_Click(sender As System.Object, e As System.EventArgs) Handles btn_ShowAuto1.Click
    13. ShowAuto(Auto1)
    14. End Sub
    16. Private Sub btn_CloneAuto1_Click(sender As System.Object, e As System.EventArgs) Handles btn_CloneAuto1.Click
    17. Auto2 = DeepClone(Auto1)
    18. Auto2.Marke = "Clone von DACIA"
    19. End Sub
    21. Private Sub btn_ShowAuto2_Click(sender As System.Object, e As System.EventArgs) Handles btn_ShowAuto2.Click
    22. ShowAuto(Auto2)
    23. End Sub
    25. #End Region
    27. #Region "Auto"
    29. <Serializable()> _
    30. Public Class cls_Auto
    31. Implements ISerializable
    33. Public Rad As New cls_rad
    34. Public Motor As New cls_Motor
    35. Public Getriebe As New cls_Getriebe
    37. Public Property blaAuto() As Integer
    38. Public Property Masse() As Integer
    39. Public Property Marke() As String
    41. Public Sub New()
    42. End Sub
    44. Public Sub New(ByVal Info As SerializationInfo, ByVal Context As StreamingContext)
    45. With Info
    46. Masse = .GetInt32("Masse")
    47. Motor.PS = .GetInt32("MotorPS")
    48. End With
    49. End Sub
    51. Sub getobjectdatainfo(ByVal Info As SerializationInfo, ByVal Context As StreamingContext) Implements ISerializable.GetObjectData
    52. With Info
    53. .AddValue("Masse", Masse)
    54. .AddValue("MotorPS", Motor.PS)
    55. End With
    56. End Sub
    58. End Class
    60. Public Class cls_Motor
    62. Public Property blaMotor() As Integer
    63. Public Property PS() As Integer
    65. End Class
    67. Public Class cls_Getriebe
    68. Implements ISerializable
    70. Public Property blaGetriebe() As Integer
    71. Public Property Masse() As Integer
    73. Public Sub New()
    74. End Sub
    76. Public Sub New(ByVal Info As SerializationInfo, ByVal Context As StreamingContext)
    77. With Info
    78. Masse = .GetInt32("Masse")
    79. End With
    80. End Sub
    82. Sub getobjectdatainfo(ByVal Info As SerializationInfo, ByVal Context As StreamingContext) Implements ISerializable.GetObjectData
    83. With Info
    84. .AddValue("Masse", Masse)
    85. End With
    86. End Sub
    88. End Class
    90. Public Class cls_rad
    92. Public felge As New cls_Felge
    93. Public reifen As New cls_Reifen
    95. Public Property blaRad() As Integer
    96. Public Property Masse() As Integer
    98. End Class
    100. Public Class cls_Felge
    102. Public Property blaFelge() As Integer
    103. Public Property Masse() As Integer
    105. End Class
    107. Public Class cls_Reifen
    109. Public Property blaReifen() As Integer
    110. Public Property Masse() As Integer
    112. End Class
    114. #End Region
    116. Private Sub Form3_Load(sender As Object, e As System.EventArgs) Handles Me.Load
    118. Auto1.Marke = "Dacia"
    119. Auto1.Masse = 1500
    120. Auto1.blaAuto = 111
    122. Auto1.Rad.Masse = 100
    123. Auto1.Rad.blaRad = 222
    125. Auto1.Rad.felge.Masse = 75
    126. Auto1.Rad.felge.blaFelge = 333
    128. Auto1.Rad.reifen.Masse = 25
    129. Auto1.Rad.reifen.blaReifen = 444
    131. Auto1.Motor.blaMotor = 555
    132. Auto1.Motor.PS = 25
    134. Auto1.Getriebe.blaGetriebe = 666
    135. Auto1.Getriebe.Masse = 200
    137. End Sub
    139. Private Sub ShowAuto(ByVal tmpAuto As cls_Auto)
    140. Debug.WriteLine("======================================")
    141. Debug.WriteLine("AutoMarke: " & tmpAuto.Marke)
    142. Debug.WriteLine("AutoMasse: " & tmpAuto.Masse)
    143. Debug.WriteLine("AutoBla: " & tmpAuto.blaAuto)
    144. Debug.WriteLine("-------------------")
    145. Debug.WriteLine("RadMasse: " & tmpAuto.Rad.Masse)
    146. Debug.WriteLine("RadBla: " & tmpAuto.Rad.blaRad)
    147. Debug.WriteLine("-------------------")
    148. Debug.WriteLine("FelgeMasse: " & tmpAuto.Rad.felge.Masse)
    149. Debug.WriteLine("FelgeBla: " & tmpAuto.Rad.felge.blaFelge)
    150. Debug.WriteLine("-------------------")
    151. Debug.WriteLine("ReifenMasse: " & tmpAuto.Rad.reifen.Masse)
    152. Debug.WriteLine("ReifenBla: " & tmpAuto.Rad.reifen.blaReifen)
    153. Debug.WriteLine("-------------------")
    154. Debug.WriteLine("MotorBla: " & tmpAuto.Motor.blaMotor)
    155. Debug.WriteLine("MotorPS: " & tmpAuto.Motor.PS)
    156. Debug.WriteLine("-------------------")
    157. Debug.WriteLine("GetriebeBla: " & tmpAuto.Getriebe.blaGetriebe)
    158. Debug.WriteLine("GetriebeMasse: " & tmpAuto.Getriebe.Masse)
    159. End Sub
    161. Function DeepClone(Of T)(ByRef orig As T) As T
    163. 'http://stackoverflow.com/questions/15584053/deep-copy-of-an-object
    165. ' Don't serialize a null object, simply return the default for that object
    166. If (Object.ReferenceEquals(orig, Nothing)) Then Return Nothing
    168. Dim formatter As New BinaryFormatter()
    169. Dim stream As New MemoryStream()
    171. formatter.Serialize(stream, orig)
    172. stream.Seek(0, SeekOrigin.Begin)
    174. Return CType(formatter.Deserialize(stream), T)
    176. End Function
    178. End Class


    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „cl10k“ ()

    ich habs jetzt mal getestet - also wenn du im Iserializable nur 2 Properties serialisierst, dann sind im Clon halt nur 2 Properties serialisiert.

    VB.NET-Quellcode

    1. 'cla_Auto
    2. Sub getobjectdatainfo(ByVal Info As SerializationInfo, ByVal Context As StreamingContext) Implements ISerializable.GetObjectData
    3. With Info
    4. .AddValue("Masse", Masse)
    5. .AddValue("MotorPS", Motor.PS)
    6. End With
    7. End Sub

    so gehts:

    VB.NET-Quellcode

    1. #Region "Auto"
    3. <Serializable> _
    4. Public Class cls_Auto
    6. Public Rad As New cls_rad
    7. Public Motor As New cls_Motor
    8. Public Getriebe As New cls_Getriebe
    10. Public Property blaAuto() As Integer
    11. Public Property Masse() As Integer
    12. Public Property Marke() As String
    14. End Class
    16. <Serializable> _
    17. Public Class cls_Motor
    19. Public Property blaMotor() As Integer
    20. Public Property PS() As Integer
    22. End Class
    24. <Serializable> _
    25. Public Class cls_Getriebe
    27. Public Property blaGetriebe() As Integer
    28. Public Property Masse() As Integer
    30. End Class
    32. <Serializable> _
    33. Public Class cls_rad
    35. Public felge As New cls_Felge
    36. Public reifen As New cls_Reifen
    38. Public Property blaRad() As Integer
    39. Public Property Masse() As Integer
    41. End Class
    43. <Serializable> _
    44. Public Class cls_Felge
    46. Public Property blaFelge() As Integer
    47. Public Property Masse() As Integer
    49. End Class
    51. <Serializable> _
    52. Public Class cls_Reifen
    54. Public Property blaReifen() As Integer
    55. Public Property Masse() As Integer
    57. End Class
    59. #End Region
    also er erkennt das durchaus. Nur wenn du ISerializable implementierst, dann hält er sich natürlich daran.
    Also implementiere es nicht.

    Drängler!

    Mit deiner Methode fange ich mir aber wieder alle vorhandenen Properties ein. Ich möchte ja nur bestimmte "ausgewählte" Eigenschaften clonen.

    Ich habe jetzt cls_Auto wie folgt geändert:

    VB.NET-Quellcode

    1. Public Sub New(ByVal Info As SerializationInfo, ByVal Context As StreamingContext)
    2. With Info
    3. Masse = .GetInt32("Masse")
    4. Motor.PS = .GetInt32("MotorPS")
    5. Getriebe = DirectCast(.GetValue("Getriebe", GetType(cls_Getriebe)), cls_Getriebe) '<----
    6. End With
    7. End Sub
    9. Sub getobjectdatainfo(ByVal Info As SerializationInfo, ByVal Context As StreamingContext) Implements ISerializable.GetObjectData
    10. With Info
    11. .AddValue("Masse", Masse)
    12. .AddValue("MotorPS", Motor.PS)
    13. .AddValue("Getriebe", Getriebe) '<----
    14. End With
    15. End Sub


    und das funktioniert. Ich clone jetzt genau die Infos aus Getriebe, die ich dort lokal in der getobjectdatainfo angeben habe :)


    Trotzdem beschleicht mich das Gefühl, ISerializable eher wenig elegant zu benutzen. Das gecaste geht mir auch aufn Keks...

    cl10k schrieb:

    Ich möchte ja nur bestimmte "ausgewählte" Eigenschaften clonen.
    ah - hab ich nciht gewusst.
    Du kannst die BackingFields von Properties, die nicht serialisiert werden sollen, mit <NonSerialized> attributieren.

    VB.NET-Quellcode

    1. <Serializable> _
    2. Public Class cls_Felge
    4. Public Property blaFelge() As Integer
    5. <NonSerialized> _
    6. Private _Masse As Integer
    7. Public Property Masse() As Integer
    8. Get
    9. Return _Masse
    10. End Get
    11. Set(value As Integer)
    12. _Masse = value
    13. End Set
    14. End Property
    16. End Class

    Ja, <nonserialized> wäre eine Möglichkeit. Aber in meiner tatsächlichen Klassenstruktur komme ich auf mehrere Hundert Properties. Für meinen Clone brauche ich aber nur so 30 bis maximal 50 davon. Ich bin tatsächlich zu faul, jede einzelne Property entsprechend zu taggen.

    Mit der aktuellen Lösung, brauche ich nur zu definieren, was ich tatsächlich gecloned haben möchte. Also genau das was ich mir ursprünglich (im Eingangspost) erhofft hatte.

    Schön wenn etwas mal funktioniert ohne elendig herumprobieren zu müssen :)

    (Der Clone dient dafür, einen Snapshot von einer Klassenstruktur anzufertigen und diesen Snapshot dann per AsyncWorker an ein externes CAD-Programm zu schicken. In der Zwischenzeit steht es dem User frei die GUI weiter zu benutzen und damit die Daten in der originalen Klassenstruktur zu ändern)

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „cl10k“ ()

    Du sprichst immer von klonen - serialisieren ist aber bisserl mehr (und glaub auch umständlicher).
    also wenn du nur klonen willst - das ginge einfacher als das Gemurkel mit ISerializable zu implementieren. (und geht übrigens ohne Cast).

    Einfach eine Methode Clone schreiben, die ein neues cls_Auto zurückgibt, mit den Eigenschaften, die du übertragen haben willst.

    Womit wir wieder bei der Feingliedrigkeit von vor 10 posts rauskämen :P

    Ja, es ist für mich halt ein langsames Rantasten an ein unbekanntes Thema...

    Ursprünglich wollte ich eigentlich nur eine Momentaufnahme der Daten in meiner Klassenstruktur haben (zu diesem Zeitpunkt hatte ich keine Ahnung was Serialization überhaupt ist...)

    Verrätst du mir noch, wie ich an dem Cast vorbeikomme?

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „cl10k“ ()

Facebook
Telefonspende