abwärtskompatibler Serialisierer gesucht

  • VB.NET

Es gibt 3 Antworten in diesem Thema. Der letzte Beitrag () ist von Kangaroo.

    abwärtskompatibler Serialisierer gesucht

    Hallo zusammen,

    ich schreibe zurzeit ein größeres Projekt, das diverse Daten speichern und wieder öffnen können muss. Es wird in Zukunft zwangsweise dazu kommen, dass sich die Struktur der zu speichernden Daten/Klassen ändert, bzw. weiterentwickelt. Ich möchte aber in Zukunft auch die "älteren" Daten wieder einlesen können. Also eine Art abwärtskompatibilität gewährleisten.

    Jetzt weiß ich nicht, wie ich die Daten serialisieren soll, so dass die "alten Daten" in die aktuellen Objekte appliziert werden können.
    ...so wie ich das erkläre, versteht das wahrscheinlich kein Mensch ?( Also:

    Ich habe ein Objekt mit einer bestimmten Anzahl von Parametern, bzw. einem Array bestimmter Größe, das ich serialisiere. Wenn ich das Objekt um die ein oder andere Variable erweitere bzw. die Arraygröße ändere und dann versuche eine alte Speicherstand wieder einzulesen, kommt es bei den üblichen Serialisierern zu Problemen, weil ich entweder ein altes Objekt mit der falschen Arraygröße bekomme oder direkt eine Fehlermeldung, dass die falsche Anzahl von Parametern erwartet wurde.

    Kennt jemand einen passenen Serialisierer, einen Trick oder kann mir sagen, wie ich einen eigenen Serialisierer schreiben kann?



    Vielen Dank schonmal...

    mfG, Oli

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

    Nun, Du scheinst Dich ja intensiv mit der Materie auseinandergesetzt zu haben, insofern weiss ich nicht ob ich da viel Neues zu bieten habe.

    Grundsätzliches:
    Du erwähnst "einen eigenen Serializer" schreiben und/oder verwenden. Was meinst Du damit ? Grundsätzlich hast Du die Wahl zwischen eigentlich 2 (Soap mal aussen vor) unterschiedlichen Arten von Serialisierung:
    • XML Serialisierung: setzt auf IXMLSERIALIZABLE Interface auf, nur Public fields, langsam,editierbar,relativ versionstolerant,plattformunabhängig
    • Binary Serialisierung: setzt auf ISERIALIZABLE Interface auf, Private & Public fields, schneller,nicht editierbar,wenig versionstolerant,plattformabhängig
    Dabei haben die beiden Interfaces nichts miteinander zu tun, IXMLSerializable ist also kein Derivat von ISerializable. Ich hab geschrieben Binary Serialisation sei schneller als die von XML, ist aber immer noch relativ langsam und speicheraufwändig. Wenn es auf Grösse ankommt geht der Trend jetzt zu Protocol Buffern, insbesondere die von Google implementierte Form.

    Also solltest Du Dich zunächst mal für eine Art Serialisierung entscheiden. Ich gehe mal von Binary aus: dann hast Du wiederum die Wahl wie Du Deine Objekte persistent machst:
    • Default Serialisierung: einfach , relativ wenig versionstolerant wie Du schon bemerkt hast
    • Custom Serialisierung: so versionstolerant wie Du es implementierst, heisst aber auch daß Du bei jedem (kritischen) Objekt das ISerializable Interface implementiern musst
    Die Arbeit , individuelle Implementierungen des ISerializable Interface zu schreiben würde ich mir definitiv nicht machen, man gerät da leicht in die Versuchung die eierlegende-Wollmilchsau zu schaffen. Eine Alternative, die Dir vielleicht ausreicht sind die Erweiterungen die MS in .NET 2.0 geschaffen hat unter dem Begriff "Version tolerant Serialisation".

    Das sind im Wesentlichen eine Reihe von neuen Attributen für das ISerializable Interface, die es erlauben (etwas) flexibler auf fehlende oder überflüssige Daten zu reagieren, insofern einen Teil Deines Problems abdeckt. Ob das auch für Deine fixen Arrays eine Lösung ist kann ich nicht sagen, frage mich aber warum Du a) Arrays statt Collections benutzt und b) noch mit fixer Grösse.

    Zu dem Thema noch einmal ein interessanter Artikel, den mir vor einiger Zeit mal aufgefallen war zum Thema "versionstolerante Serialisierung": generell die Aussage dass Du zwar mit VTS Serialisierungsfehler bzw. Custom Serialization vermeiden kannst, Dir aber dafür Logikfehler einhandelst die evtl noch schwerer zu entdecken sind, hier der Artikel

    Bin gespannt was andere zu diesem Thema an Erfahrung haben, jedenfalls eine interessante Abwechslung zu den sonstigen Fragen hier im Forum.

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

    erstmal vielen Dank für die ganze Reihe an neuen Denkanstößen und Vokabeln. Natürlich versuche ich mein bestes, bevor ich andere mit meinen Problemen belästige. Um so mehr erfreut es micht, das diese Thematik auch von anderen nicht als ausgelutscht betrachtet wird.
    Ich hab mich gerade mal ein bisschen mit dem Herrn Google auseinandergesetzt und mir deine Vorschläge angeguckt. In Sachen Custom Serialisierung hast Du natürlich recht; am liebsten würde ich auch darauf verzichten, mit dem ISerializable Interface alles per Hand machen zu müssen. Weil ich es bisher nicht kannte, habe ich mir tatsächlich schon Gedanken darüber gemacht, wie ich das hinkriege, was das VersionAdded-Property kann. Dann wäre ich also in der Lage, wenigstens neue Parameter hinzuzufügen. Allerdings wächst der Code dann natürlich mit der Zeit ins Unermessliche und deshalb tendiere ich auf den ersten Blick ja zu dem Tip, auf die VTS-Schiene aufzuspringen :thumbup: . Nach meinem ersten Testprogramm habe ich es anscheinend richtig verstanden, dass ich Parameter, die in Zukunft vielleicht entfallen könnten (zur Not also einfach alle) einfach als optional markiere, und es den Kompiler ich Zukunft nicht stört, wenn er mit einer gespeicherten Information nichts anzufangen weiß und sie deshalb einfach hinten runterfallen lässt.

    Ich hab mir gerade eine Testklasse mit einer optionalen Variable geschrieben und per BinaryFormatter serialisiert. Dann in der Klasse die Variable gelöscht, neue hinzugefügt, und die gespeicherten Daten als Objekt dieser neue Klasse deserialisert. Hat super geklappt :thumbsup: . Ich denke ich werde mein Programm ertmal in dieser Richtung weiter verfolgen, bis mir ein Grund einfällt der dagegen sprechen sollte.
    Vor allem weil ich noch lange nicht so weit bin, das Programm hier in der Firma zu launchen. Es würden also noch keine großen Datenmangen verloren gehen, wenn ich demnächst doch noch mal umschwenke.

    Bin also weiterhin für jede Art Erfahrung oder Disskussion offen...

    Auch nochmal vielen Dank für die beiden Links. War echt interessant.


    P.S.: meine Parameter waren eigentlich immer ArrayLists diverser "kleinerer" Objekte oder ganze Klassenobjekte mit Unter- Und Unter-Unter-Objekten. Aber bis gerade eben hatte ich mich auch noch nie mit Collections beschäfftigt :wacko: . Die sind echt nützlich... :D . Werd ich in Zukunft wohl öffters drauf zurückgreifen :thumbsup:

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „oliverw83“ () aus folgendem Grund: P.S. hinzu

    Nun, freut mich wenn der Post Dir weiterhelfen konnte, bei neuen Membern weiss man nie wie weit man in die Grundlagen abtauchen muss oder ob das gleich den Gähn-Effekt auslöst.

    Wenn Du noch relativ neu im Bereich .NET bist, hast Du Dich evtl auch noch nicht mit dem Konzept von Generics auseinandergesetzt. Daher mal hier eine kleine aber feine generische Serializer Klasse die Dir vielleicht (oder auch nicht) bei Deinem Projekt weiterhilft:
    Spoiler anzeigen

    VB.NET-Quellcode

    1. '############################################################################################
    2. '######## CLASS: SERIALIZER ######### -----
    3. '############################################################################################
    4. '---
    5. '--- Diese Klasse bietet folgende Serialisierungen an:
    6. '--- Binary Serialisierung/Deserialisierung, Optional mit Kompression
    7. '--- XML Serialisierung/Deserialisierung
    8. '--- Bei Deserialisierung kann eine Default-Instanz angegeben werden, sonst wird NEW genommen
    9. '--- Relative Dateipfade werden akzeptiert
    10. '--- wenn FileNamen nicht existieren werden sie angelegt
    11. ' Source:
    12. ' http://www.vbarchiv.net/tipps/details.php?id=1749
    13. ' http://www.devproconnections.com/article/net-framework2/net-generics.aspx
    15. Imports System.IO
    16. Imports System.IO.Compression
    17. Imports System.Runtime.Serialization.Formatters.Binary
    20. Public Class Serializer
    22. '############################################################
    23. '### METHODS #####
    24. '############################################################
    26. '-------------------------------
    27. '-- BinarySerialize ----
    28. '-------------------------------
    29. Public Shared Sub BinarySerialize(Of T)(ByVal fileName As String, ByVal instance As T, ByVal compression As Boolean)
    30. Dim fullPath As String
    31. Try
    32. fullPath = System.IO.Path.GetFullPath(fileName)
    33. ' directory anlegen
    34. If Not Directory.Exists(Path.GetDirectoryName(fullPath)) Then
    35. Directory.CreateDirectory(Path.GetDirectoryName(fullPath))
    36. End If
    37. ' stream und formatter definieren
    38. Dim fs As Stream = New FileStream(fullPath, FileMode.Create)
    39. Dim bf As New BinaryFormatter
    40. ' compression nur wenn gewünscht
    41. If compression Then fs = New GZipStream(fs, CompressionMode.Compress)
    42. ' die eigentliche serialisierung
    43. bf.Serialize(fs, instance)
    44. fs.Close()
    45. Catch ex As Exception
    46. MessageBox.Show(ex.Message, Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Error)
    47. Throw ex
    48. End Try
    49. End Sub
    50. ' overloads: BinarySerialize ohne Compression
    51. Public Shared Sub BinarySerialize(Of T)(ByVal fileName As String, ByVal instance As T)
    52. BinarySerialize(fileName, instance, False)
    53. End Sub
    56. '-------------------------------
    57. '-- BinaryDeserialize ----
    58. '-------------------------------
    59. Public Shared Function BinaryDeserialize(Of T)(ByVal fileName As String, ByVal defaultInstance As T, ByVal compression As Boolean) As T
    60. Dim fullPath As String
    61. Try
    62. fullPath = System.IO.Path.GetFullPath(fileName)
    63. ' directory anlegen, wenn nicht existiert wird die default Instanz geladen
    64. If Not File.Exists(fullPath) Then
    65. BinarySerialize(fileName, defaultInstance, compression)
    66. Return defaultInstance
    67. End If
    68. ' stream und formatter definieren
    69. Dim fs As Stream = New FileStream(fileName, FileMode.Create)
    70. Dim bf As New BinaryFormatter
    71. ' compression falls angegeben
    72. If compression Then fs = New GZipStream(fs, CompressionMode.Decompress)
    73. ' die Deserialisierung
    74. BinaryDeserialize = CType(bf.Deserialize(fs), T)
    75. fs.Close()
    76. Catch ex As Exception
    77. MessageBox.Show(ex.Message, Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Error)
    78. Throw ex
    79. End Try
    80. End Function
    81. ' overloads BinaryDeserialize: ohne Compression
    82. Public Shared Function BinaryDeserialize(Of T)(ByVal fileName As String, ByVal defaultInstance As T) As T
    83. Return BinaryDeserialize(Of T)(fileName, defaultInstance, False)
    84. End Function
    85. ' overloads BinaryDeserialize: als Default wird NEW genommen
    86. Public Shared Function BinaryDeserialize(Of T As New)(ByVal fileName As String, ByVal compression As Boolean) As T
    87. Return BinaryDeserialize(Of T)(fileName, New T, compression)
    88. End Function
    89. ' overloads BinaryDeserialize: ohne Compression, NEW als Default
    90. Public Shared Function BinaryDeserialize(Of T As New)(ByVal fileName As String) As T
    91. Return BinaryDeserialize(Of T)(fileName, New T)
    92. End Function
    94. '-------------------------------
    95. '-- XMLSerialize ----
    96. '-------------------------------
    97. Public Shared Sub XMLSerialize(Of T)(ByVal fileName As String, ByVal instance As T)
    98. Dim fullPath As String
    99. Try
    100. fullPath = System.IO.Path.GetFullPath(fileName)
    101. ' directory anlegen
    102. If Not Directory.Exists(Path.GetDirectoryName(fullPath)) Then
    103. Directory.CreateDirectory(Path.GetDirectoryName(fullPath))
    104. End If
    105. ' stream und serializer definieren
    106. Dim xs As New System.Xml.Serialization.XmlSerializer(GetType(T))
    107. Dim fs As Stream = New FileStream(fullPath, FileMode.Create)
    108. ' serialisieren
    109. xs.Serialize(fs, instance)
    110. fs.Close()
    111. Catch ex As Exception
    112. MessageBox.Show(ex.Message, Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Error)
    113. Throw ex
    114. End Try
    115. End Sub
    117. '-------------------------------
    118. '-- XMLDeserialize ----
    119. '-------------------------------
    120. Public Shared Function XMLDeserialize(Of T)(ByVal fileName As String, ByVal defaultInstance As T) As T
    121. Dim fullPath As String
    122. Try
    123. fullPath = System.IO.Path.GetFullPath(fileName)
    124. ' directory anlegen
    125. If Not File.Exists(fullPath) Then
    126. XMLSerialize(fileName, defaultInstance)
    127. Return defaultInstance
    128. End If
    129. ' stream und serializer definieren
    130. Dim fs As Stream = New FileStream(fileName, FileMode.OpenOrCreate)
    131. Dim xs As New System.Xml.Serialization.XmlSerializer(GetType(T))
    132. ' deserialisieren
    133. XMLDeserialize = CType(xs.Deserialize(fs), T)
    134. fs.Close()
    135. Catch ex As Exception
    136. MessageBox.Show(ex.Message, Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Error)
    137. Throw ex
    138. End Try
    139. End Function
    140. ' overloads XMLDeserialize: NEW als Default
    141. Public Shared Function xmlDeserialize(Of T As New)(ByVal fileName As String) As T
    142. Return xmlDeserialize(Of T)(fileName, New T)
    143. End Function
    144. End Class


    Die versieht schon seit einiger Zeit brav ihren Dienst in meiner Standard-Library und serialisiert so ziemlich alles was die entsprechenden Voraussetzungen erfüllt. Vorsicht natürlich immer bei Laufzeit-kritischen Anwendungen.

    Ich wollte hier schon seit ein paar Tagen ein Mini-Tutorial zum Thema Serialisierung schreiben, die Serializer-Klasse war dafür als praktische Umsetzung gedacht.

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

Facebook
Telefonspende