how to declare an event C# code example

Example 1: c# events

// --------------------- HOW TO CREATE EVENTS? ----------------------- //
// 1º - Main (Start the program)
// 2º - Publisher (the one that sends the event) 
// 3º - Subscriber (the one that receives the event)


// PUBLISHER:
class Publisher
{
   // 1º Create a delegate
   public delegate void MyEventHandler (object source, EventArgs args);

   // 2º Create an event based on that delegate
   public event MyEventHandler myEvents;

   // 3º Raise the event. For example, create a method that does:
   protected virtual void Method1()
   {
      if(myEvents != null)
      {
           myEvents(this, EventArgs.Empty);  // Calling the event if it points to some other method 
      }
   }

   public void Method2()
   {
      Console.WriteLine("This method is called from the Main function...");

      // Continuation of 3º step
      Method1();
     
    }
}


// SUBSCRIBER:
public class Subscriber
{
     public void Method1(object source, EventArgs e)
     {
            Console.WriteLine("The work done by the subscriber after the event was raised...");
      }
}


// MAIN:
class Program
{
   static void Main(string[] args)
   {
      var myPublisher = new Publisher();
      var mySubscriber = new Subscriber();

      // Give the Event a pointer to the function inside the class Subscriber
      myPublisher.myEvents += mySubscriber.Method1;

      myPublisher.Method2();
   }
}


// ----------- HOW TO PASS ARGUMENTS/DATA THROUGH EVENTS? ------------ //
// You have to create an EventArgs class, like:

public class MyNewEventArgs : EventArgs    // It will inherit from the EventArgs class, and you can add on top of that, some new information 
{
	public string newData {get; set;}	

}


// Then, you just need to change the following (in the code above):
// |  1º |
public delegate void EventHandler (object source, MyNewEventArgs args);  // Substitute EventArgs for MyNewEventArgs
// |  2º |
myEvents(this, new MyNewEventArgs() { newData = "Hello World!"} );  // Create an instance of the MyNewEventArgs class and pass it as a parameter of myEvents   
// |  3º |
public void Method1(object source, MyNewEventArgs e)   // Update all the other methods (substitute EventArgs for MyNewEventArgs)

// Now you can use the data inside the "e" variable on the Subscribers methods

Example 2: C# events

//1. (Optionally) Make a event class to return data in. Microsoft has a EventArgs class you can derive from, but benifits are minimal besides ahereance to standards.
//2. Make a event class 2 sub scribe to or that will publish the event.
//3. In any place you wish to use the event (subscribe to the event) or subscribe to the event.
    /// 1. An event argument to handle the Data received
    public class YourEventReceiveEventArgs : EventArgs
    {
    	//give out any properties you wish the subscriber to have here.
		//often makeing the set private so the event can be secure is a good idea.
        public byte[] YourDataAsProperties { get; private set; }
        public DateTime DateTime { get; private set; } = DateTime.UtcNow;
        internal DataReceiveEventArgs(byte[] Data){ this.Data = Data; }
    }
	//2. In the Class that will be raise (creates and orignates from) the event add a delegate EventHandler
	public class YourEventPublishingClass
    {
      	//Create a delegate of the signiture of methods you would like to subscribe the event to
      	//Optionally: The object is sender is optional but is a ahereance to standards.
      	//Optionally: Add the event class that you would like to pass data in
		public delegate void YourEventHandler(object Sender, DataReceiveEventArgs e);
		//create Your event using your newly created signature.
    	public event YourEventHandler YourEvent;
      	//Create a way to raise your event this could be a call to check
      	//something durring another in anthor thread or async watch method.
		protected void RaseEvent()
        {
          //if(Condtions are met)
          if(true)
          	handler?.Invoke(this, e);
        }
    }
	//3. Subscribe to event and attach a method to rase on the event
	private class YourSubscriberClass
	{
		//using instance of the class (or you could have a static style class in some rare cases) subscribe
      	//note how you instance and pass the class is up to you.
		private YourEventPublishingClass YourEventPublishingClassProperty;
      	public YourSubscriberClass(YourEventPublishingClass EventClassIn)
        {
      	   YourEventPublishingClassProperty = EventClassIn;
           YourEventPublishingClassProperty.YourEvent += YourEventRecivedMethodEvent;
        }
		//Make sure you your event follows the signature of your delagate
    	private void YourEventRecivedMethodEvent(object Sender, YourEventReceiveEventArgs e)
    	{
      		//replace this with your code
    	}
	}