theburningmonk.com

If you’ve used events in C# before, you’ve prob­a­bly writ­ten code like this too:

public event EventHandler Started;
...
// make sure Started is not null before firing the event
// else, NullReferenceException will be thrown
if (Started != null)
{
    Started(this, some_event_args);
}

This is per­fectly ok and nor­mal to do, but can quickly become tire­some if you have to fire events in mul­ti­ple places in your code and have to do a null ref­er­ence check every time!

So instead, I have been using this pat­tern for a while:

// initialise with empty event hanlder so there's no need for Null reference check later
public event EventHandler Started = (s, e) => { };
...
// no need for Null reference check anymore as Started is never null
Started(this, some_event_args);

If all you need is the abil­ity to add/remove han­dlers, then this pat­tern would do you fine as the event will never be null because there’s no way for you to remove the anony­mous method the event was ini­tialised with unless you set the event to null.

How­ever, if you occa­sion­ally need to clear ALL the event han­dlers and set the event to null, then don’t use this pat­tern as you might start see­ing Null­Ref­er­ence­Ex­cep­tion being thrown before you add event han­dlers back in.

The Dis­pose pat­tern is some­thing we’ve all seen before, and it’s so tried and tested most of us (espe­cially myself!) have been more than happy to apply with­out question.

Whilst read­ing var­i­ous blogs/articles I came across some dif­fer­ing opin­ion about this well known pat­tern and started to ques­tion what I had taken for granted myself.

After some more research and a ques­tion on the gold­mine of knowl­edge that is the Stack­Over­flow I have short­listed a few points you should con­sider when imple­ment­ing the stan­dard C# dis­pose pattern:

1. if your object doesn’t hold any IDis­pos­able objects or unman­aged resources (DB con­nec­tion, for exam­ple) then you don’t need to imple­ment the IDis­pos­able or final­izer at all
2. if your object doesn’t hold any unman­aged resources then don’t imple­ment a final­izer, the Garbage Col­lec­tor won’t attempt to final­ize your object (which has a per­for­mance hit) unless you have imple­mented a finalizer.
3. don’t for­get to call Dis­pose() on each of the IDis­pos­able objects in the Dispose(bool) method.
4. if your object holds unman­aged resources, clean them up in the final­izer with­out re-writing any of the cleanup code in the Dispose(bool) method already.

So for a sim­ple class with no unman­aged resources and a col­lec­tion of IDis­pos­able objects, your class might look some­thing like this:

public sealed class MyClass : IDisposable
{
     IList<MyObject> objects;  // MyClass holds a list of objects
     private bool _disposed;   // boolean flag to stop us calling Dispose(twice)

     public void Dispose()
     {
          Dispose(true);
          GC.SuppressFinalize(this);
     }

     private void Dispose(bool disposing)
     {
          if (!_disposed)
          {
               // call Dispose on each item in the list
               if (disposing)
               {
                    foreach (var o in objects)
                    {
                         // check if MyObject implements IDisposable
                         var d = o as IDisposable();
                         if (d != null) d.Dispose();
                    }
               }
          _disposed = true;
          }
     }
}

This is fairly sim­i­lar to the stan­dard C# Dis­pose pat­tern, the main dif­fer­ence being the lack of a final­izer because remem­ber, imple­ment­ing a final­izer will impact the per­for­mance of your type so don’t imple­ment it unless you need it.