Appropriate use of C # event handlers

Any advice or literature I have to read will be pointed out. I have no formal training in C #, so I apologize if I misrepresented anything.

This explains a few things. :)
I read about streams, event handling, and creating system tray icons / interfaces.

It is important to note the following:

• Events are processed on the same thread from which they are called. If you want the event handling to not block the GUI, you need the button to move the work to a different thread.

• When the event fires, it passes the appropriate arguments to all the methods in its list. This is almost the same as calling one method, which in turn calls all the others (see EventFired example). The purpose of events is not to call methods, since we can already do this, this is a call to methods that may not be known when the code is compiled (the click event on a control button will not be known when the library in which the control is located, for example, is compiled). In short, if you can call a method instead of using an event, then do so.

  void EventFired(int arg1, object arg2)
  {
      subscribedMethod1(arg1, arg2);
      SubscribedMethod2(arg1, arg2);
      SubscribedMethod3(arg1, arg2);
      SubscribedMethod4(arg1, arg2);
      SubscribedMethod5(arg1, arg2);
      SubscribedMethod6(arg1, arg2);
      SubscribedMethod7(arg1, arg2);
  }
  
        
  
          
          
          
        
  
      

• If you want the UI not blocking work on another thread. Remember that UI elements (forms, buttons, grids, labels, etc.) can only be accessed from their host thread. Use control.Invoke method to call methods on your thread.

• Removing the option from the interface is not a good way to prevent pavement conditions (the user triggers the connect / disconnect when it is already running), as the UI will be on a different thread and may not be synchronized (it takes time for the individual threads to synchronize). While there are many ways to solve this problem, the easiest way for someone new to streaming is to use value locking. This way .NET will make sure that only one thread can change the setting at a time. You will still have to update the UI to let the user know that the update is taking place.

Your overall design sounds fine. You can use 2-3 threads (1 for the UI (tray icon), 1 for checking new network connections, and 1 (can be combined with checking the connection) that checks the internet connection.

Hope this helps, let us know if you need more (or accept an answer).

If you want no more than one state change to occur at any time, it is best to have event handlers for external events that you listen to in order to hold the lock while they are executing. This provides an easy way to program because you are guaranteed that the state of your application does not change under you. In this particular case, a separate thread is not required.

You need to differentiate between the current state of the application and the target state. The user defines the target state ("connected", "disconnected"). Actual condition may vary. Example: the user wants to be disconnected, but the actual state is authenticated. After completing the authentication phase, the state machine should check the target state:

targetState == connected => set current state to connected
targetState == disconnected => begin to disconnect and set state to disconnecting

      

        
        
        
      

    

Separating the actual and target states allows the user to change their mind at any time, and the state machine to the desired state.