C# to VB.Net Eventhandling

  • VB.NET
  • .NET (FX) 4.5–4.8

Es gibt 18 Antworten in diesem Thema. Der letzte Beitrag () ist von ThuCommix.

    C# to VB.Net Eventhandling

    Haudi,

    hab gerade ein Problem, ein Kollege hat mir bei einer Klasse geholfen, nur leider ist diese in C# und da ich wenig erfahrung habe mit Eventhandling, verstehe ich nicht, wie ich diese in VB.Net übersetzt bekomme.

    C# - Code:
    Spoiler anzeigen

    C#-Quellcode

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Diagnostics;
    4. using System.IO.Ports;
    5. using System.Threading;
    6. using System.Windows.Forms;
    8. {
    9. Public Class ComHelper
    10. {
    11. public delegate void DetectedComPortEventHandler(object sender, ComPortDetectedEventArgs e);
    12. public delegate void ProgressEventHandler(object sender, ComHelperProgressChangedEventArgs e);
    13. public event ComHelper.DetectedComPortEventHandler DetectedComPort;
    14. public event ComHelper.ProgressEventHandler ProgressChanged;
    15. public int Range
    16. {
    17. get;
    18. set;
    19. }
    20. Public ComHelper()
    21. {
    22. this.Range = 100;
    23. }
    24. public ComHelper(int range)
    25. {
    26. this.Range = range;
    27. }
    28. public void Run()
    29. {
    30. Thread thread = new Thread(new ThreadStart(this.InternalRun));
    31. thread.Start();
    32. }
    33. private void InternalRun()
    34. {
    35. List<ComPort> list = new List<ComPort>();
    36. for (int i = 0; i <= this.Range; i++)
    37. {
    38. try
    39. {
    40. SerialPort serialPort = new SerialPort("COM" + i.ToString());
    41. serialPort.Open();
    42. serialPort.Close();
    43. list.Add(new ComPort(i));
    44. }
    45. catch
    46. {
    47. Debug.WriteLine("No rabbit on COM" + i.ToString());
    48. }
    49. if (this.ProgressChanged != null)
    50. {
    51. int percentage = 100 * i / this.Range;
    52. ComHelperProgressChangedEventArgs comHelperProgressChangedEventArgs = new ComHelperProgressChangedEventArgs(percentage);
    53. Delegate[] invocationList = this.ProgressChanged.GetInvocationList();
    54. for (int j = 0; j < invocationList.Length; j++)
    55. {
    56. ComHelper.ProgressEventHandler progressEventHandler = (ComHelper.ProgressEventHandler)invocationList[j];
    57. if (progressEventHandler.Target is Control && ((Control)progressEventHandler.Target).InvokeRequired)
    58. {
    59. ((Control)progressEventHandler.Target).Invoke(progressEventHandler, new object[]
    60. {
    61. this,
    62. comHelperProgressChangedEventArgs
    63. });
    64. }
    65. else
    66. {
    67. progressEventHandler(this, comHelperProgressChangedEventArgs);
    68. }
    69. }
    70. }
    71. }
    72. if (this.DetectedComPort != null)
    73. {
    74. ComPortDetectedEventArgs comPortDetectedEventArgs = new ComPortDetectedEventArgs(list.ToArray());
    75. Delegate[] invocationList = this.DetectedComPort.GetInvocationList();
    76. for (int j = 0; j < invocationList.Length; j++)
    77. {
    78. ComHelper.DetectedComPortEventHandler detectedComPortEventHandler = (ComHelper.DetectedComPortEventHandler)invocationList[j];
    79. if (detectedComPortEventHandler.Target is Control && ((Control)detectedComPortEventHandler.Target).InvokeRequired)
    80. {
    81. ((Control)detectedComPortEventHandler.Target).Invoke(detectedComPortEventHandler, new object[]
    82. {
    83. this,
    84. comPortDetectedEventArgs
    85. });
    86. }
    87. else
    88. {
    89. detectedComPortEventHandler(this, comPortDetectedEventArgs);
    90. }
    91. }
    92. }
    93. }
    94. }
    95. }




    Meine bisherigen Versuche sehen so aus: (Problemstellen sind kommentiert)
    Spoiler anzeigen

    VB.NET-Quellcode

    1. Imports System
    2. Imports System.Collections.Generic
    3. Imports System.Diagnostics
    4. Imports System.IO.Ports
    5. Imports System.Threading
    6. Imports System.Windows.Forms
    8. Public Class ComHelper
    9. Public Delegate Sub DetectedComPortEventHandler(sender As Object, e As ComPortDetectedEventArgs)
    10. Public Delegate Sub ProgressEventHandler(sender As Object, e As ComHelperProgressChangedEventArgs)
    11. Public Event DetectedComPort As ComHelper.DetectedComPortEventHandler
    12. Public Event ProgressChanged As ComHelper.ProgressEventHandler
    13. Public Property Range() As Integer
    15. Public Sub New()
    16. Me.Range = 100
    18. End Sub
    20. Public Sub New(range As Integer)
    21. Me.Range = range
    22. End Sub
    24. Public Sub Run()
    25. Dim thread As New Thread(AddressOf Me.InternalRun)
    26. thread.Start()
    27. End Sub
    29. Private Sub InternalRun()
    30. Dim list As List(Of ComPort) = New List(Of ComPort)()
    31. For i As Integer = 0 To Me.Range
    32. Try
    33. Dim serialPort As SerialPort = New SerialPort("COM" + i.ToString())
    34. serialPort.Open()
    35. serialPort.Close()
    36. list.Add(New ComPort(i))
    37. Catch ex_45 As Exception
    38. Debug.WriteLine("No rabbit on COM" + i.ToString())
    39. End Try
    40. '#######################################
    41. ' Ab hier geht es los
    42. If Me.ProgressChanged IsNot Nothing Then
    43. Dim percentage As Integer = 100 * i / Me.Range
    44. Dim comHelperProgressChangedEventArgs As ComHelperProgressChangedEventArgs = New ComHelperProgressChangedEventArgs(percentage)
    45. Dim invocationList As [Delegate]() = Me.ProgressChanged.GetInvocationList()
    46. For j As Integer = 0 To invocationList.Length - 1
    47. Dim progressEventHandler As ComHelper.ProgressEventHandler = CType(invocationList(j), ComHelper.ProgressEventHandler)
    48. If TypeOf progressEventHandler.Target Is Control AndAlso (CType(progressEventHandler.Target, Control)).InvokeRequired Then
    49. (CType(progressEventHandler.Target, Control)).Invoke(progressEventHandler, New Object()() { Me, comHelperProgressChangedEventArgs })
    50. Else
    51. progressEventHandler(Me, comHelperProgressChangedEventArgs)
    52. End If
    53. Next
    54. End If
    55. 'Bis hierhin....
    56. 'Abfrage unten entprechend gleich
    57. '########################################
    58. Next
    59. If Me.DetectedComPort IsNot Nothing Then
    60. Dim comPortDetectedEventArgs As ComPortDetectedEventArgs = New ComPortDetectedEventArgs(list.ToArray)
    61. Dim invocationList As [Delegate]() = Me.DetectedComPort.GetInvocationList()
    62. For j As Integer = 0 To invocationList.Length - 1
    63. Dim detectedComPortEventHandler As ComHelper.DetectedComPortEventHandler = CType(invocationList(j), ComHelper.DetectedComPortEventHandler)
    64. If TypeOf detectedComPortEventHandler.Target Is Control AndAlso (CType(detectedComPortEventHandler.Target, Control)).InvokeRequired Then
    65. (CType(detectedComPortEventHandler.Target, Control)).Invoke(detectedComPortEventHandler, New Object()() { Me, comPortDetectedEventArgs })
    66. Else
    67. detectedComPortEventHandler(Me, comPortDetectedEventArgs)
    68. End If
    69. Next
    70. End If
    71. End Sub
    72. End Class




    Wäre wirklich cool wenn mir einer kurz helfen könnte und gegebenenfalls kurz erklären :)

    Dankeschön :)

    shaebich schrieb:

    Eventhandling
    geht inzwischen so:

    VB.NET-Quellcode

    1. Public Event MyEvent(sender As Object, e As EventArgs)
    2. Private Sub DoAnything()
    3. RaiseEvent MyEvent(Me, EventArgs.Empty)
    4. End Sub

    C#-Quellcode

    1. public EventHandler<EventArgs> MyEvent;
    2. private void DoAnything()
    3. {
    4. if(this.MyEvent != null)
    5. {
    6. this.MyEvent(this, EventArgs.Empty);
    7. }
    8. }

    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!

    @RodFromGermany Da fehlt aber das ​event-Schlüsselwort im C#-Code:

    C#-Quellcode

    1. ​public event EventHandler<EventArgs> MyEvent;
    2. private void DoAnything()
    3. {
    4. if(this.MyEvent != null)
    5. {
    6. this.MyEvent(this, EventArgs.Empty);
    7. }
    8. }
    Mit freundlichen Grüßen,
    Thunderbolt

    Der Ausgangs-Code ist kein korrektes c#, bitte kopiere wirklichen c#-Code ein.
    Ausserdem ist veraltet - glaub das meinte Rod - dass eigene Delegaten creiert werden - da nimmt man seit 2005 generische Delegaten.
    Daher braucht man den korrekten c#-Code, muss den bisserl aufarbeiten, und dann übersetzen.

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

    @ErfinderDesRades was meinst du mit wirklichen c# Code? Habe bisher noch nichts Delegates gebastelt, da alles mit Async und Await funktioniert hat.
    @RodFromGermany Danke. Den Grundgedanke von Event und wie man diese verwendet ist mir schon klar. Allerdings verstehe ich einfach nicht was der C# Code macht :D
    Wieso kann man ein Event auf Nothing prüfen? Und was macht der Rest von:
    Spoiler anzeigen

    C#-Quellcode

    1. if (this.ProgressChanged != null)
    2. {
    3. int percentage = 100 * i / this.Range;
    4. ComHelperProgressChangedEventArgs comHelperProgressChangedEventArgs = new ComHelperProgressChangedEventArgs(percentage);
    5. Delegate[] invocationList = this.ProgressChanged.GetInvocationList();
    6. for (int j = 0; j < invocationList.Length; j++)
    7. {
    8. ComHelper.ProgressEventHandler progressEventHandler = (ComHelper.ProgressEventHandler)invocationList[j];
    9. if (progressEventHandler.Target is Control && ((Control)progressEventHandler.Target).InvokeRequired)
    10. {
    11. ((Control)progressEventHandler.Target).Invoke(progressEventHandler, new object[]
    12. {
    13. this,
    14. comHelperProgressChangedEventArgs
    15. });
    16. }
    17. else
    18. {
    19. progressEventHandler(this, comHelperProgressChangedEventArgs);
    20. }
    21. }
    22. }


    schon Public Class kompiliert nicht, denn solch wird in c# klein geschrieben. Daher ist der Code, der gezeigt ist, nicht wirklich relevant.

    Was anne Events zu bemängeln ist, hat mit Async gar nix zu tun. Sondern - wie gesagt - mit den Events.
    Man könnte es leicht aufarbeiten, aber dazu musses erst mal in relevanter Form - also compilierbar - vorliegen.

    ErfinderDesRades schrieb:

    schon Public Class kompiliert nicht, denn solch wird in c# klein geschrieben. Daher ist der Code, der gezeigt ist, nicht wirklich relevant.


    Ok tut mir leid, keine ahnung wieso beim kopieren aus die 2 wörter groß geschrieben worden sind.

    Also hier die Class ComHelper
    Spoiler anzeigen

    C#-Quellcode

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Diagnostics;
    4. using System.IO.Ports;
    5. using System.Linq;
    6. using System.Text;
    7. using System.Threading;
    8. using System.Threading.Tasks;
    9. using System.Windows.Forms;
    11. namespace WindowsFormsApplication1
    12. {
    13. public class ComHelper
    14. {
    15. public delegate void DetectedComPortEventHandler(object sender, ComPortDetectedEventArgs e);
    16. public delegate void ProgressEventHandler(object sender, ComHelperProgressChangedEventArgs e);
    17. public event ComHelper.DetectedComPortEventHandler DetectedComPort;
    18. public event ComHelper.ProgressEventHandler ProgressChanged;
    19. public int Range
    20. {
    21. get;
    22. set;
    23. }
    24. public ComHelper()
    25. {
    26. this.Range = 100;
    27. }
    28. public ComHelper(int range)
    29. {
    30. this.Range = range;
    31. }
    32. public void Run()
    33. {
    34. Thread thread = new Thread(new ThreadStart(this.InternalRun));
    35. thread.Start();
    36. }
    37. private void InternalRun()
    38. {
    39. List<ComPort> list = new List<ComPort>();
    40. for (int i = 0; i <= this.Range; i++)
    41. {
    42. try
    43. {
    44. SerialPort serialPort = new SerialPort("COM" + i.ToString());
    45. serialPort.Open();
    46. serialPort.Close();
    47. list.Add(new ComPort(i));
    48. }
    49. catch
    50. {
    51. Debug.WriteLine("No rabbit on COM" + i.ToString());
    52. }
    53. if (this.ProgressChanged != null)
    54. {
    55. int percentage = 100 * i / this.Range;
    56. ComHelperProgressChangedEventArgs comHelperProgressChangedEventArgs = new ComHelperProgressChangedEventArgs(percentage);
    57. Delegate[] invocationList = this.ProgressChanged.GetInvocationList();
    58. for (int j = 0; j < invocationList.Length; j++)
    59. {
    60. ComHelper.ProgressEventHandler progressEventHandler = (ComHelper.ProgressEventHandler)invocationList[j];
    61. if (progressEventHandler.Target is Control && ((Control)progressEventHandler.Target).InvokeRequired)
    62. {
    63. ((Control)progressEventHandler.Target).Invoke(progressEventHandler, new object[]
    64. {
    65. this,
    66. comHelperProgressChangedEventArgs
    67. });
    68. }
    69. else
    70. {
    71. progressEventHandler(this, comHelperProgressChangedEventArgs);
    72. }
    73. }
    74. }
    75. }
    76. if (this.DetectedComPort != null)
    77. {
    78. ComPortDetectedEventArgs comPortDetectedEventArgs = new ComPortDetectedEventArgs(list.ToArray());
    79. Delegate[] invocationList = this.DetectedComPort.GetInvocationList();
    80. for (int j = 0; j < invocationList.Length; j++)
    81. {
    82. ComHelper.DetectedComPortEventHandler detectedComPortEventHandler = (ComHelper.DetectedComPortEventHandler)invocationList[j];
    83. if (detectedComPortEventHandler.Target is Control && ((Control)detectedComPortEventHandler.Target).InvokeRequired)
    84. {
    85. ((Control)detectedComPortEventHandler.Target).Invoke(detectedComPortEventHandler, new object[]
    86. {
    87. this,
    88. comPortDetectedEventArgs
    89. });
    90. }
    91. else
    92. {
    93. detectedComPortEventHandler(this, comPortDetectedEventArgs);
    94. }
    95. }
    96. }
    97. }
    98. }
    99. }



    ComPort
    ComHelperProgressChangedEventArgs
    ComPortDetectedEventArgs
    sollten für die Problemstellung hier eigentlich irrelevant sein.

    also so sieht bislang meine c#-Überarbeitung aus. Ich verwende generische Event-Deklarationen, und wende eine einfachere Technik an, um die Events im Gui-Thread zu feuern:

    C#-Quellcode

    1. public class ComHelper {
    2. public event EventHandler<ComPortDetectedEventArgs> DetectedComPort;
    3. public event EventHandler<ComHelperProgressChangedEventArgs> ProgressChanged;
    4. public int Range {
    5. get;
    6. set;
    7. }
    8. public ComHelper() {
    9. this.Range = 100;
    10. }
    11. public ComHelper(int range) {
    12. this.Range = range;
    13. }
    14. public void Run() {
    15. Thread thread = new Thread(new ThreadStart(this.InternalRun));
    16. thread.Start();
    17. }
    18. private void InternalRun() {
    19. var list = new List<ComPort>();
    20. var ctl = Application.OpenForms[0];
    21. for (int i = 0; i <= this.Range; i++) {
    22. try {
    23. SerialPort serialPort = new SerialPort("COM" + i.ToString());
    24. serialPort.Open();
    25. serialPort.Close();
    26. list.Add(new ComPort(i));
    27. }
    28. catch {
    29. Debug.WriteLine("No rabbit on COM" + i.ToString());
    30. }
    31. if (this.ProgressChanged != null) {
    32. int percentage = 100 * i / this.Range;
    33. var comHelperProgressChangedEventArgs = new ComHelperProgressChangedEventArgs(percentage);
    34. ctl.BeginInvoke(ProgressChanged, this, comHelperProgressChangedEventArgs);
    35. }
    36. }
    37. if (this.DetectedComPort != null) {
    38. var comPortDetectedEventArgs = new ComPortDetectedEventArgs(list.ToArray());
    39. ctl.BeginInvoke(DetectedComPort, this, comPortDetectedEventArgs);
    40. }
    41. }
    42. }
    Aber ist das wirklich ein erwünschtes Verhalten, dass wann immer ein ProgressChanged gefeuert wird, dass gleichzeitig auch das ComportDetected - Event zu feuern ist?
    Eine andere Fragwürdigkeit scheint mir, dass für jeden Comport im Range ein ProgressChanged gefeuert wird - woher weiß der Empfänger nun, für welchen Comport es gilt?

    Und hier in vb:

    VB.NET-Quellcode

    1. Public Class ComHelper
    2. Public Event DetectedComPort As EventHandler(Of ComPortDetectedEventArgs)
    3. Public Event ProgressChanged As EventHandler(Of ComHelperProgressChangedEventArgs)
    4. Private _OnDetectedComPort As Action(Of ComPortDetectedEventArgs) = Sub(e) RaiseEvent DetectedComPort(Me, e)
    5. Private _OnProgressChanged As Action(Of ComHelperProgressChangedEventArgs) = Sub(e) RaiseEvent ProgressChanged(Me, e)
    6. Public Property Range() As Integer
    8. Public Sub New(Optional range As Integer = 100)
    9. Me.Range = range
    10. End Sub
    12. Public Sub Run()
    13. Dim thread As New Thread(New ThreadStart(AddressOf Me.InternalRun))
    14. thread.Start()
    15. End Sub
    17. Private Sub InternalRun()
    18. Dim list = New List(Of ComPort)()
    19. Dim ctl = Application.OpenForms(0)
    20. For i As Integer = 0 To Me.Range
    21. Try
    22. Dim serialPort As New SerialPort("COM" & i.ToString())
    23. serialPort.Open()
    24. serialPort.Close()
    25. list.Add(New ComPort(i))
    26. Catch
    27. Debug.WriteLine("No rabbit on COM" & i.ToString())
    28. End Try
    29. Dim comHelperProgressChangedEventArgs = New ComHelperProgressChangedEventArgs(100 * i \ Me.Range)
    30. ctl.BeginInvoke(_OnProgressChanged, comHelperProgressChangedEventArgs)
    31. Next
    32. Dim comPortDetectedEventArgs = New ComPortDetectedEventArgs(list.ToArray())
    33. ctl.BeginInvoke(_OnDetectedComPort, comPortDetectedEventArgs)
    34. End Sub
    35. End Class
    Bei Fragen fragen ;)

    (Und Ich hab auch eine Frage, nämlich obs funzt ;) ;) )

    Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von „ErfinderDesRades“ ()

    delegaten sind Referenzen auf Methoden und ein Event ist quasi eine Liste von delegaten, welche beim auftreten des Events aufgerufen werden. mit += new ... fügst du einem Event einen delegaten hinzu und mit -= entfernst du ihn entsprechend wieder. Wenn das Event-Objekt null/Nothing ist, ist dies gleichbedeutend damit, dass das Event von nirgends aus abonniert wurde, also du keinen delegaten hinzugefügt hast, dann kann auch kein delegate aufgerufen werden und du brauchst das Event auch nicht "raisen"
    Ich wollte auch mal ne total überflüssige Signatur:
    ---Leer---

    shaebich schrieb:

    kleines Sample Projekt
    mit kleinem Absturz bei Beendigung:

    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!

    Nur noch zur Vollständigkeit @ErfinderDesRades
    und wende eine einfachere Technik an

    Deine Technik mag zwar funktionieren, ist aber suboptimal. Zu bevorzugen wäre die SynchronizationContext Klasse. Diese ist genau dafür gemacht und vermeidet solch Fehler wie oben.


    Opensource Audio-Bibliothek auf github: KLICK, im Showroom oder auf NuGet.

    Mit SyncContext gäbe es halt eine andere Exception, aber das Problem löst das auch nicht.
    Und umständlicher und anfälliger zu bedienen ist er, weil birgt die Gefahr, im falschen Thread erstellt zu werden.

    Das Problem ist, dass der Thread läuft, und weiter das Gui aktualisieren will, auch wenn dieses schon geschlossen wurde.
    Mit meim Ansatz kann man das übrigens recht einfach abfangen - Control.IsDisposed abfragen.
    Mit SynchronisizeContext tut man sich da bischen schwerer und umständlicher.

    Hier habe ich übrigens den Ansatz ausgearbeitet, abgesichert und auf optimale Bedienfreundlichkeit fortentwickelt: codeproject.com/KB/vb/AsyncWorker2.aspx

    Kannste auch umstellen auf SyncContext, wenns beliebt - aber besser wird davon nix.

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

    Vielleicht sollte der Thread einfach gebeten werden, sich durch Verlassen der Thread-Prozedur selbst zu beenden.
    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!

    hatte aber extra im Form_Closing die Threads beendet.

    VB.NET-Quellcode

    1. Private Sub Form1_Closing(sender As Object, e As EventArgs) Handles Button2.Click, Me.FormClosing
    2. progressBarHelper.Abort()
    3. labelHelper1.Abort()
    4. labelHelper2.Abort()
    5. labelHelper3.Abort()
    6. labelHelper4.Abort()
    7. labelHelper5.Abort()
    8. labelHelper6.Abort()
    9. End Sub


    funktioniert bei mir auch ohne Probleme, vielleicht nicht die eleganteste Lösung, erfüllt allerding für die veranschaulichung des Projekts seinen Zweck :D

    ErfinderDesRades schrieb:

    Ausserdem ist veraltet - glaub das meinte Rod - dass eigene Delegaten creiert werden - da nimmt man seit 2005 generische Delegaten.


    Wow danke, daran hab ich gar nicht gedacht - Erspart eine Menge Arbeit.

Facebook
Telefonspende