Dose event cannot be invoked in the default interface method.

[TruePluto]

I want to test the new feature of C#8. but i found the default interface method cantnot invoke the event

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Runtime.CompilerServices;
using System.Text;

namespace ClassLibrary1
{
	//Default Interface Implementations 
	public interface IDimTest
	{
		public event PropertyChangedEventHandler PropertyChanged;

		public virtual void RaisePropertyChanged([CallerMemberName]string propertyName = "")
		{
                      //error cs0079
			PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
                      //error cs0079
		}

		public virtual void AddPropertyChanged()
		{
			PropertyChanged += IDimTest_PropertyChanged;
		}

		void IDimTest_PropertyChanged(object sender, PropertyChangedEventArgs e)
		{
			throw new NotImplementedException();
		}
	}
}

[YairHalberstadt]

Similar to a property, an event exposes syntax to add and remove callbacks to something easily, but that something could be anything at all.

In a class, an auto event (similar to an auto property) generates a simple implementation using a backing field. So if you changed your interface to a class, you would generate this:

        [CompilerGenerated]
        private PropertyChangedEventHandler m_PropertyChanged;

        public event PropertyChangedEventHandler PropertyChanged
        {
            [CompilerGenerated]
            add
            {
                PropertyChangedEventHandler propertyChangedEventHandler = this.m_PropertyChanged;
                PropertyChangedEventHandler propertyChangedEventHandler2;
                do
                {
                    propertyChangedEventHandler2 = propertyChangedEventHandler;
                    PropertyChangedEventHandler value2 = (PropertyChangedEventHandler)Delegate.Combine(propertyChangedEventHandler2, value);
                    propertyChangedEventHandler = Interlocked.CompareExchange(ref this.m_PropertyChanged, value2, propertyChangedEventHandler2);
                }
                while ((object)propertyChangedEventHandler != propertyChangedEventHandler2);
            }
            [CompilerGenerated]
            remove
            {
                PropertyChangedEventHandler propertyChangedEventHandler = this.m_PropertyChanged;
                PropertyChangedEventHandler propertyChangedEventHandler2;
                do
                {
                    propertyChangedEventHandler2 = propertyChangedEventHandler;
                    PropertyChangedEventHandler value2 = (PropertyChangedEventHandler)Delegate.Remove(propertyChangedEventHandler2, value);
                    propertyChangedEventHandler = Interlocked.CompareExchange(ref this.m_PropertyChanged, value2, propertyChangedEventHandler2);
                }
                while ((object)propertyChangedEventHandler != propertyChangedEventHandler2);
            }
        }

When you then call PropertyChanged?.Invoke you actually call this on the backing field. It compiles down to m_PropertyChanged?.Invoke.

In an interface however you can't create a field. public event PropertyChangedEventHandler PropertyChanged; is now an abstract member of your interface rather than an auto-implemented event. As such you can't call the backing field - there is none.

Instead you can make a protected property, and manually write the event logic yourself. However that won't allow you to make it thread safe simply, since you cant use Interlocked.CompareExchange on a property. You can however write a simple non thread safe implementation:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading;

namespace ClassLibrary1
{
    public interface IDimTest
    {
        [CompilerGenerated]
        protected PropertyChangedEventHandler m_PropertyChanged { get; set; }

        public event PropertyChangedEventHandler PropertyChanged
        {
            [CompilerGenerated]
            add
            {
                m_PropertyChanged += value;
            }
            [CompilerGenerated]
            remove
            {
                m_PropertyChanged -= value;
            }
        }

        public virtual void RaisePropertyChanged([CallerMemberName] string propertyName = "")
        {
            m_PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }

        public virtual void AddPropertyChanged()
        {
            PropertyChanged += new PropertyChangedEventHandler(IDimTest_PropertyChanged);
        }

        private void IDimTest_PropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            throw new NotImplementedException();
        }
    }
}

Be warned, that if two events are added at once, one of them may be lost.

[Tim-Utelogy]

Is doing a lock within the add/remove sufficient to make this thread safe as @TruePluto suggests?
lock (this) m_PropertyChanged -= value;

[gafter]

This is by design. Your event is abstract. As such it has no backing field or implementation. There is no value for you to invoke.

[TruePluto]

Thank you YairHalberstadt and gafter for your initerpretations.
I just don't understand why an event in an interface can be +=ed and -=ed but cant be invoked. each class with the interface should define the event. what is the difference between +=/-= and invoke.
thanks again.

[YairHalberstadt]

@TruePluto
An abstract event guarantees that any implementers implement += and -=. It does not guarantee they create a backing field to store the event. For example a perfectly valid implementation of an event in C#, is to simply do nothing at all:

public event EventHandler MyEvent { add {} remove {} }

What would you invoke if this was your implementation?

[HaloFour]

When you invoke an event within a class you're actually referencing the field that contains the delegate for the event directly. That field does not (and can not) exist in an interface because interfaces can't contain state. At most an interface can express methods, which the adder and remover accessors are. But the implementing class has to supply its own event field.

The only way to achieve what you're looking to do would be to add a method to the interface for raising the event and expect the implementer to provide the state for the event:

public interface I {
    event EventHandler MyEvent;
    
    protected void OnEvent();
    
    void DoSomething() {
        this.OnEvent();
    }
}

public class C : I {
    public event EventHandler MyEvent;

    void I.OnEvent() => MyEvent?.Invoke(this, EventArgs.Empty);
}

[Thaina]

Seem very weird that property is also cannot have backed field in interface but we can do things with property

Is this possible ?

public interface I {
    EventHandler MyEvent { get; }
    void DoSomething() {
        MyEvent.Invoke();
    }
}

[HaloFour]

@Thaina

Yes, that code works. The interface can't contain the state for properties either and the implementer must supply that state. But since your property has a get which is a method the interface can reference that getter to access whatever the implementer happens to return. Events don't have getters, there's no way for a consumer to get to the underlying delegate.

This is more akin to the event problem:

public interface I {
    EventHandler MyEvent { set; }
    void DoSomething() {
        MyEvent?.Invoke(this, EventArgs.Empty); // error CS0154
    }
}

[TruePluto]

Thanks all of you.
I want to know whether the flowlling code is a good idea. I add lock(this) in the add and remove.

public interface IDimTest
	{
		[CompilerGenerated]
		protected PropertyChangedEventHandler m_PropertyChanged { get; set; }

		public event PropertyChangedEventHandler PropertyChanged
		{
			[CompilerGenerated]
			add
			{
				**lock (this) //here**
					m_PropertyChanged += value;
			}
			[CompilerGenerated]
			remove
			{
				**lock (this) //here**
					m_PropertyChanged -= value;
			}
		}

		public virtual void RaisePropertyChanged([CallerMemberName] string propertyName = "")
		{
			m_PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
		}

		public virtual void AddPropertyChanged()
		{
			PropertyChanged += new PropertyChangedEventHandler(IDimTest_PropertyChanged);
		}

		private void IDimTest_PropertyChanged(object sender, PropertyChangedEventArgs e)
		{
			throw new NotImplementedException();
		}
	}