Event handling using delegates

You are not using the recommended event declaration and handling schema designed to add additional arguments to the event in a uniform way. At the same time, you are trying to handle the even as if this schema is followed; as a result, you deal with EventArgs parameters which "knows" nothing about your string parameter. This scheme is based on overriding EventArgs class, but you are trying to use the base class; no wonder you cannot pass this string parameter.

Here is what you can do:

class MessageEventArgs : System.EventArgs {
    internal MessageEventArgs(string message) { this.Message = message; }
    public string Message { get; private set; } // this way, set is only used by a constuctor,
                                                // and get is needed to be public, to be accessed by the handlers
} // class MessageEventArgs

class MyClass {
   public System.EventHandler<MessageEventArgs> ClassLoaded; // instead of Systen.EventHandler
   void InvokeEvent(string message) {
       if (ClassLoaded)
           ClassLoaded.Invoke(this, new MessageEventArgs(message));
   }
} // class MyClass

By the way, the name of your event makes no sense anyway (a class is not "loaded", but it is instantiated), and it makes no sense anyway, because, if a constructor is not called, no code can add a handler to the invocation list of your even handler (it does not yet exist, unless it is static, which would make too little sense), and there is no point to handle an event in the declaring class itself. That's why I did not reproduce your constructor — the whole idea is wrong.

But, let's get back to event and its handling. The code using the class can add a handler to the invocation list of an event handler:

MyClass myObject = new MyClass( /* ... */ );
//...
myObject.ClassLoaded += (sender, eventArgs) => { // now eventArgs type is MessageEventArgs, inferred by a compiler from event type
    // so, in the handler you can use Message:
    HandleTheMessageTheWayYouWant(eventArgs.Message); // the value will be passed from the moment of invocation
};

—SA

I think I need to explain more why your approach is pointless. Your code is simply equivalent to this:

public class Class1
{
        //public delegate void FirstHandler(string msg); // no need for this type
        //public event FirstHandler isClassLoaded;       // no need for this event instance
 
        public Class1()
        {
            if (this.isClassLoaded == null) { Console.WriteLine("ClassLoaded null argument"); }
            FirstHandler_EventHandler("10 points"); 
            Console.WriteLine(isClassLoaded.ToString());
        }
 
        protected void FirstHandler_EventHandler(string message) // pseudo-abstract, inheritance will add functionality to it
        {
            //...
        }
      
}

Are you getting the idea? The event instances are needed to handle some event by different users of the class independently. Those users add different handles to the invocation list of the event, and all those handlers are called by the method Invoke of the event instance. Handling the event in the class declaring the event is totally useless and means defeat of the purpose of events.

Another your problem is the idea that instantiation of the class object can be handled with an instance (non-static) event. Your event is public, so it implies the class still can have users which can handle the event. The problem is: this event instance will never call any handlers (except your FirstHandler_EventHandler, which is pointless as I already explained before). Why? Just because the user code will be able to add a handler to this event after the instance of the class is already obtained. But in this case, a handler would be added too late, as the event instance is only invoked in the constructor. More generally, invocation of any non-static (instance) events in a constructor is totally useless.

Also, handling such event as object creation (which you mistakenly call "loading") is useless in principle. When you have a fragment of code creating the object, this is your event. Just think about it.

And, just for a record: with static event instances, the situation is totally different. You can use similar technique to catch the event when every instance of some class is created. This may make some sense, because one part of code creates an instance, and some other parts get notification on this event. But you should understand that using any static members is not thread-safe. To make such technique thread-safe, you could use thread synchronization primitives (such as lock), but the use of them depends on the threading scenario, so I would prefer not to discuss threading here. For example:

class MyClass {
   public static System.EventHandler ClassLoaded; // WARNING: not thread-safe!

   public MyClass() {}
       //...
       if (ClassLoaded != null)
          ClassLoaded.Invoke(this, new EventArgs());
   }

   //...

} // class MyClass

//...

MyClass firstObject = new MyClass();
//...
MyClass secondObject = new MyClass();

It may make certain sense because the event of creation of each of the instances (like those shown above) could be handled in one more mode different places of code:

MyClass.ClassLoaded += (sender, eventArgs) => { // note that the instance is not needed because ClassLoaded is static, that's the key
   MyClass instance = (MyClass)sender; // you can be sure that this cast is successful
   instance.SomeMyClassMember // this is how you can access the created instance and its instance members
}

Are you getting the idea now?

—SA