Generic EventArgs to go with generic EventHandler?
You could make it a little bit more useful if you added some supporting factory methods to create the arguments.  That way you don't have to use the constructor and its somewhat awkward syntax (having to supply the types).

public static class EventHandlerExtensions
{
    public static EventArgs&lt;T&gt; CreateArgs&lt;T&gt;(
        this EventHandler&lt;EventArgs&lt;T&gt;&gt; _,
        T argument)
    {
        return new EventArgs&lt;T&gt;(argument);
    }

    public static ReadOnlyEventArgs&lt;T&gt; CreateArgs&lt;T&gt;(
        this EventHandler&lt;ReadOnlyEventArgs&lt;T&gt;&gt; _,
        T argument)
    {
        return new ReadOnlyEventArgs&lt;T&gt;(argument);
    }
}


Then to create the instance of the arguments, you could just do this:

public event EventHandler&lt;EventArgs&lt;SomeArg&gt;&gt; SomeEvent;
public event EventHandler&lt;ReadOnlyEventArgs&lt;SomeArg&gt;&gt; SomeOtherEvent;

protected virtual void OnSomeEvent(SomeArg argument)
{
    var someEvent = SomeEvent;
    if (someEvent != null)
    {
        var args = someEvent.CreateArgs(argument);
        // instead of:
        //var args = new EventArgs&lt;SomeArg&gt;(argument);
        someEvent(this, args);
    }
}

protected virtual void OnSomeOtherEvent(SomeArg argument)
{
    var someOtherEvent = SomeOtherEvent;
    if (someOtherEvent != null)
    {
        var args = someOtherEvent.CreateArgs(argument);
        // instead of:
        //var args = new ReadOnlyEventArgs&lt;SomeArg&gt;(argument);
        someOtherEvent(this, args);
    }
}


It might be useful to have options for multiple parameters (similar to how the tuple is).  Though it might not be feasible to have all combinations of multiple (im)mutable arguments.