OOP - Eigenschaften von zwei Klassen abgleichen, die sich von einer Basisklasse ableiten.

  • VB.NET

Es gibt 13 Antworten in diesem Thema. Der letzte Beitrag () ist von FredM.

    OOP - Eigenschaften von zwei Klassen abgleichen, die sich von einer Basisklasse ableiten.

    Folgendes Beispiel:

    Ich habe eine Basisklasse und zwei Klassen die sich davon Ableiten mit ein paar zusätzlichen Eingenschaften.

    Nun möchte ich folgendes tun. In meinem Code später habe ich eine Instanz AppSettings laufen und viele Instanzen DocSettings.
    Jetzt möchte ich zu einen gegebenen Zeitpunkt alle Eigenschaften der Basisklasse meiner AppSettings Instanz in eine DocSettings Instanz schreiben.
    Natürlich könnte ich das einfach per Zuweisung DocSetting.P1 = AppSetting.P1, aber gibts da vielleicht einen schöneren Weg in einer Schleife oder so?
    Ist halt Pflegeleichter, weil wenn ich das in einer Schleife realisieren könnte, müsste ich dann einfach nur eine neue Eigenschaft hinzufügen und das wars, und nicht noch woanders im Code die Zuweisung hinzufügen.

    VB.NET-Quellcode

    1. Public Class BasicSettings
    2. Public Property P1 As String = ""
    3. Public Property P2 As String = ""
    4. Public Property P3 As String = ""
    5. Public Property P4 As Integer = 0
    6. Public Property P5 As Integer = 0
    7. End Class
    9. Public Class AppSettings
    10. Inherits BasicSettings
    12. Public Property A1 As String = ""
    13. Public Property A2 As Integer = 0
    14. End Class
    16. Public Class DocSettings
    17. Inherits BasicSettings
    19. Public Property D1 As Integer = 0
    20. Public Property D2 As Integer = 0
    21. Public Property D3 As String = ""
    22. End Class
    "Es ist absolut möglich, dass jenseits der Wahrnehmung unserer Sinne ungeahnte Welten verborgen sind." — Albert Einstein
    "Wenn die Macht der Liebe die Liebe zur Macht übersteigt, erst dann wird die Welt endlich wissen, was Frieden heißt." — Jimi Hendrix

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

    VB.NET-Quellcode

    1. Dim ap As AppSettings = '...
    2. Dim dsList As List(Of DocSettings) = '...
    3. For Each ds In dsList
    4. ds.D1 = ap.A1
    5. ds.D2 = ap.A2
    6. '...
    7. Next


    Oder wenn du nur alle P Variablen kopieren willst (die haben ja beide Unterklassen):

    VB.NET-Quellcode

    1. Dim ap As AppSettings = '...
    2. Dim dsList As List(Of DocSettings) = '...
    3. For Each ds In dsList
    4. ds.P1 = ap.P1
    5. ds.P2 = ap.P2
    6. '...
    7. Next


    Du könntest natürlich statt P1, P2, P3 auch einfach ein Array daraus machen, fall sie den gleichen Datentyp besitzen.

    Du willst alle Variablen auf einmal kopieren? Glaub jetzt hab ich verstanden was du meinst:
    Du brauchst eine Struktur:

    VB.NET-Quellcode

    1. Public Structure DatenZumUebergeben
    2. Dim P1 As Integer
    3. Dim P2 As Integer
    4. '...
    5. End Structure


    Später hast du die gesamten Daten deines Objektes in einer Instanz der Strukur:

    VB.NET-Quellcode

    1. Dim dzu As New DatenZumUebergeben


    Geht das in deine Richtung?

    Variablen über das Internet senden? [VB.NET] Universal Ticket.dll :thumbup:
    Lasse deine Programme selbstständig lernen! [VB.NET] Brain.dll     :thumbsup:

    Lass die abgeleiteten Klassen doch zusätzlich noch einen Methode erben, die eine Instanz von BasicSettings entgegen nimmt und deren Werte in die eigenen Properties schreibt.

    VB.NET-Quellcode

    1. Public Class BasicSettings
    2. Public Property P1 As String = ""
    3. Public Property P2 As String = ""
    4. Public Property P3 As String = ""
    5. Public Property P4 As Integer = 0
    6. Public Property P5 As Integer = 0
    8. Public Sub InsertSettings(ByVal SetObj As BasicSettings)
    9. P1 = SetObj.P1
    10. P2 = SetObj.P2
    11. 'und so weiter...
    12. End Sub
    13. End Class

    @FuFu^^
    Sowas würde ich dann aber eher im Konstruktor regeln.

    VB.NET-Quellcode

    1. Sub New(settings As BasicSettings)

    Damit ließe sich das dann sogar in der Basisklasse regeln, wodurch alle abgeleiteten Klassen ineinander konvertierbar wären.

    FredM schrieb:

    Jetzt möchte ich zu einen gegebenen Zeitpunkt...

    @Artentus: Dem entnehme ich für meinen Teil, dass das Übernehmen der "Basic-Properties" nicht zwingend auf den Zeitpunkt der Instanzierung der Objekte der abgleiteten Klassen fällt.


    Wenn du dir meinen Code ansiehst wirst du feststellen, dass ich das ebenfalls in der Basisklasse regele.

    ja richtig FuFu das übernehmen der Basic-Props passiert nicht zum Zeitpunkt der Instanzierung. Und vom gleichen Typ sind die eingeschaften nicht. Gibt String, Boolean und Integer.
    Irgendwie möchte ich halt die beiden abgeleiteten Klassen ineinander konvertieren können.

    Eine Instanz der Basisklasse gibt es bei mir im Code nicht. Die hab ich nur damit ich sie vererben kann.
    "Es ist absolut möglich, dass jenseits der Wahrnehmung unserer Sinne ungeahnte Welten verborgen sind." — Albert Einstein
    "Wenn die Macht der Liebe die Liebe zur Macht übersteigt, erst dann wird die Welt endlich wissen, was Frieden heißt." — Jimi Hendrix

    Ok so gehts :) Gibts noch ein anderen Weg nach Rom, wie war das mit den Strukturen?

    VB.NET-Quellcode

    1. Public Class Form1
    3. Dim aps As New AppSettings
    4. Dim dos As New DocSettings
    6. Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
    7. aps.P1 = "test1"
    8. aps.P2 = "test2"
    10. dos.P1 = "asdf1"
    11. dos.P2 = "asdf2"
    13. MsgBox(dos.P1)
    14. dos.InsertSettings(aps)
    15. MsgBox(dos.P1)
    16. End Sub
    17. End Class
    21. Public Class BasicSettings
    22. Public Property P1 As String = ""
    23. Public Property P2 As String = ""
    24. Public Property P3 As String = ""
    25. Public Property P4 As Integer = 0
    26. Public Property P5 As Integer = 0
    28. Public Sub InsertSettings(ByVal SetObj As BasicSettings)
    29. P1 = SetObj.P1
    30. P2 = SetObj.P2
    31. P3 = SetObj.P3
    32. P4 = SetObj.P4
    33. P5 = SetObj.P5
    34. End Sub
    35. End Class
    37. Public Class AppSettings
    38. Inherits BasicSettings
    40. Public Property A1 As String = ""
    41. Public Property A2 As Integer = 0
    42. End Class
    44. Public Class DocSettings
    45. Inherits BasicSettings
    47. Public Property D1 As Integer = 0
    48. Public Property D2 As Integer = 0
    49. Public Property D3 As String = ""
    50. End Class
    "Es ist absolut möglich, dass jenseits der Wahrnehmung unserer Sinne ungeahnte Welten verborgen sind." — Albert Einstein
    "Wenn die Macht der Liebe die Liebe zur Macht übersteigt, erst dann wird die Welt endlich wissen, was Frieden heißt." — Jimi Hendrix

    FredM schrieb:

    Jetzt möchte ich zu einen gegebenen Zeitpunkt alle Eigenschaften der Basisklasse meiner AppSettings Instanz in eine DocSettings Instanz schreiben.
    Natürlich könnte ich das einfach per Zuweisung DocSetting.P1 = AppSetting.P1, aber gibts da vielleicht einen schöneren Weg in einer Schleife oder so?
    Nein, ums Zuweisen jeder einzelnen Property kommste nicht drumrum, es sei denn du bemühst Reflection, aber das soll ziemlich unperformant sein.
    Ich nenne so eine Methoden gerne "CopyTo(other As Type)", und könnteste in diesem Fall auch inne Basisklasse anlegen.

    Möglicherweise kannst du eine Instanz einer Erbenden Klasse auch mit einer der Basisklasse überschreiben. Dann gehen allerdings die Werte der neuen Properties im Objekt der abgeleiteten Klassen verloren.
    Zwecks Konvertierbarkeit der abgeleiteten Objekte vielleicht auch mal mit Interfaces beschäftigen?


    Ich würd's so lassen wie du es jetzt hast. Falls du extrem viele Properties in der Basisklasse hast, könntest du den Code ggf. noch mit Reflection und Schleifen kürzen.
    //Na super, Erfinder :\ :D

    Danke mal so weit. :thumbup:

    So gehts auch, allerdings finde ich das nicht so schön, da jetzt die Basicsettings nur über die variable bs. aufrufbar ist.


    VB.NET-Quellcode

    1. Public Class Form1
    3. Dim aps As New AppSettings
    4. Dim dos As New DocSettings
    6. Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
    7. aps.bs.P1 = "test1"
    8. dos.bs.P1 = "asdf1"
    10. MsgBox(dos.bs.P1)
    11. dos.bs = aps.bs
    12. MsgBox(dos.bs.P1)
    13. End Sub
    14. End Class
    17. Public Structure BasicSettings
    18. Public Property P1 As String
    19. Public Property P2 As String
    20. Public Property P3 As String
    21. Public Property P4 As Integer
    22. Public Property P5 As Integer
    23. End Structure
    25. Public Class AppSettings
    26. Public bs As New BasicSettings
    28. Public Property A1 As String = ""
    29. Public Property A2 As Integer = 0
    30. End Class
    32. Public Class DocSettings
    33. Public bs As New BasicSettings
    35. Public Property D1 As Integer = 0
    36. Public Property D2 As Integer = 0
    37. Public Property D3 As String = ""
    38. End Class
    "Es ist absolut möglich, dass jenseits der Wahrnehmung unserer Sinne ungeahnte Welten verborgen sind." — Albert Einstein
    "Wenn die Macht der Liebe die Liebe zur Macht übersteigt, erst dann wird die Welt endlich wissen, was Frieden heißt." — Jimi Hendrix

    Hier noch meine Schleife über alle Properties :)

    VB.NET-Quellcode

    1. Public Sub InsertSettings(ByRef SetObj As BasicSettings)
    2. Dim bs As New BasicSettings
    3. For Each prop In bs.GetType.GetProperties()
    4. Dim target_prop As System.Reflection.PropertyInfo = Me.GetType.GetProperty(prop.Name)
    5. Dim source_prop As System.Reflection.PropertyInfo = SetObj.GetType.GetProperty(prop.Name)
    6. target_prop.SetValue(Me, source_prop.GetValue(SetObj, Nothing), Nothing)
    7. Next
    8. End Sub
    "Es ist absolut möglich, dass jenseits der Wahrnehmung unserer Sinne ungeahnte Welten verborgen sind." — Albert Einstein
    "Wenn die Macht der Liebe die Liebe zur Macht übersteigt, erst dann wird die Welt endlich wissen, was Frieden heißt." — Jimi Hendrix