Question

I looked at this example from the C# in nutshell book
(http://www.albahari.com/nutshell/ch04.aspx)

using System;

public class PriceChangedEventArgs : EventArgs
{
  public readonly decimal LastPrice;
  public readonly decimal NewPrice;

  public PriceChangedEventArgs (decimal lastPrice, decimal newPrice)
  {
    LastPrice = lastPrice; NewPrice = newPrice;
  }
}

public class Stock
{
  string symbol;
  decimal price;

  public Stock (string symbol) {this.symbol = symbol;}

  public event EventHandler<PriceChangedEventArgs> PriceChanged;

  ****protected virtual void OnPriceChanged (PriceChangedEventArgs e)
  {
    if (PriceChanged != null) PriceChanged (this, e);
  }****

  public decimal Price
  {
    get { return price; }
    set
    {
      if (price == value) return;
      OnPriceChanged (new PriceChangedEventArgs (price, value));
      price = value;
    }  
  }
}

class Test
{
  static void Main()
  {
    Stock stock = new Stock ("THPW");
    stock.Price = 27.10M;
    // register with the PriceChanged event    
    stock.PriceChanged += stock_PriceChanged;
    stock.Price = 31.59M;
  }

  static void stock_PriceChanged (object sender, PriceChangedEventArgs e)
  {
    if ((e.NewPrice - e.LastPrice) / e.LastPrice > 0.1M)
      Console.WriteLine ("Alert, 10% stock price increase!");
  }
}

What I don’t understand, is why this convention is used…

  ****protected virtual void OnPriceChanged (PriceChangedEventArgs e)
  {
    if (PriceChanged != null) PriceChanged (this, e);
  }****

Why do I need that method and why do I care to give it the “this” parameter?!? Cant I just attach the event from that class with the method PriceChanged in the test class straight away and skip that method?!?

Answer 1

Null checks are used since a (event) delegate list is not empty but null if there are no subscribers.

However, it’s not thread safe. So it can blow up in your face if you start using a BackgroundWorker or any other multi-threaded technique.

I suggest that you use an empty delegate instead:

public event EventHandler<PriceChangedEventArgs> PriceChanged = delegate {};

Since it allows you to just write:

protected virtual void OnPriceChanged (PriceChangedEventArgs e)
{
   PriceChanged (this, e);
}

It’s thread safe and the code is more easy to read.

why do I care to give it the “this” parameter?!?

Same event handler might be used by multiple event generators. The sender tells which generate the invocation is for. You should always send the correct event generator as it is expected and you’ll break open/closed principle if you don’t

Why Do I need that method?

You don’t, unless you would duplicate code otherwise (such as generating the EventArgs class)