Fehlerbehandlung bei Objektverweisen auf eine Strukur

  • VB.NET

Es gibt 4 Antworten in diesem Thema. Der letzte Beitrag () ist von ProcessControl.

    Fehlerbehandlung bei Objektverweisen auf eine Strukur

    Hallo Leutz,
    ich stehe momentan ziemlich auf dem Schlauch mit einer (wie ich dachte) genialen Konstruktion:

    Ich habe komplexe (vorgegebene!) Datenstrukturen zu bearbeiten, die aber in verschiedenen (Struktur)Versionen vorliegen.
    Dazu habe ich mir zu den jeweiligen Strukturversionen dazu passende structures angelegt, mit allem drin, was man so für das Handling der Daten braucht.
    (Subs fürs initialisieren, schreiben und lesen in/aus Datei, prüfen auf Plausibilität, usw...)

    Ein Großteil der Aktionen, die ich mit diesen Daten mache, ist aber immer identisch, sodaß ich mich geärgert habe, trotzdem bei jeder Aktion jedesmal mühselig unterscheiden zu müssen, um welche Version es sich denn nun handelt, um dann auch die richtige -structure- verwenden zu können.

    Also habe mir Varis vom Typ Object erstellt, und mache nur einmal einen Verweis auf die passende -structure-, danach ist der Code, welcher dann nur noch mit der Object Vari spielt, immer identisch, da die Subs in den structures für die nötigen Aktionen auch immer die gleichen Namen und Parameter benutzen.

    Klappt wunderbar, was das Umgehen mit den Daten selbst angeht, aaaaber:
    Tritt in einer Sub der structure dann ein Fehler auf, wird dieser NICHT mehr höher gereicht an die aufrufende Methode!
    (In dieser ist aber das Try/Catch Konstrukt, das die Fehler abfangen soll!)
    Verwende ich stattdessen die structure direkt, also ohne Object Vari dazwischen, dann funktionierts!

    Zwei Lösungen hätte ich schon, aber die gefallen mir gar nicht! (Wegen des extremen Programmieraufwands)
    1. Doch immer die original -structure- verwenden, und bei jeder Aktion dann mühselig unterscheiden, welche denn nun benutzt werden muss.
    2. Eine "Universal" structure bauen, die mit allen Daten-Versionen umgehen kann, und erst beim initialisieren auf eine bestimmte Version "eingestellt" wird.

    Hättet ihr eine andere Lösung? Wie ich zum Beispiel auftretende Fehler auch über einen Verweis hinweg weiter nach"oben" reichen kann?

    Stefan

    Dies könnte man relativ einfach über Vererbung lösen.

    Du hast eine BaseClass die alle Daten / Subs / Funcs enthält, die für alle Versionen gültig sind. Dies schließt solche ein, die sich zwischen den Versionen in iherer Funktion, aber nicht an den Parametern / Ausgabe ändern . Danach legst du neue Classes an, angefangen bei der kleinsten Version, die jeweils von der Version davor Erben (Die kleinste Version erbt von der Base Class), und die entsprechenden Subs / Funcs / Propertys überschreiben, sodass sie auf die Version passen.

    Was du nun tun kannst, ist z.B. eine List(Of BaseVersionClass) zu benutzen in der du alle Versionen Sammeln kannst, eine Sub DoVersionDependentStuff() aufzurufen, die nun für jede Version die passende DoVersionDependendStuff() aufruft.
    Hier ein Beispiel:
    'VB.NET. ACHTUNG CONVERTER

    VB.NET-Quellcode

    1. Namespace InheritanceTest
    2. Public MustInherit Class BaseVersionClass
    3. Public Overridable Property VersionDependentString() As String
    4. Get
    5. Return m_VersionDependentString
    6. End Get
    7. Set
    8. m_VersionDependentString = Value
    9. End Set
    10. End Property
    11. Private Overridable m_VersionDependentString As String
    12. Public Overridable Property VersionDependentInt() As Integer
    13. Get
    14. Return m_VersionDependentInt
    15. End Get
    16. Set
    17. m_VersionDependentInt = Value
    18. End Set
    19. End Property
    20. Private Overridable m_VersionDependentInt As Integer
    22. Public Overridable Sub DoVersionDependentStuff()
    23. 'Do some Stuff that is different from Version to Version.
    24. 'The base can be emtpy.
    25. End Sub
    26. End Class
    28. Class Version1_1Class
    29. Inherits BaseVersionClass
    30. Public Overrides Property VersionDependentInt() As Integer
    31. 'Do some access validation before returning it
    32. Get
    33. End Get
    34. 'Do some access validation before returning it
    35. Set
    36. End Set
    37. End Property
    38. Public Overrides Sub DoVersionDependentStuff()
    39. 'Do some stuff that only v1.1 does.
    40. End Sub
    41. End Class
    43. Class Version1_2Class
    44. Inherits Version1_1Class
    45. Public Overrides Property VersionDependentString() As String
    46. 'Do some access validation before returning it
    47. Get
    48. End Get
    49. 'Do some access validation before returning it
    50. Set
    51. End Set
    52. End Property
    54. Public Overrides Sub DoVersionDependentStuff()
    55. 'Do some stuff that is different from v1.1.
    56. End Sub
    57. End Class
    58. End Namespace

    C# Code

    C#-Quellcode

    1. namespace InheritanceTest
    2. {
    3. public abstract class BaseVersionClass
    4. {
    5. public virtual string VersionDependentString { get; set; }
    6. public virtual int VersionDependentInt { get; set; }
    8. public virtual void DoVersionDependentStuff()
    9. {
    10. //Do some Stuff that is different from Version to Version.
    11. //The base can be emtpy.
    12. }
    13. }
    15. class Version1_1Class : BaseVersionClass
    16. {
    17. public override int VersionDependentInt
    18. {
    19. get
    20. {
    21. //Do some access validation before returning it
    22. }
    23. set
    24. {
    25. //Do some access validation before returning it
    26. }
    27. }
    28. public override void DoVersionDependentStuff()
    29. {
    30. //Do some stuff that only v1.1 does.
    31. }
    32. }
    34. class Version1_2Class : Version1_1Class
    35. {
    36. public override string VersionDependentString
    37. {
    38. get
    39. {
    40. //Do some access validation before returning it
    41. }
    42. set
    43. {
    44. //Do some access validation before returning it
    45. }
    46. }
    48. public override void DoVersionDependentStuff()
    49. {
    50. //Do some stuff that is different from v1.1.
    51. }
    52. }
    53. }


    Dadurch kannst du dann sowas tun:
    'VB.NET Code ACHTUNG CONVERTER

    VB.NET-Quellcode

    1. Dim lstBSV As New List(Of BaseVersionClass)()
    2. lstBSV.Add(New Version1_1Class() With { _
    3. Key .VersionDependentInt = 1, _
    4. Key .VersionDependentString = "Test" _
    5. })
    6. lstBSV.Add(New Version1_2Class() With { _
    7. Key .VersionDependentInt = 2, _
    8. Key .VersionDependentString = "noch ein Test" _
    9. })
    11. For Each item As var In lstBSV
    12. item.DoVersionDependentStuff()
    13. Next

    C# Code

    C#-Quellcode

    1. List<BaseVersionClass> lstBSV = new List<BaseVersionClass>();
    2. lstBSV.Add(new Version1_1Class() { VersionDependentInt = 1, VersionDependentString = "Test" });
    3. lstBSV.Add(new Version1_2Class() { VersionDependentInt = 2, VersionDependentString = "noch ein Test" });
    5. foreach (var item in lstBSV)
    6. {
    7. item.DoVersionDependentStuff();
    8. }

    Es wird bei jedem Durchlauf nun nicht die Funktion der Basisklasse aufgerufen, sondern die jeweils überschriebene Varainte von V1_1 und V1_2.
    Gleiches beim Setzen der Properties.

    Nebenbei, wieso Strukturen?

    ProcessControl schrieb:

    verschiedenen (Struktur)Versionen
    Mach Dir eine gemeinsame Basisklasse, in denen die Operationen reinkommen, in den abgeleiteten Klassen die unterschiedlichen Daten.
    Wenn Du Daten speichern willst, nimm je Datensatz eine Property-Datenklasse und serialisiere die (XML oder binary), gugst Du hier.
    Wenn Du die Datenstruktur einer solchen Klasse änderst, werden die gemeinsamen Daten gelesen, die unterschiedlichen auf die initial vorgegebenen gesetzt.
    Beim nächsten Speichern ist wieder alles I.O.
    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!

    ProcessControl schrieb:

    Ich habe komplexe (vorgegebene!) Datenstrukturen zu bearbeiten, die aber in verschiedenen (Struktur)Versionen vorliegen.
    Das solltest du erstmal näher erläutern, weil davon hängt ab, was die beste Vorgehensweise ist.

    "vorgegebene Datenstruktur" sagt ja garnix - sind das Dateien? Xml? Csv? Text?

    Vorab: Sorry! Weil:
    1. Ich leider einige Zeit für ein Projekt unterwegs war, und eure Antworten nicht mehr gelesen habe.
    2. Der Erfinder hat recht: Ich hätte nicht soviel rumschwafeln sollen, sondern eher handfesten Code und Beispiele posten sollen.
    (Dann wäre das Problem deutlicher geworden)
    3. Die Frage von Earan war auch gerechtfertigt: Ich bin mir mittlerweile garnicht mehr sicher, ob "structures" wohl der richtige Weg waren...:-) Bin eher ungewollt da rein gekommen, weil MS die Dinger als "Ersatz" für die alten "Type" Definitionen von VB6 anpreist.
    Von der alten Zeit kommen auch noch die vielen Gigabytes an alten Daten, die ich leider auch heute noch immer mal wieder einlesen und verwerten können muss.

    Aber zum Problem:
    Ich habe tatsächlich meine structures nun so aufgebohrt, das jede von ihnen auch mit unterschiedlichen Versionen der Daten umgehen kann, und wenn gewünscht, auch zwischen den Versionen konvertieren kann.
    Insofern sind stuctures vielleicht doch garnicht so verkehrt, wenn man bedenkt, was man hier alles gleich an zugehörigem "Behandlungscode" mit reinpacken kann. :)

    Vielen Dank nochmal an euch für eure Antworten!

    Stefan