A: 

If you haven't hooked any event subscribers up to your StartedWorking event, then it will be null. That is how .NET events works.

This article, among other things, demonstrates that you should check for null before invoking an event. This other question and answer demonstrates how you can create events in a way that avoids the null check (basically by adding an empty handler always).

driis
The first article (from .NET 1.1) shows how to do it, but it's inappropriate in multithreaded situations. I recommend my approach instead. The second article works, but can be brittle (it's possible to remove that handler, which will cause the exception again), plus it adds overhead every time you raise the event (a delegate invocation).
Reed Copsey
+7  A: 

The event handler will be null unless somebody has subscribed to the event. As soon as a delegate is subscribed to the event, it will no longer be null.

This is why it's always suggested to use the following form for raising events:

public void Start()
{
    var handler = this.StartedWorking;
    if (handler != null)
    {
         handler(this, eventArgObject);
    }
}

This protects you from a null exception if there has been no subscribers.

Reed Copsey
Assigning a variable also prevent you from dealing with a race condition, in the case that the event is unsubscribed between the null check and the call itself.
Pierre-Alain Vigeant
A: 

Don't you need to assign a function ?

StartedWorking += new EventHandler(afunction);

void afunction(object sender, EventArgs e)
{
   DoSomething();
}
Julian de Wit
+1  A: 

As others have already said, it's null because there are no subscribers.

To answer your edit: Yes, you should always check an event for null before triggering it. However, if you just do a plain if(StartedWorking != null){...} you risk a race condition, because it's possible for a subscriber to unsubscribe after the null check but before you trigger the event. Because of this, you should always use this pattern when checking events for null:

protected void OnStartedWorking()
{
    EventHandler localEvent = StartedWorking
    if(localEvent != null)
    {
        localEvent(this, EventArgs.Empty);
    }
}

This prevents the race condition by taking a copy of the event first so the subscribe list is fixed at the point of copying.

There's more infomration about publishing events on MSDN: How to Publish Events that Conform to .NET Framework Guidelines

(This works because in .net the MultiCastDelegate class in imutable, so any attempt to change the subscriber list on the event won't effect the copy you have made)

Simon P Stevens