CODEWITHSUNDEEP
c#events
Carra
Carra

Reputation: 17964

Short way to write an event?

Typically we use this code:

    private EventHandler _updateErrorIcons;
    public event EventHandler UpdateErrorIcons
    {
        add { _updateErrorIcons += value; }
        remove { _updateErrorIcons -= value; }
    }

Is there a similar shortcut like with automatic properties? Something like:

   public event EventHandler UpdateErrorIcons { add; remove; }

Upvotes: 11

Views: 2144

Answers (3)

Dan Tao
Dan Tao

Reputation: 128307

Yep. Get rid of the { add; remove; } part and the backing delegate field and you're golden:

public event EventHandler UpdateErrorIcons;

That's it!

Let me just add that before you asked this question, I hadn't even thought about the fact that the auto-implemented version of events is inconsistent with that of properties. Personally, I would actually prefer it if auto-implemented events worked the way you first attempted in your question. It would be more consistent, and it would also serve as a mental reminder that events are not identical to delegate fields, just like properties are not identical to regular fields.

Honestly, I think you're the rare exception where you actually knew about the custom syntax first. A lot of .NET developers have no clue there's an option to implement your own add and remove methods at all.

Update: Just for your own peace of mind, I have confirmed using Reflector that the default implementation of events in C# 4 (i.e., the implementation that gets generated when you go the auto-implemented route) is equivalent to this:

private EventHandler _updateErrorIcons;
public event EventHandler UpdateErrorIcons
{
    add
    {
        EventHandler current, original;
        do
        {
            original = _updateErrorIcons;
            EventHandler updated = (EventHandler)Delegate.Combine(original, value);
            current = Interlocked.CompareExchange(ref _updateErrorIcons, updated, original);
        }
        while (current != original);
    }
    remove
    {
        // Same deal, only with Delegate.Remove instead of Delegate.Combine.
    }
}

Note that the above utilizes lock-free synchronization to effectively serialize add and remove calls. So if you're using the latest C# compiler, you don't need to implement add/remove yourself even for synchronization.

Upvotes: 15

Tedd Hansen
Tedd Hansen

Reputation: 12314

add {} and remove {} are used only in special cases where you need to handle event hookups manually. Us mere mortals normally just use public event EventHandler UpdateErrorIcons; where "EventHandler" is the delegate of choice.

For instance:

public delegate void MyEventDelegate(object sender, string param1);
public event MyEventDelegate MyEvent;

Note that because MyEvent is null if it doesn't have any listeners you need to check if it is null before invoking it. A standard method for doing this check is:

public void InvokeMyEvent(string param1)
{
    MyEventDelegate myEventDelegate = MyEvent;
    if (myEventDelegate != null)
        myEventDelegate(this, param1);
}

A key element in this check is to make a copy of the object in question first and then work only on the copy. If not you could get a rare race condition where another thread unhooks between your if and your call.

Upvotes: 2

Stecya
Stecya

Reputation: 23266

public event EventHandler UpdateErrorIcons;

is just fine

you can use

yourObbject.UpdateErrorIcons += YourFunction;

Upvotes: 5

Related Questions