Okay - I've decided to try and enter the world of OOP, and I've decided to learn C#. There's no reason for this other than personal development. I started learning last week, and up until now Google has been good, but I think I need this one spelling out to me.

Firstly - I don't quite 'get' custom event handling. I can kinda make it work, but I don't understand it fully - in terms of events, delegates and handlers.

Secondly - and this is the bit I think I really need spelling out to me. I want to fire an event every time an object is created. That seems easy enough - just put it in the constructor.

I just don't know how to handle it - the examples I've looked at seem to show handling events PER object, but this needs to be global.

in other words, by purely running

MyClass test = new MyClass();
MyClass test2 = new MyClass();
MyClass test3 = new MyClass();

in the form, I might get the output

"New MyClass Created - ID is 1"
"New MyClass Created - ID is 2"
"New MyClass Created - ID is 3"

I'm told that classes shouldn't really interface with the GUI (and as I wanna try some multi threaded stuff later, this is a definite) I really need to understand how to make this work with events.

Ta for any help.

I've ended up doing it by creating a static class to house my CustomEvents. It feels like a good solution, as I only need to define the event handler once in the forms I want to use it. It also means I can put all my custom events together. It looks like this:

static class CustEventHandler
{

public delegate void NewCallDataEventHandler();

public static event NewCallDataEventHandler NewCallEvent;

public static void NewCall(int NewCallID)
{
NewCallID = 10;
if (NewCallEvent != null)
{
NewCallEvent();
}
}
}

And CustEventHandler.NewCall(); is ran from the other classes constructor. Obviously I haven't passed any values to the event, but I will.

 
public class CustEventHandler
{
 
public delegate void NewCallDataEventHandler();
 
public event NewCallDataEventHandler NewCallEvent;
 
public void NewCall(int NewCallID)
{
NewCallID = 10;
if (NewCallEvent != null)
{
NewCallEvent();
}
}
}

 
public class MyNewClass : CustEventHandler {
 public MyNewClass() {
  this.NewCall(10);
 }
}
 

// Derived from EventArgs class
class FooCreatedEventArgs : EventArgs
{
  // Field marked readonly can only be set in constructor/initializer
  private readonly Foo foo;
 
  public FooCreatedEventArgs(Foo foo)
  {
    this.foo = foo;
  }
 
  public Foo Foo { get { return this.foo; } }
}
 
class Foo
{
  // Use the generic EventHandler delegate rather than declaring your own
  public static event EventHandler<FooCreatedEventArgs> Created;
 
  // Event-raising method marked private, can't be called from other classes
  private static void OnCreated(Foo foo)
  {
    // Thread-safe pattern for raising events
    var handler = Created;
    if (handler != null)
      handler(null, new FooCreatedEventArgs(foo));
  }
 
  // Private constructor, prevents creating instances with new operator
  // except from within this class
  private Foo()
  {
    // All constructor code
    // ...
  }
 
  // Factory method creates instances and fires event
  public static Foo Create()
  {
    var foo = new Foo();
 
    OnCreated(foo);
 
    return foo;
  }
}
 
class Program
{
  static void Main(string[] args)
  {
    Foo.Created += HandleFooCreated;
    var foo1 = Foo.Create();
  }
 
  static void HandleFooCreated(object sender, FooCreatedEventArgs e)
  {
    Console.WriteLine("A new Foo! Halloo!");
  }
}