this.MyEvent += new MyDel(WelcomeUser); ( What exactly meaning of this line )

Question

using System;

namespace SampleApp {
   public delegate string MyDel(string str);
    
   class EventProgram {
      event MyDel MyEvent;
        
      public EventProgram() {
         this.MyEvent += new MyDel(this.WelcomeUser);
      }
      public string WelcomeUser(string username) {
         return "Welcome " + username;
      }
      static void Main(string[] args) {
         EventProgram obj1 = new EventProgram();
         string result = obj1.MyEvent("Tutorials Point");
         Console.WriteLine(result);
      }
   }
}

Answer 1

The idea of using events is to provide ability for some object, which stores this event (called "publisher") notify some others objects (called "subscribers"), who subscribed to this event, that something happened.

Your example may be used in a way "Notify when some user joined". It utilizes some sort of "Publisher-Subscriber pattern".

So, you have some EventProgram class, which is "publisher" that stores event OnUserJoin, which is fired every time when user joins (adds to List). Event firing provided through invoking OnUserJoin EventHandler after adding new user. When invoking it, we providing username to UserJoinedEventArgs - which are a kind of "details" of "what was happened". OnUserJoin? (with ?) means a check, that there are some "subscribers" to who we can "send notification".

public class EventProgram
{
    private readonly List<string> users;

    // Publishing event for "subscribers"
    public event EventHandler<UserJoinedEventArgs> OnUserJoin;

    public EventProgram() 
    {
        users = new List<string>();
    }

    public void AddNewUser(string username)
    {
        // Adding new user
        users.Add(username);
        // And calling event to notify "subscribers" that we added provided user
        OnUserJoin?.Invoke(this, new UserJoinedEventArgs { Username = username });
    }
}

// Custom details for our event
public class UserJoinedEventArgs
{
    public string Username { get; set; }
    // and other details you wish to provide about joined user
}

And usage of it as a "subscriber" is to create handler (HandleUserJoin in example), which will "accept notifications" from "publisher" class and do something with accepted details from UserJoinedEventArgs.

void Main(string[] args = default)
{ 
    EventProgram eventProgram = new EventProgram();
    // "Subscribing" to "publisher"'s event with `HandleUserJoin` handler
    eventProgram.OnUserJoin += HandleUserJoin;

    // Adding new user
    eventProgram.AddNewUser("Mr.Wadile");
}

// This handler is actually "subscriber", which waits for notifications
// from "publisher"'s OnUserJoin event with details, provided
// as UserJoinedEventArgs
private void HandleUserJoin(object sender, UserJoinedEventArgs args)
{
    Console.WriteLine("Welcome, " + args.Username);
} 

At result, each time when we adding new user with .AddNewUser("Some Username") - "publisher" EventProgram will notify us through OnUserJoin event and when we "accept" this notification in HandleUserJoin - we print welcome message.

Answering to question about += operator - this is actually "subscribing" process, when you "subscribing" HandleUserJoin method to notifications from OnUserJoin event (in this example).

Delegates are, in common, "pointers" to some methods, which match to delegate signature. Based on example above, you can use delegate to combine different actions and call them all as one:

public class EventProgram
{
    private readonly List<string> users;
    // Delegate declaration with "void (string)" signature
    public delegate void JoinUser(string username);

    // A field of delegate type, that will be used to call from other classes
    public JoinUser JoinNewUser;

    public EventProgram()
    {
        users = new List<string>();

        // Combining different actions with User into one delegate
        // First - assigning with "=" (+= can be used too)
        JoinNewUser = AddUserToDatabase;
        // Next - appending with "+="
        JoinNewUser += WelcomeUser;
        JoinNewUser += SendWelcomeGiftToUser;
    }

    // Matches to delegate signature "void (string)"
    private void AddUserToDatabase(string username)
    {
        users.Add(username);
        Console.WriteLine("New user \"" + username + "\" added to database!");
    }
   
    // Matches to delegate signature "void (string)"
    private void WelcomeUser(string username) =>
        Console.WriteLine("Welcome, " + username);

    // Matches to delegate signature "void (string)"
    private void SendWelcomeGiftToUser(string username) =>
        Console.WriteLine(username + ", we sending you 100$ as a welcome gift!");
}

So from other class we just call JoinNewUser after creating instance of EventProgram, and all 3 actions will be invoked by delegate:

void Main(string[] args = default)
{
    EventProgram eventProgram = new EventProgram();
    eventProgram.JoinNewUser("Mr.Wadile");
}

So it would look like:

The += operator is usually used when subscribing to events, because the = operator would replace the "delegates stack" and only the last delegate would be executed. For example, in the previous example:

JoinNewUser = AddUserToDatabase;
JoinNewUser = WelcomeUser;
JoinNewUser = SendWelcomeGiftToUser;

Would only output the SendWelcomeGiftToUser delegate instead of the expected three delegates/functions/methods:

Mr Wadile, we sending you 100$ as a welcome gift