How to force an event to occur from an extension method?

Question

I am creating a C# application and I am using the interface INotifyPropertyChanged thus:

public class Test: INotifyPropertyChanged
{
    private int foo;
    public int Foo { get => foo; set => Set(ref foo, value); }

    public void Set<T>(ref T property, T value, [CallerMemberName]string p = "")
    {
        property = value;
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(p));
    }

}

My problem is that whenever I want to implement this way of working (with the method Set(ref property, value) i am obliged to come here and copy the code and reimplementit. From this problem, I thought of an extension method like this:

using System.Runtime.CompilerServices;

public static class Extensions 
{
    public static void Set<T>(
        this INotifyPropertyChanged source, ref T property, T value,
        [CallerMemberName]string propertyName = "")
    {
        property = value;
        source.PropertyChanged?
            .Invoke(source, new PropertyChangedEventArgs(propertyName));
    }
}

My problem is that if I try to do this implementation, I get this message:

The Event INotifyPropertyChanged.PropertyChanged can only appear on the left hand side of += or -=

What I need to do to get me to force the call from that event through an extension property?

Answer 1

I don’t have the slightest idea of what you want to do, because it doesn’t have the full implementation, it seems something very wrong, but to strictly solve your problem you have to pass the event handler as parameter to the desired method and call explicitly. I actually saw no advantage in having it as an extension method.

I had to put some other things to satisfy the interface:

using System.ComponentModel;
using System.Runtime.CompilerServices;

public class Program {
    public static void Main() {
        var x = new Test();
        x.Foo = 10;
    }
}
public class Test: INotifyPropertyChanged {
    private int foo;
    public int Foo { get => foo; set => this.Set(ref foo, value, PropertyChanged); }
    public event PropertyChangedEventHandler PropertyChanged;
    protected void OnPropertyChanged(string name) {
        PropertyChangedEventHandler handler = PropertyChanged;
        if (handler != null) handler(this, new PropertyChangedEventArgs(name));
    }
}

public static class Extensions {
    public static void Set<T>(
        this INotifyPropertyChanged source, ref T property, T value, PropertyChangedEventHandler handler, [CallerMemberName]string propertyName = "") {
        property = value;
        handler?.Invoke(source, new PropertyChangedEventArgs(propertyName));
    }
}

Behold working in the ideone. And in the .NET Fiddle. Also put on the Github for future reference.