Assumptions

Basically, a Connection class has a "Disconnect" event. Subscribing to this event isn't thread-safe, because the disconnection may fire from another thread right before I subscribe. So checking before the subscription doesn't help.

Checking for the disconnect after subscription doesn't help either because the event may have fired in the meanwhile (2 threads might execute the same "observer" twice).

(My) Solution:

An event always fired once (and only once), even if the event itself already happened before Source is on GitHub as well.

Questions:

Are there other simpler solutions addressing this? (by simpler I mean from an outside or usage perspective)

Do you see any race conditions or things that could go wrong?

Maybe you have optimizations or simplifications to add?

Input is highly appreciated!

/// <summary>

/// Triggers if the event is invoked or was invoked before subscribing to it.

/// <para> Can be accessed safely by multiple threads.</para>

/// </summary>

public class AutoInvokeEvent<Sender, Args>

{

    public delegate void EventHandle(Sender sender, Args arguments);



    /// <summary>

    /// Handle will be invoked if the event was triggered in the past.

    /// <para>Unsubscribing happens automatically after the invocation and is redundant if done from the event handle.</para>

    /// </summary>

    public event EventHandle Event

    {

        add

        {

            if (!Subscribe(value))

                value(m_sender, m_eventArgs);

        }

        remove { InternalEvent -= value; }

    }



    private event EventHandle InternalEvent;



    // this is my personal lock implementation. in this case it is used like any other lock(object) so just ignore it

    private SafeExecutor m_lock = new SingleThreadExecutor();

    private volatile bool m_invoked = false;



    Sender m_sender;

    Args m_eventArgs;



    /// <summary>

    /// Invokes all subscribed handles with the given parameters. 

    /// <para>All calls after the first are ignored.</para>

    /// </summary>

    public void Invoke(Sender sender, Args args)

    {

        GetEventHandle(sender, args)?.Invoke(m_sender, m_eventArgs);

    }



    private EventHandle GetEventHandle(Sender sender, Args args)

    {

        return m_lock.Execute(() =>

        {

            if (m_invoked)

                return null;



            m_sender = sender;

            m_eventArgs = args;

            m_invoked = true;

            EventHandle handle = InternalEvent;

            InternalEvent = null;

            return handle;

        });

    }



    /// <returns>Returns true if subscription was successful and false if handle needs to be invoked immediately.</returns>

    private bool Subscribe(EventHandle handle)

    {

        return m_lock.Execute(() =>

        {

            if (!m_invoked)

                InternalEvent += handle;



            return !m_invoked;

        });

    }

}

How the class could be used :

class Connection

{

    public AutoInvokeEvent<object, EndPoint> OnDisconnect = new AutoInvokeEvent<object, EndPoint>();



    public Disconnect()

    {

        OnDisconnect.Invoke(this, endpoint);

    }

}



void main()

{

    Connection connection = new Connection();

    connection.OnDisconnect.Event += DoStuffOnDisconnect;

}



void DoStuffOnDisconnect(object sender, EndPoint endpoint) { }