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?

[jjonescz]

Created a proposal for this: https://github.com/dotnet/csharplang/blob/main/proposals/partial-events-and-constructors.md
Champion issue: #9058

[h3xds1nz]

Is there any chance this proposal would include partial enums as well?

My use-case is kinda simple, often times I require to have helper/special members declared (e.g. AllFlags, Max) to ease up working with the enumerations. Nowadays we can get a lot of stuff done via source generator to make enums rather pleasant via extension methods,
but so far there's no way to generate these helper members without declaring them explicitly.

It would be really cool if we could just source-generate these as well directly on the enumeration to make it feel more natural.

[RikkiGibson]

Likely no, because the scope creep of handling them at all, may be too much, in addition to designing the handling of automatic enum member values across parts.

Perhaps the ergonomics here can be improved in future by adding a const field of the enum type as an extension. #8696

[jjonescz]

Sounds like the enum members you would want to generate is limited to a few (as you say, AllFlags, Max), so perhaps an analyzer which tells you to add them and keep them up to date would be good enough.

[h3xds1nz]

@RikkiGibson Yeah I understand; regarding the extensions, is this planned for the initial release of extensions or future is "maybe later"? I haven't been following on the progress enough but looking at the current spec briefly I didn't see anything.

@jjonescz Yeah analyzer paired with an attribute does the job (as some enums shouldn't have those, etc.) but it is still not "perfect" due to the "manual" action required, regardless whether I'd write a fixer. Needless to say, there's a workaround indeed.

[RikkiGibson]

#8696 (comment)