Event über mehrere Klassen

  • VB.NET

SSL ist deaktiviert! Aktivieren Sie SSL für diese Sitzung, um eine sichere Verbindung herzustellen.

    Event über mehrere Klassen

    Hallo,

    ich hab eine Form, in welcher eine Klasse instanziert wird.
    Diese Klasse enthält eine weitere Klasse, welche wiederum eine Textbox enthält.

    Wie leitet man am besten das TextChanged-Event - oder irgend ein anderes Event - bis zur Form durch ?

    Gruss

    mikeb69
    Hallo,

    hab mal einen Beispielcode erstellt.

    VB.NET-Quellcode

    1. Public Class Form1
    2. Private c1 As New class1
    3. End Class
    4. Public Class class1
    5. Private c2 As New class2
    6. End Class
    7. Public Class class2
    8. Private tb As New TextBox
    9. Public Sub New()
    10. AddHandler tb.TextChanged, AddressOf textchanged
    11. End Sub
    12. Private Sub textchanged(sender As Object, e As EventArgs)
    13. 'Hier ist das Event um das es geht.
    14. 'Dieses Event soll bis zur Form durchgeleitet werden
    15. End Sub
    16. End Class


    Wie leite ich das Event bis zur Form durch ?

    Gruss

    mikeb69
    Ich meine etwa so:

    VB.NET-Quellcode

    1. Public Class Form1
    2. Private _class1 As New Class1
    3. Private Sub Form1_Load(sender As System.Object, e As System.EventArgs) Handles MyBase.Load
    4. AddHandler _class1.TextBox.TextChanged, AddressOf Me.TextBoxTextChanged
    5. _class1.ChangeText("Haaallllloooooo")
    6. End Sub
    7. Private Sub TextBoxTextChanged(sender As Object, e As EventArgs)
    8. With DirectCast(sender, TextBox)
    9. Debug.Print("Text geändert: '{0}'", .Text)
    10. End With
    11. End Sub
    12. End Class
    13. Public Class Class1
    14. Private _txtbox As New TextBox
    15. Public ReadOnly Property TextBox As TextBox
    16. Get
    17. Return _txtbox
    18. End Get
    19. End Property
    20. Public Sub ChangeText(newText As String)
    21. _txtbox.Text = newText
    22. End Sub
    23. End Class
    Hallo xtts02,

    so wäre es einfach.
    Meine Textbox befindet sich aber eine Klasse weiter.

    Klar kann ich in der Klasse die dazwischen liegt auch ein oder mehrere Event(s) definieren.
    So viele werden es nicht werden !

    Wie macht man sowas ?

    Gruss

    mikeb69
    Das funktioniert, auch wenn ich noch nicht verstehe das du eine Textbox in der Klasse 2 hälst.

    Was noch fehlt ist wenn du die Klassen frei gibst musst du die Handler auch wieder mit Remove Handler entfernen.

    Spoiler anzeigen

    VB.NET-Quellcode

    1. Public Class Form1
    2. ''' <summary>
    3. ''' Klasse 1
    4. ''' </summary>
    5. ''' <remarks></remarks>
    6. Private _c1 As Class1
    7. ''' <summary>
    8. ''' Beim laden der Form neue Instanz von Klasse 1 mit Handler zu Class2TextboxChanged
    9. ''' </summary>
    10. ''' <param name="sender"></param>
    11. ''' <param name="e"></param>
    12. ''' <remarks></remarks>
    13. Private Sub Form1_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load
    14. _c1 = New Class1
    15. AddHandler _c1.RedirectClass2TextChanged, AddressOf Class2TextboxChanged
    16. End Sub
    17. ''' <summary>
    18. ''' Wenn sich der Text in Textbox Klasse 2 ändert
    19. ''' </summary>
    20. ''' <param name="sender"></param>
    21. ''' <param name="e"></param>
    22. ''' <remarks></remarks>
    23. Private Sub Class2TextboxChanged(ByVal sender As Object, ByVal e As System.EventArgs)
    24. Dim t As String = CType(sender, TextBox).Text
    25. MsgBox(String.Format("Der Wert der Textbox in Klasse 2 ist:{0} ", t))
    26. End Sub
    27. ''' <summary>
    28. ''' Zum Testen
    29. ''' </summary>
    30. ''' <param name="sender"></param>
    31. ''' <param name="e"></param>
    32. ''' <remarks></remarks>
    33. Private Sub ButtonTest_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles ButtonTest.Click
    34. _c1.GetClass2.GetTextBox.Text = "TEST" 'Wert hier in Textbox Klasse2 setzen
    35. End Sub
    36. End Class
    37. Public Class Class1
    38. ''' <summary>
    39. ''' Weiterleitendes Event zwischen Klasse2 und Form
    40. ''' </summary>
    41. ''' <param name="sender"></param>
    42. ''' <param name="e"></param>
    43. ''' <remarks></remarks>
    44. Public Event RedirectClass2TextChanged(ByVal sender As Object, ByVal e As System.EventArgs)
    45. ''' <summary>
    46. ''' Klasse 2
    47. ''' </summary>
    48. ''' <remarks></remarks>
    49. Private _c2 As Class2
    50. ''' <summary>
    51. ''' Bei neuer Instanz Klasse 2 neu erstellen und Handler hinzufügen
    52. ''' </summary>
    53. ''' <remarks></remarks>
    54. Public Sub New()
    55. _c2 = New Class2
    56. AddHandler _c2.TextChangedClass2, AddressOf Class2TextboxChanged
    57. End Sub
    58. ''' <summary>
    59. ''' Für Testfall Klasse 2 zurück geben
    60. ''' </summary>
    61. ''' <value></value>
    62. ''' <returns></returns>
    63. ''' <remarks></remarks>
    64. Public ReadOnly Property GetClass2() As Class2
    65. Get
    66. Return _c2
    67. End Get
    68. End Property
    69. ''' <summary>
    70. ''' Abfangen und Weiterleiten des Events RedirectClass2TextChanged
    71. ''' </summary>
    72. ''' <param name="sender"></param>
    73. ''' <param name="e"></param>
    74. ''' <remarks></remarks>
    75. Private Sub Class2TextboxChanged(ByVal sender As Object, ByVal e As System.EventArgs)
    76. RaiseEvent RedirectClass2TextChanged(sender, e)
    77. End Sub
    78. End Class
    79. Public Class Class2
    80. ''' <summary>
    81. ''' Event für ändern des Textes in Textchanged
    82. ''' </summary>
    83. ''' <param name="sender"></param>
    84. ''' <param name="e"></param>
    85. ''' <remarks></remarks>
    86. Public Event TextChangedClass2(ByVal sender As Object, ByVal e As System.EventArgs)
    87. ''' <summary>
    88. ''' Textbox in Klasse 2
    89. ''' </summary>
    90. ''' <remarks></remarks>
    91. Private _tb As TextBox
    92. ''' <summary>
    93. ''' Bei neuer Instanz neue Textbox erstellen und Handler hinzufügen zu Textchanged
    94. ''' </summary>
    95. ''' <remarks></remarks>
    96. Public Sub New()
    97. _tb = New TextBox
    98. AddHandler _tb.TextChanged, AddressOf Textchanged
    99. End Sub
    100. ''' <summary>
    101. ''' Für Testfall
    102. ''' </summary>
    103. ''' <value></value>
    104. ''' <returns></returns>
    105. ''' <remarks></remarks>
    106. Public ReadOnly Property GetTextBox() As TextBox
    107. Get
    108. Return _tb
    109. End Get
    110. End Property
    111. ''' <summary>
    112. ''' Wenn sich der Text in der Textbox ändert
    113. ''' </summary>
    114. ''' <param name="sender"></param>
    115. ''' <param name="e"></param>
    116. ''' <remarks></remarks>
    117. Public Sub Textchanged(ByVal sender As Object, ByVal e As EventArgs)
    118. RaiseEvent TextChangedClass2(sender, e)
    119. End Sub
    120. End Class

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

    Theoretisch sollte es gehen. Wie man es in der Praxis aufbauen soll, weiß ich selber nicht. Aber für Armateuren wie uns ist es eh egal. Hauptsache es tut sich 'was ;)

    VB.NET-Quellcode

    1. Public Class Form1
    2. Private WithEvents _class1 As New Class1
    3. Private Sub Form1_Load(sender As System.Object, e As System.EventArgs) Handles MyBase.Load
    4. _class1.Class2.ChangeText("Hallloooo")
    5. End Sub
    6. Private Sub _class1_TextBoxTextChanged(sender As Object, e As System.EventArgs) Handles _class1.TextBoxTextChanged
    7. Debug.Print("TextBox-Content changed to: '{0}'", DirectCast(sender, TextBox).Text)
    8. End Sub
    9. End Class
    10. Public Class Class1
    11. Public Event TextBoxTextChanged As EventHandler
    12. Private WithEvents _class2 As New Class2
    13. Public ReadOnly Property Class2 As Class2
    14. Get
    15. Return _class2
    16. End Get
    17. End Property
    18. Private Sub _class2_TextBoxTextChanged(sender As Object, e As System.EventArgs) Handles _class2.TextBoxTextChanged
    19. RaiseEvent TextBoxTextChanged(sender, e)
    20. End Sub
    21. End Class
    22. Public Class Class2
    23. Public Event TextBoxTextChanged As EventHandler
    24. Private _txtbox As New TextBox
    25. Public Sub New()
    26. AddHandler _txtbox.TextChanged, AddressOf Me.TextBox_TextChanged
    27. End Sub
    28. Private Sub TextBox_TextChanged(sender As Object, e As EventArgs)
    29. RaiseEvent TextBoxTextChanged(sender, e)
    30. End Sub
    31. Public Sub ChangeText(newText As String)
    32. _txtbox.Text = newText
    33. End Sub
    34. End Class
    Hallo mex100,

    so funktionert es, so hätte ich es gemacht, so gefällt es mir aber nicht.

    OK - das hab ich vor.

    Ich programmiere gerade - in den Arbeitspausen - an einem Editor.
    Dieser enthält ein Tabcontrol welches die Textboxen enthalten soll.

    Da ich die Logik für alle Editorfunktionen in einer Klasse haben will wird das von der Form getrennt.

    Da ein TabControl mehrere TabPages und somit mehrere Textboxen enthalten kann ist die oben beschriebene Class1 eine Container-Klasse.
    Diese Container-Klasse enthält Klassen die die Textbox und die Logik (kopieren, vergleichen, einfügen, löschen usw.) zur Textbox enthalten.

    Über eine Property stellt die Containerklasse die Textboxen, nach aussen hin, zur Verfügung.
    So kann jede Textbox der entsprechenden Tabpage zur Verfügung gestellt werden.

    Gruss

    mikeb69
    Ok wenn du das natürlich für viele Texboxen (Controls) machen willst ist das zu umständlich.

    Dann würde ich die Handler von der Form direkt in die Textbox der Klasse 2 setzen.
    Das setzt vorraus das die zwei Klassen immer bei Start Instanziert werden.

    Spoiler anzeigen

    VB.NET-Quellcode

    1. Public Class Form1
    2. ''' <summary>
    3. ''' Klasse 1
    4. ''' </summary>
    5. ''' <remarks></remarks>
    6. Private _tabC As TabPageContainer
    7. ''' <summary>
    8. ''' Beim schließen der Form
    9. ''' </summary>
    10. ''' <param name="sender"></param>
    11. ''' <param name="e"></param>
    12. ''' <remarks></remarks>
    13. Private Sub Form1_FormClosed(ByVal sender As Object, ByVal e As System.Windows.Forms.FormClosedEventArgs) Handles Me.FormClosed
    14. RemoveHandler _tabC.ContainerTabPage1.GetTextBox1.TextChanged, AddressOf Class2TextboxChanged
    15. End Sub
    16. ''' <summary>
    17. ''' Beim laden der Form neue Instanz von Klasse 1 mit Handler zu Class2TextboxChanged
    18. ''' </summary>
    19. ''' <param name="sender"></param>
    20. ''' <param name="e"></param>
    21. ''' <remarks></remarks>
    22. Private Sub Form1_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load
    23. _tabC = New TabPageContainer
    24. AddHandler _tabC.ContainerTabPage1.GetTextBox1.TextChanged, AddressOf Class2TextboxChanged
    25. End Sub
    26. ''' <summary>
    27. ''' Wenn sich der Text in Textbox Klasse 2 ändert
    28. ''' </summary>
    29. ''' <param name="sender"></param>
    30. ''' <param name="e"></param>
    31. ''' <remarks></remarks>
    32. Private Sub Class2TextboxChanged(ByVal sender As Object, ByVal e As System.EventArgs)
    33. Dim t As String = CType(sender, TextBox).Text
    34. MsgBox(String.Format("Der Wert der Textbox in Klasse 2 ist:{0} ", t))
    35. End Sub
    36. ''' <summary>
    37. ''' Zum Testen
    38. ''' </summary>
    39. ''' <param name="sender"></param>
    40. ''' <param name="e"></param>
    41. ''' <remarks></remarks>
    42. Private Sub ButtonTest_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles ButtonTest.Click
    43. _tabC.ContainerTabPage1.GetTextBox1.Text = "TEST" 'Wert hier in Textbox Klasse2 setzen
    44. End Sub
    45. End Class
    46. Public Class TabPageContainer
    47. ''' <summary>
    48. ''' Klasse 2
    49. ''' </summary>
    50. ''' <remarks></remarks>
    51. Private _t1 As TabPage1Container
    52. ''' <summary>
    53. ''' Bei neuer Instanz Klasse 2 neu erstellen und Handler hinzufügen
    54. ''' </summary>
    55. ''' <remarks></remarks>
    56. Public Sub New()
    57. _t1 = New TabPage1Container
    58. End Sub
    59. ''' <summary>
    60. ''' Für Testfall Klasse 2 zurück geben
    61. ''' </summary>
    62. ''' <value></value>
    63. ''' <returns></returns>
    64. ''' <remarks></remarks>
    65. Public ReadOnly Property ContainerTabPage1() As TabPage1Container
    66. Get
    67. Return _t1
    68. End Get
    69. End Property
    70. End Class
    71. Public Class TabPage1Container
    72. ''' <summary>
    73. ''' Textbox in Klasse 2
    74. ''' </summary>
    75. ''' <remarks></remarks>
    76. Private _tb As TextBox
    77. ''' <summary>
    78. ''' Bei neuer Instanz neue Textbox erstellen und Handler hinzufügen zu Textchanged
    79. ''' </summary>
    80. ''' <remarks></remarks>
    81. Public Sub New()
    82. _tb = New TextBox
    83. End Sub
    84. ''' <summary>
    85. ''' Für Testfall
    86. ''' </summary>
    87. ''' <value></value>
    88. ''' <returns></returns>
    89. ''' <remarks></remarks>
    90. Public ReadOnly Property GetTextBox1() As TextBox
    91. Get
    92. Return _tb
    93. End Get
    94. End Property
    95. End Class

    Hi.

    Ich würde das ganze mit einem allgemein formulierten Event lösen. In etwa so (ich habe dein Beispiel erweitert):
    Spoiler anzeigen

    VB.NET-Quellcode

    1. Public Class Form1
    2. Private c1 As New class1
    3. Private ep As IEventProvider
    4. Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
    5. ep = c1.ep
    6. AddHandler ep.GenericEvent, AddressOf GenericHandler
    7. End Sub
    8. Private Sub GenericHandler(ByVal sender As Object, ByVal e As EventArgs)
    9. MessageBox.Show("got event from: " & DirectCast(sender, Control).Name & ". New text = " & DirectCast(sender, Control).Text)
    10. End Sub
    11. 'Diese Methode fällt weg
    12. Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button2.Click
    13. c1.c2.FireEvent()
    14. End Sub
    15. End Class
    16. Public Class class1
    17. Public c2 As New class2 'nur für FireEvent Public --> wieder Private setzen
    18. ReadOnly Property ep() As IEventProvider
    19. Get
    20. Return c2
    21. End Get
    22. End Property
    23. End Class
    24. Public Class class2
    25. Implements IEventProvider
    26. Private tb As New TextBox With {.Name = "MyTextBox"}
    27. Public Sub New()
    28. AddHandler tb.TextChanged, AddressOf textchanged
    29. End Sub
    30. 'Diese Methode fällt weg
    31. Public Sub FireEvent()
    32. Dim rnd As New Random()
    33. tb.Text = rnd.Next().ToString()
    34. End Sub
    35. Private Sub textchanged(ByVal sender As Object, ByVal e As EventArgs)
    36. 'Hier ist das Event um das es geht.
    37. 'Dieses Event soll bis zur Form durchgeleitet werden
    38. RaiseEvent GenericEvent(sender, e)
    39. End Sub
    40. Private Event GenericEvent(ByVal sender As Object, ByVal e As System.EventArgs) Implements IEventProvider.GenericEvent
    41. End Class
    42. Public Interface IEventProvider
    43. Event GenericEvent As EventHandler
    44. End Interface

    Das geht natürlich auch andersrum:
    Spoiler anzeigen

    VB.NET-Quellcode

    1. Public Class Form1
    2. Implements IEventConsumer
    3. Private c1 As class1
    4. Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
    5. c1 = New class1(Me)
    6. End Sub
    7. 'Diese Methode fällt weg
    8. Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button2.Click
    9. c1.c2.FireEvent()
    10. End Sub
    11. Private Sub Handler(ByVal sender As Object, ByVal e As System.EventArgs) Implements IEventConsumer.Handler
    12. MessageBox.Show("got event from: " & DirectCast(sender, Control).Name & ". New text = " & DirectCast(sender, Control).Text)
    13. End Sub
    14. End Class
    15. Public Class class1
    16. Public c2 As class2 'nur für FireEvent Public --> wieder Private setzen
    17. Public Sub New(ByVal ec As IEventConsumer)
    18. c2 = New class2(ec)
    19. End Sub
    20. End Class
    21. Public Class class2
    22. Private tb As New TextBox With {.Name = "MyTextBox"}
    23. Private _ec As IEventConsumer
    24. Public Sub New(ByVal ec As IEventConsumer)
    25. _ec = ec
    26. AddHandler tb.TextChanged, AddressOf ec.Handler
    27. End Sub
    28. 'Diese Methode fällt weg
    29. Public Sub FireEvent()
    30. Dim rnd As New Random()
    31. tb.Text = rnd.Next().ToString()
    32. End Sub
    33. End Class
    34. Public Interface IEventConsumer
    35. Sub Handler(ByVal sender As Object, ByVal e As EventArgs)
    36. End Interface

    Die zweite Variante halte ich schon für ziemlich optimal. Falls das zu unspezifisch ist, kannst du die Handler auch für bestimme Ereignisse präzisieren, und zwar über einen EventMulticaster:
    Spoiler anzeigen

    VB.NET-Quellcode

    1. Public Class Form1
    2. Private c1 As class1
    3. Private WithEvents emc As New EventMulticaster
    4. Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
    5. c1 = New class1(emc)
    6. End Sub
    7. Private Sub TextChangedHandler(ByVal sender As Object, ByVal e As EventArgs) Handles emc.TextChanged
    8. MessageBox.Show("got event from: " & DirectCast(sender, Control).Name & ". New text = " & DirectCast(sender, Control).Text)
    9. End Sub
    10. 'Diese Methode fällt weg
    11. Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button2.Click
    12. c1.c2.FireEvent()
    13. End Sub
    14. End Class
    15. Public Class class1
    16. Public c2 As class2 'nur für FireEvent Public --> wieder Private setzen
    17. Public Sub New(ByVal ep As IEventProvider)
    18. c2 = New class2(ep)
    19. End Sub
    20. End Class
    21. Public Class class2
    22. Private tb As New TextBox With {.Name = "MyTextBox"}
    23. Private _ep As IEventProvider
    24. Public Sub New(ByVal ep As IEventProvider)
    25. _ep = ep
    26. AddHandler tb.TextChanged, AddressOf ep.TextBoxTextChanged
    27. End Sub
    28. 'Diese Methode fällt weg
    29. Public Sub FireEvent()
    30. Dim rnd As New Random()
    31. tb.Text = rnd.Next().ToString()
    32. End Sub
    33. End Class
    34. Public Interface IEventProvider
    35. Sub GenericHandler(ByVal sender As Object, ByVal e As EventArgs)
    36. Sub TextBoxTextChanged(ByVal sender As Object, ByVal e As EventArgs)
    37. 'spezifischere Handler hier definieren
    38. End Interface
    39. Public Class EventMulticaster
    40. Implements IEventProvider
    41. Public Event TextChanged As EventHandler 'As EventHandler(Of BlaAbcEventArgs)
    42. Public Event GenericEvent As EventHandler
    43. 'spezifischer(er) Handler, könnte z.B. AbcXyzPaintSonstwasEventArgs haben
    44. Public Sub TextBoxTextChanged(ByVal sender As Object, ByVal e As System.EventArgs) Implements IEventProvider.TextBoxTextChanged
    45. RaiseEvent TextChanged(sender, e)
    46. End Sub
    47. Public Sub GenericHandler(ByVal sender As Object, ByVal e As EventArgs) Implements IEventProvider.GenericHandler
    48. RaiseEvent GenericEvent(sender, e)
    49. End Sub
    50. End Class


    Die Kunst bei dieser Sache ist, möglichst viele Events in einem Handler zusammenzufassen. Wichtig ist, dass die Events nicht über X Klassen geroutet werden, sondern möglichst zentral abgeladen werden und diese Zentrale dann an registrierte Handler weiterleitet (siehe letztes Beispiel).
    Gruß
    hal2000
    Wichtig ist, dass die Events nicht über X Klassen geroutet werden,

    Why not? Sollte nicht jede Abteilung einer Firma an den Abteilungsleiter berichten? Werden Abteilungen übersprungen, steht immer jemand da ohne Ahnung, was passiert ist.

    Wenn ich die Problematik - und Hals Beispiele - verstanden habe (grüble immer noch...), dann wäre dies mit den IObservable(of...)- und IObserver(of...)-Schnittstellen zu erreichen. Die Klasse mit implementierem IObservable wird zum "Sender", der auf die subscribierten Klasse(n) Infos ausgibt. Der Observer dient als Empfänger der Nachrichten.

    Spoiler anzeigen

    VB.NET-Quellcode

    1. Public Class Broadcast
    2. Implements IObservable(Of Nachricht)
    3. Public AlleAbonnenten As New List(Of IObserver(Of Nachricht))
    4. Public Function Subscribe(observer As System.IObserver(Of Nachricht)) As System.IDisposable Implements System.IObservable(Of Nachricht).Subscribe
    5. AlleAbonnenten.Add(observer) 'Pseudo-Code
    6. End Function
    7. End Class
    8. Public Class Listener
    9. Implements IObserver(Of Nachricht)
    10. '...
    11. Public Sub OnNext(value As Nachricht) Implements System.IObserver(Of Nachricht).OnNext
    12. 'Hier kannst du mit der Klasse arbeiten, die übergeben wird.
    13. 'in deinem Beispiel evtl. ein Event.
    14. End Sub
    15. End Class
    16. Public Class Nachricht
    17. 'Diese Klasse enthält die Infos, die übergeben werden.
    18. End Class

    In diesem (tw. Pseudo-Code) Beispiel wäre Broadcast die Klasse2 aus Post Nr. 4, dort, wo sich der Event abspielt. In dieser könnte nun aus der Auflistung AlleAbonennten jedem Element mit der Element.Onnext-Methode die Nachricht übermittelt werden. Bei dir wäre das vom Unter-Untergeordneten Objekt zum Hauptobjekt.
    Beim Listener könnte man noch im Konstruktor den Broadcaster übergeben...

    Hoffentlich blickt hier noch jemand durch. Ich nicht mehr. :D
    @TE: Kennst du UserControls?
    Damit könnteste fast autarke Einheiten entwickeln, die je ein TextDokument bearbeiten könnenn.
    Davon dann auf jede TabPage eine - fertig ist ein tabbed Editor.

    Du mußt aber genau hirnen, wie du die Funktionalität verteilen willst: Etwa das TextChanged-Event braucht imo nicht bis zum Form durchgeleitet werden. Tatsächlich muß das Form glaub leidlich wenig über diese Ucls wissen: Laden und Speichern musses aufrufen können, das meiste annere müsste doch son Ucl autark erledigen können, glaubich.
    Programmier-Tipps:   allgemeine Tipps                                   Tipps zu DB-Programmierung
    Helferlein:                  Online Code-Übersetzer (c# <=> vb)   Decompiler ILSpy

    der_Kurt schrieb:

    Why not? Sollte nicht jede Abteilung einer Firma an den Abteilungsleiter berichten? Werden Abteilungen übersprungen, steht immer jemand da ohne Ahnung, was passiert ist.

    Um Code zu sparen. Es ist doch auch gut, wenn jede Abteilung ne Mail an die Poststelle sendet, welche die Nachricht wiederum an alle interessierten Empfänger weiterleitet. Die Instanzen "ohne Ahnung" können sich ja an den Multicaster hängen, wenn sie wollen.

    Um bei den Abteilungen zu bleiben:
    Der erste Ansatz ist für mehrere Abteilungen, die an denselben Empfänger senden, besser geeignet.
    Der zweite Ansatz ist für mehrere Empfänger, die von einer Abteilung empfangen, besser geeignet.
    Der dritte Ansatz ist eine Mischform, bei der es sowohl mehrere Abteilungen als auch mehrere Empfänger geben kann. Für jede Abteilung wird ein passender EventMulticaster (inklusive Interface) erstellt, den beliebige Empfänger instanzieren können. Dieses Konzept ist gut erweiterbar, da z.B. auch eine Liste von EMC-Instanzen übergeben werden kann. Das Interface legt fest, welche EMCs die Abteilung unterstützt.

    EDR hat übrigens Recht: Wenn es hier um irgendwelche (User-)Controls geht, sollte die Form die Ereignisse nicht verarbeiten. Das führt zu Abhängigkeiten, die früher oder später nicht mehr durchschaubar sind. Ein UserControl, das einen Handler in der einbindenden Klasse benötigt, um zu funktionieren, ist eindeutig ein Fehldesign.
    Gruß
    hal2000

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

    Hallo EDR,

    Etwa das TextChanged-Event braucht imo nicht bis zum Form durchgeleitet werden.

    dieses Event ist im Moment das einzige das ich durchleiten will.

    Einfach um die Menüpunkte für das Speichern aktivieren zu können wenn sich was getan hat.

    Gruss

    mikeb69
    @hal2000,

    wow - perfekt.
    Hab dein Beispiel (Multicaster) erfolgreich nach C# portiert und es tut genau was ich wollte.

    Vielen Dank

    mikeb69

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