Partial events

[thomaslevesque]

At the moment, events cannot be declared partial in C#. I realize needing to do this isn't very common, but now that we have rich code generation features, it could be useful to allow it.

My specific use case is to make a generator for weak events (i.e. events that only keep weak references to the handlers). I have a library that provides a generic weak event implementation. At the moment the library has certain restrictions (not relevant to this discussion, but you can look at the issue if you're interested), which could probably be solved by using a source generator. Ideally I'd like the user to declare an event like this:

public delegate void MyEventHandler(int foo, string bar);

public partial class MyClass
{
    [WeakEvent]
    public partial event MyEventHandler MyEvent;
}

And the library would generate the event implementation, and a method to raise the event. In my use case it would probably similar to this:

partial class MyClass
{
    private readonly __WeakMyEventHandler _myEvent; // __WeakMyEventHandler would also be generated

    public partial event MyEventHandler MyEvent
    {
        add { _myEvent.AddHandler(value); }
        remove { _myEvent.RemoveHandler(value); }
    }

    protected void RaiseMyEvent(int foo, string bar) => _myEvent.Invoke(foo, bar);
}

But since events can't be partial, it's not currently possible to use this approach.

This idea is actually pretty similar to the Partial properties proposal, which wants to allow partial properties to allow code generation scenarios.

Like for properties, it would be required to have an implementing declaration of the event (whether it's provided manually or by a generator).

[HaloFour]

One thing that I think would need consideration is how the declaring class would be expected to raise the event.

[thomaslevesque]

It would be implementation-dependent. In my case:

And the library would generate the event implementation, and a method to raise the event.

[HaloFour]

Got it, didn't see that blurb in there. 😄

Makes sense, so the source generator would be responsible for emitting something like protected void OnMyEvent(...) which would then be used to raise the event. The exact signature could depend on the source generator or policies.

[thomaslevesque]

Exactly

[RikkiGibson]

Could you please include a full sample of the implementation part you would like to generate for the partial event, and how the event would be used in user code? Thanks!

[HaloFour]

There are numerous weak event handler implementations out there. Presumably a source generator would either use one of those or emit its own, and then wire up the explicit event to use said implementation:

public partial class Foo {
    [Weak] public partial event EventHandler<EventArgs> MyEvent;

    public void Bar() {
        // do stuff, then raise the weak event
        OnMyEvent(EventArgs.Empty);
    }
}

// generated
public partial class Foo {
    private readonly WeakEvent<EventHandler<EventArgs>> _myEventImpl;

    public partial event EventHandler<EventArgs> MyEvent {
        add { _myEventImpl.Add(value); }
        remove { _myEventImpl.Remove(value); }
    }

    protected void OnMyEvent(EventArgs args) {
        _myEventImpl.Raise(this, args);
    }
}

[thomaslevesque]

Done

[hez2010]

@RikkiGibson
It's quite important because with weak event handlers, we are able to reduce the possibility of memory leaking in GUI apps.
You can check how such things are becoming a main reason of memory leaking in MAUI: https://github.com/dotnet/maui/pulls?q=is%3Apr+memory+leak+event+handler+is%3Aclosed
With partial events, we can then source generate weak event handlers so that no boilerplate code would be necessary.
I suggest including partial events as well while implementing partial properties.

[hez2010]

[KennethHoff]

partial all the things!

[thomaslevesque]

By indexers, you mean indexed properties, right? Isn't it covered in the partial properties proposal?