Objekt überwachen und aktualisieren falls sich etwas ändert

  • VB.NET

Es gibt 17 Antworten in diesem Thema. Der letzte Beitrag () ist von Chriis.

    Objekt überwachen und aktualisieren falls sich etwas ändert

    Momentan setze ich ein wenig mit Klasse auseinander.
    Ich habe mir einer klasse erstellt und möchte nun ein aus dieser Klasse erzeugtes Objekt überwachen. Falls sie dort etwas ändert z.B "Objektname.Guthaben" ist nicht mehr "40" sondern " 50
    das dies wahrgenommen wird und z.B in einem Label wo das Guthaben angezeigt wird auch aktualisiert wird.

    Meine Hauptidee wäre dafür eine Sub zu schreiben die ich dann immer wenn sich was ändert aufrufe aber das müsste ich doch für jede variable machen oder?

    Ich blick das gerade nicht ganz.

    Das ist meine Klasse
    Spoiler anzeigen

    VB.NET-Quellcode

    1. Public Class UserProperties
    3. Dim _stufe As Integer = 1
    4. Dim _gender As Integer = 1
    5. Dim _money As Integer = 2000
    6. Dim _minions As Integer = 0
    7. Dim _name As String = "Name"
    8. Dim _wins As Integer = 0
    9. Dim _losts As Integer = 0
    10. Dim _color As Color = Color.Blue
    12. Public Property lvl() As Integer
    13. Get
    14. Return _stufe
    15. End Get
    16. Set(ByVal value As Integer)
    17. _stufe = value
    18. End Set
    19. End Property 'Stufe
    21. Public Property male() As Integer
    22. Get
    23. Return _gender
    24. End Get
    25. Set(ByVal value As Integer)
    26. _gender = value
    27. End Set
    28. End Property 'Gender
    30. Public Property currMoney() As Integer
    31. Get
    32. Return _money
    33. End Get
    34. Set(ByVal value As Integer)
    35. _money = value
    36. End Set
    37. End Property 'Money
    39. Public Property totalMinios() As Integer
    40. Get
    41. Return _minions
    42. End Get
    43. Set(ByVal value As Integer)
    44. _minions = value
    45. End Set
    46. End Property 'Minions
    48. Public Property igName() As String
    49. Get
    50. Return _name
    51. End Get
    52. Set(ByVal value As String)
    53. _name = value
    54. End Set
    55. End Property 'Name
    57. Public Property totalWins() As Integer
    58. Get
    59. Return _wins
    60. End Get
    61. Set(ByVal value As Integer)
    62. _wins = value
    63. End Set
    64. End Property 'Wins
    66. Public Property totalLosts() As Integer
    67. Get
    68. Return _losts
    69. End Get
    70. Set(ByVal value As Integer)
    71. _losts = value
    72. End Set
    73. End Property 'Loses
    75. Public Property currColor() As Color
    76. Get
    77. Return _color
    78. End Get
    79. Set(ByVal value As Color)
    80. _color = value
    81. End Set
    82. End Property 'Color
    86. End Class

    Dann sende, wenn sich die entsprechende Property ändert, ein Event.
    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!

    Hab jetzt mal ein wenig rumgebprobiert

    VB.NET-Quellcode

    1. Public Event PropertyChanged()
    2. Public Property lvl() As Integer
    3. Get
    4. Return _stufe
    5. End Get
    6. Set(ByVal value As Integer)
    7. _stufe = value
    8. RaiseEvent PropertyChanged()
    9. End Set
    10. End Property 'Stufe


    Und dann einfach so oder wie?

    VB.NET-Quellcode

    1. Private Sub change() Handles Me.PropertyChanged
    2. 'Aktualisieren
    3. End Sub

    Hi
    Ereignisse sollte man mit As EventHandler[(Of T)] deklarieren:

    VB.NET-Quellcode

    1. Public Event Event1 As EventHandler
    2. Public Event Event2 As EventHandler(Of MouseEventArgs)

    Der erste Parameter gibt an, was das Event ausgelöst hat, der zweite definiert zusätzliche Argumente, die übergeben werden sollen, wie die Position der Maus, Informationen über die Änderung, sich zwischendurch ggf. ändernde Werte oder eben Kontextinformationen.

    Gruß
    ~blaze~

    Zum Beispiel so:

    VB.NET-Quellcode

    1. Public Class Test
    2. Public Event ValueChanged As EventHandler
    4. Private _value As Integer
    6. Public Property Value As Integer
    7. Get
    8. Return _value
    9. End Get
    10. Set(value As Integer)
    11. _value = value
    12. OnValueChanged(EventArgs.Empty)
    13. End Set
    14. End Property
    16. Protected Overridable Sub OnValueChanged(e As EventArgs)
    17. RaiseEvent ValueChanged(Me, e)
    18. End Sub
    19. End Class

    OnValueChanged definiert man, um einen Aufruf in der Vererbungsfolge zu ermöglichen, sowie das Ereignis kontrolliert zu verschlucken, etc. Alternativ könnte das obige auch so aussehen:

    VB.NET-Quellcode

    1. Public Class ValueChangedEventArgs
    2. Inherits EventArgs
    4. Private _PreviousValue As Integer
    6. Public Property PreviousValue As Integer
    7. Get
    8. Return _value
    9. End Get
    10. Private Set(value As Integer)
    11. _value = value
    12. End Set
    13. End Property
    15. Public Sub New(previousValue As Integer)
    16. Me.PreviousValue = previousValue
    17. End Sub
    18. End Class
    20. Public Class Test
    21. Public Event ValueChanged As EventHandler(Of ValueChangedEventArgs)
    23. Private _value As Integer
    25. Public Property Value As Integer
    26. Get
    27. Return _value
    28. End Get
    29. Set(value As Integer)
    30. Dim previous As Integer = Value
    31. _value = value
    32. OnValueChanged(New ValueChangedEventArgs(previous))
    33. End Set
    34. End Property
    36. Protected Overridable Sub OnValueChanged(e As ValueChangedEventArgs)
    37. RaiseEvent ValueChanged(Me, e)
    38. End Sub
    39. End Class


    Schöne Verwendungsbeispiele sind übrigens z.B. Form.FormClosing, Form.MouseMove, INotifyPropertyChanged.PropertyChanged, Form.Paint und Form.Click.
    Form.FormClosing lässt zu, dass man Cancel setzt, sodass ggf. das Schließen der Form abgebrochen wird.
    Form.MouseMove hält die Änderungen fest, wie bspw. Modifizierer, die sich in der Zeit zwischen Tastendruck und Verarbeitung ändern können.
    INotifyPropertyChanged.PropertyChanged hat eine definierte Semantik, es wird aufgerufen, wenn sich der Wert, der durch den Namen definierte Eigenschaft, ändert. Der Name wird manuell angegeben (siehe Verwendung) und wird häufig für die Datenbindung verwendet.
    Form.Paint erlaubt den Zugriff auf das Zeichenobjekt e.Graphics, sodass man damit arbeiten kann.
    Bei Form.Click nimmt e je nach Ursache des Klicks unterschiedliche EventArgs-Erben an, so z.B. bei einem Mausklick MouseEventArgs.

    Events selber sind eigentlich eine Art Liste an Aufrufern (Delegaten), die aufgerufen werden, sobald das Ereignis ausgelöst wird.

    INotifyPropertyChanged an sich ist eine sehr unschöne Art der Eigenschaftenverwaltung. Es arbeitet indirekt und ist wohl eher rein zu Datenverarbeitungszwecken vorgesehen, da es den Eigenschaftennamen angibt, der indirekt über Reflection zugeordnet werden soll (oder eher entsprechende PropertyDescriptoren), statt eine Semantik zu verwenden, die das Verhalten definiert, wie es im Programmbeispiel von mir der Fall ist. Die Datenverarbeitung ist in einigen Punkten von der Architektur her aber eher unsauber, weil es keinen "lightweight" Descriptor für Properties gibt...

    Gruß
    ~blaze~

    Chriis schrieb:

    Meine Hauptidee wäre dafür eine Sub zu schreiben die ich dann immer wenn sich was ändert aufrufe aber das müsste ich doch für jede variable machen oder?
    Wie artentus schon sagte: Bei Betrachtung deiner Klasse drängt sich dringend auf, dass deine Klasse INotifyPropertyChanged implementieren sollte.
    Das setzt nämlich genau deine Hauptidee um (und die Sub musste nur einmal schreiben), und ist drüberhinaus ein guter Einstieg in die Welt der databinding-getriebenen Programmierung.

    kannste auch mal im ObjectBrowser angugge das Interface, und von dort mit F1 inne Msdn hopfen.

    Du solltest bei der Implementierung des Events in der Property aufpassen, dass Du nicht in StackOverflowExceptions läufst. Würdest Du versuchen, aus dem EventHandler heraus diese Property zu ändern, so ergibt sich eine Endlosschleife. Ich halte es generell für kein schönes Design, aus Properties heraus Events auszulösen. Du hast ohnehin die Kontrolle darüber, wann eine Property geändert wird. Für meine Logik ist ein Ereignis die Folge einer Aktion. Diese Aktionen sind für mein Verständnis eher Methoden oder Funktionen einer Klasse, keine Eigenschaften. Aber gut, muss jeder selber wissen.
    Die Unendlichkeit ist weit. Vor allem gegen Ende. ?(
    Manche Menschen sind gar nicht dumm. Sie haben nur Pech beim Denken. 8o

    Ein PropertyChanged-Event zur Implementierung des INotifyPropertyChanged-Interfaces wird logischerweise aus der Property ausgelöst, deswegen heisstes ja so.

    Hiermal bisserl was ausgearbeitetes

    VB.NET-Quellcode

    1. Imports System.ComponentModel
    3. Public Class UserProperties : Implements INotifyPropertyChanged
    5. #Region "INotifyPropertyChanged"
    6. Public Event PropertyChanged(sender As Object, e As PropertyChangedEventArgs) Implements INotifyPropertyChanged.PropertyChanged
    8. Protected Sub OnPropertyChanged(propName As String)
    9. RaiseEvent PropertyChanged(Me, New PropertyChangedEventArgs(propName))
    10. End Sub
    12. Protected Function SetProperty(Of T)(ByRef backingField As T, value As T, propName As String) As Boolean
    13. If Object.Equals(backingField, value) Then Return False
    14. backingField = value
    15. OnPropertyChanged(propName)
    16. Return True
    17. End Function
    18. #End Region 'INotifyPropertyChanged
    20. Dim _stufe As Integer = 1
    21. Dim _gender As Integer = 1
    22. Dim _money As Integer = 2000
    23. Dim _minions As Integer = 0
    24. Dim _name As String = "Name"
    25. Dim _wins As Integer = 0
    26. Dim _TotalLosts As Integer = 0
    27. Dim _color As Color = Color.Blue
    29. Public Property Lvl() As Integer
    30. Get
    31. Return _stufe
    32. End Get
    33. Set(ByVal value As Integer)
    34. SetProperty(_stufe, value, "Lvl")
    35. End Set
    36. End Property 'Stufe
    38. Public Property Male() As Integer
    39. Get
    40. Return _gender
    41. End Get
    42. Set(ByVal value As Integer)
    43. SetProperty(_gender, value, "Male")
    44. End Set
    45. End Property 'Gender
    47. Public Property CurrMoney() As Integer
    48. Get
    49. Return _money
    50. End Get
    51. Set(ByVal value As Integer)
    52. SetProperty(_money, value, "CurrMoney")
    53. End Set
    54. End Property 'Money
    56. Public Property TotalMinios() As Integer
    57. Get
    58. Return _minions
    59. End Get
    60. Set(ByVal value As Integer)
    61. SetProperty(_minions, value, "TotalMinios")
    62. End Set
    63. End Property 'Minions
    65. Public Property IgName() As String
    66. Get
    67. Return _name
    68. End Get
    69. Set(ByVal value As String)
    70. SetProperty(_name, value, "IgName")
    71. End Set
    72. End Property 'Name
    74. Public Property TotalWins() As Integer
    75. Get
    76. Return _wins
    77. End Get
    78. Set(ByVal value As Integer)
    79. SetProperty(_wins, value, "TotalWins")
    80. End Set
    81. End Property 'Wins
    83. Public Property TotalLosts() As Integer
    84. Get
    85. Return _TotalLosts
    86. End Get
    87. Set(ByVal value As Integer)
    88. SetProperty(_TotalLosts, value, "TotalLosts")
    89. End Set
    90. End Property 'Loses
    92. Public Property CurrColor() As Color
    93. Get
    94. Return _color
    95. End Get
    96. Set(ByVal value As Color)
    97. SetProperty(_color, value, "CurrColor")
    98. End Set
    99. End Property 'Color
    103. End Class

    @TE: zu deine Benamung:
    1. Public classmember immer groß schreiben
    2. BackingFields sollten ihrer Public Property namentlich entsprechen (etwa _TotalLosts <-> TotalLosts)

    @SpaceXY Das Event ändert ja nicht die Property sondern nur eine Variable. Sprich durch das Event wird das Event nicht noch einmal aufgerufen.

    @EDR Ungefähr genau das habe ich die ganze Zeit versucht :) Vielen Dank. Und ausnahmsweise habe ich es direkt verstanden dank dir.

    Echt? alles verstanden?
    Auch das mit dem Interface? Und dass die SetProperty-Sub erst testet, ob der neue Wert auch neu ist, bevor das Event geraist wird? Und warum OnPropertyChanged und SetProperty beide Protected sind, und nicht Public oder Private?
    Und der Typ-Parameter von SetProperty? nö - kauf ich dir nicht ab.

    jedenfallse wie gesagt: Deine Klasse stellt einen typischen Datensatz dar.
    Für Datensätze gibts enorm leistungsfähige Standard-Klassen, und Kernkonzept solcher Datenverarbeitung ist Databinding.
    Und Grundlage von Databinding ist das INotifyPropertyChanged-Interface, was von Datenklassen zu implementieren ist, damit die anneren Technologien ühaupt greifen können.
    Wohin dich das führen kann ist in vier Views-Videos kurz angerissen.

    Vmtl. bist du noch nicht so weit, aber du scheinst mir doch auf dem Weg dahin, denn offensichtlich hast du nach INotifyPropertyChanged gesucht. :thumbsup:

    Ist ja gut :D. Sagen wir mal so: Ich habe es im groben verstanden. ...groooben. Ich gönn mir jetzt erstmal einen Kaffee und dann schau ich mir das alles noch mal an.
    Einen Teil ( sagen wir 45%) habe ich wirklich verstanden. Den Rest versuch ich sobald ich meinen Kaffee getrunken habe zu verstehen.

Facebook
Telefonspende