Question

public event EventHandler ConstructDesign;
public DataGridView dataGrid = new DataGridView();
public FooClass(Action action) {
    ConstructDesign+=action;
    dataGrid.DataBindingComplete+=ConstructDesign;
}

public void Launch() {
    ConstructDesign(null, new EventArgs());
}

//IN A COMPLETELY DIFFERENT CLASS:
public void Main(string[] args) {
    var launcher = new FooClass(Fire);
    launcher.Launch();
}

public void Fire(object sender, EventHandlerArgs args...) {
    Console.WriteLine("Fired");
    //and after the first fire, action will be removed from the `ConstructDesign`.
}

So basically what I’m trying to achieve here is how to do the following:
An Action that is added manually through code to ConstructDesign and upon firing, it will removes itself from the event handler, ConstructDesign. any ideas?

Answer 1

I haven’t found a nice way to unsubscribe from the event after the first use. (You could certainly use a reflection-heavy approach, but I doubt the compiler would complain if a refactoring changed the name of an event).

Here is one that uses only delegates, so the compiler would still serve you well. It may not be as light-weight as you need, but since I took up the challenge for my own edification, I thought I’d share it.

MyEvent += SingleUseEventHandler<AssemblyLoadEventArgs, AssemblyLoadEventHandler>
   .Create(This_MyEventOccurred);

Where the magic is defined here:

public class SingleUseEventHandler<TArgs,THandler>
  where TArgs : EventArgs
{
  public static THandler Create(EventHandler<TArgs> handler)
  {
     var helper = new SingleUseEventHandler<TArgs, THandler>(handler);
     EventHandler<TArgs> h = helper.InvokeIfFirstTime;
     return (THandler)(object)Delegate.CreateDelegate(typeof(THandler), h.Target, h.Method);
  }

  public void InvokeIfFirstTime(object sender, TArgs args)
  {
     if (!raised)
     {
        raised = true;
        handler(sender, args);
     }
  }

  public SingleUseEventHandler(EventHandler<TArgs> handler)
  {
     this.handler = handler;
  }

  bool raised;
  readonly EventHandler<TArgs> handler;
}

Of course, C# won’t infer the delegate type, so you have to specify it explicitly.

If the event’s definition is EventHandler, you can use this instead:

MyEvent += SingleUseEventHandler<SomeEventArgs>.Create(SomeHandlerMethod);


public static class SingleUseEventHandler<TArgs>
  where TArgs : EventArgs
{
  public static EventHandler<TArgs> Create(EventHandler<TArgs> handler)
  {
     var helper = new SingleUseEventHandler<TArgs, EventHandler<TArgs>>(handler);
     return helper.InvokeIfFirstTime;
  }
}

Here’s an example program:

class Program
{
  static event AssemblyLoadEventHandler MyEvent;
  static int callCount;
  static void Main(string[] args)
  {
     MyEvent += SingleUseEventHandler<AssemblyLoadEventArgs, AssemblyLoadEventHandler>
        .Create(Load);

     foreach(var assembly in AppDomain.CurrentDomain.GetAssemblies())
     {
        Console.WriteLine("Raising event for " + assembly.GetName().Name);
        MyEvent(null, new AssemblyLoadEventArgs(assembly));
     }
  }

  static void Load(object sender, AssemblyLoadEventArgs eventArgs)
  {
     Console.WriteLine(++callCount);
  }
}