Essential C# 4.0: Intermediate

// Lazy Initialization
using System.IO;

class DataCache
{
  // ...

  public DataCache(string FileStreamName)
  {
    _FileStream = new Lazy<TemporaryFileStream>(
      () => new TemporaryFileStream(FileStreamName));
  // the lambda expression provides a means of passing the
  // instructions for what will happen, but not actually performing those
  // instructions until explicitly requested.
  }

  public TemporaryFileStream FileStream
  {
    get
  {
    return _FileStream.Value;
  }
  }
  private Lazy<TemporaryFileStream> _FileStream;

  // ...
}

// Needing the type parameter to support an interface or exception thrown
public class BinaryTree<T>
{
  // ...
  public Pair<BinaryTree<T>> SubItems
  {
      get { return _SubItems; }
      set {
          IComparable<T> first;
          first = (IComparable<T>)value.First.Item;
              
          if (first.CompareTo(value.Second.Item) < 0)
          {
              // first is less than second.
          }
          else
          {
              // second is less than first.
          }
          _SubItems = value;
      }
  }
  private Pair<BinaryTree<T>> _SubItems;
}

// Declaring the interface constrant
public class BinaryTree<T>
  where T: System.IComparable<T>
{
  // ...
  public Pair<BinaryTree<T>> SubItems
  {
      get{ return _SubItems; }
      set
      {
          IComparable<T> first;
          // Notice that the cast can now be eliminated.
          first = value.First.Item;
          
          if (first.CompareTo(value.Second.Item) < 0)
          {
              // first is less than second
          }
          else
          {
              // second is less than or equal to first
          }
          _SubItems = value;
      }
  }
  private Pair<BinaryTree<T>> _SubItems;
}

// multiple constraints
// an AND relationship is assumed
public class EntityDictionary<TKey, TValue>
  : Dictionary<TKey, TValue>
  where TKey : IComparable<TKey>, IFormattable
  where TValue : EntityBase
{
  // ...
}

// constructor constraints ensure default ctors only
// Ctors with parameters are NOT supported
public class EntityDictionary<TKey, TValue> :
  Dictionary<TKey, TValue>
  where TKey: IComparable<TKey>, IFormattable
  where TValue : EntityBase<TKey>, new()
{
  //...
  TValue newEntity = new TValue();
  //...
}

using System;
class DelegateSample {
    public static void BubbleSort(int[] items, ComparisonHandler comparisonMethod) {
        int i;
        int j;
        int temp;

        if (items == null) return;
        if (comparisonMethod == null) throw new ArgumentNullException("comparisonMethod");

        for (i = items.Length - 1; i >= 0; i--) {
            for (j = 1; j <= i; j++) {
                if (comparisonMethod(items[j - 1], items[j])) {
                    temp = items[j - 1];
                    items[j - 1] = items[j];
                    items[j] = temp;
                }
            }
        }
    }

    public delegate bool ComparisonHandler(int first, int second);

    public static bool GreaterThan(int first, int second) {
        return first > second;
    }
  
  public static bool AlphabeticalGreaterThan(int first, int second) {
      int comparison;
      comparison = (first.ToString().CompareTo(second.ToString()));
      
      return comparison > 0;
  }

    static void Main() {
        int[] items = new int[100];
        Random random = new Random();
        for (int i = 0; i < items.Length; i++) {
            items[i] = random.Next(0, 100);
        }

        BubbleSort(items, GreaterThan);
      // In C# 2.0, we can also use BubbleSort(items, new ComparisonHandler(GreaterThan))

        for (int i = 0; i < items.Length; i++) {
            Console.WriteLine(items[i]);
        }

        Console.ReadLine();
    }
}

// delegate's implementation of subscriber-publisher
using System;

// Heater and Cooler Event Subscriber Implementations
class Cooler {
    public Cooler(float temperature) {
        Temperature = temperature;
    }

    public float Temperature {
        get { return _Temperature; }
        set { _Temperature = value; }
    }

    private float _Temperature;

    public void OnTemperatureChanged(float newTemperature) {
        if (newTemperature > Temperature) {
            System.Console.WriteLine("Cooler: On");
        }
        else {
            System.Console.WriteLine("Cooler: Off");
        }
    }
}

class Heater {
    public Heater(float temperature) {
        Temperature = temperature;
    }

    public float Temperature {
        get { return _Temperature; }
        set { _Temperature = value; }
    }
    private float _Temperature;

    public void OnTemperatureChanged(float newTemperature) {
        if (newTemperature < Temperature) {
            System.Console.WriteLine("Heater: On");
        }
        else {
            System.Console.WriteLine("Heater: Off");
        }
    }
}

// Defining the Event Publisher, `Thermostat`
public class Thermostat {
    // Define the delegate data type
    public delegate void TemperatureChangeHandler(float newTemperature);

    // Define the event Publisher
    public TemperatureChangeHandler OnTemperatureChange {
        get { return _OnTemperatureChange; }
        set { _OnTemperatureChange = value; }
    }
    private TemperatureChangeHandler _OnTemperatureChange;

    public float CurrentTemperature {
        get { return _CurrentTemperature; }
        set {
            if (value != CurrentTemperature) {
                _CurrentTemperature = value;

                TemperatureChangeHandler localOnChange = OnTemperatureChange;

                if (localOnChange != null) {
                    // call subscribers
                    OnTemperatureChange(value); // multicast delegates
                }
            }
        }
    }
    public float CurrentTemperatureHandlingError {
        get { return _CurrentTemperature; }
        set {
            if (value != CurrentTemperature) {
                _CurrentTemperature = value;

                if (OnTemperatureChange != null) {
                    foreach (TemperatureChangeHandler handler in OnTemperatureChange.GetInvocationList()) {
                        try {
                            handler(value);
                        }
                        catch (Exception e) {
                            Console.WriteLine(e.Message);
                        }
                    }
                }
            }
        }
    }
    private float _CurrentTemperature;
}

class Program {
    public static void Main() {
        Thermostat thermostat = new Thermostat();
        Heater heater = new Heater(60);
        Cooler cooler = new Cooler(80);
        string temperature;

        // Register subscribers
        thermostat.OnTemperatureChange += heater.OnTemperatureChanged;
        thermostat.OnTemperatureChange += cooler.OnTemperatureChanged;

        Console.Write("Enter temperature: ");
        temperature = Console.ReadLine();
        thermostat.CurrentTemperature = int.Parse(temperature);

        // Delegate Operators +=, -=, +, -
        Thermostat.TemperatureChangeHandler delegate1;
        Thermostat.TemperatureChangeHandler delegate2;
        Thermostat.TemperatureChangeHandler delegate3;

        delegate1 = heater.OnTemperatureChanged;
        delegate2 = cooler.OnTemperatureChanged;

        Console.WriteLine("Invoke both delegates:");
        delegate3 = delegate1;
        delegate3 += delegate2;
        delegate3(90);

        Console.WriteLine("Invoke only delegate2");
        delegate3 -= delegate1;
        delegate3(30);

        // Error handling
        thermostat.OnTemperatureChange += (newTemperature) => { throw new ApplicationException(); };
        thermostat.CurrentTemperatureHandlingError = int.Parse(temperature) + 1;
    }
}

// event implementation of subscriber-publisher
using System;

// Heater and Cooler Event Subscriber Implementations
class Cooler {
    public Cooler(float temperature) {
        Temperature = temperature;
    }

    public float Temperature {
        get { return _Temperature; }
        set { _Temperature = value; }
    }

    private float _Temperature;

    public void OnTemperatureChanged(object sender, Thermostat.TemperatureArgs args) {
        if (args.NewTemperature > Temperature) {
            System.Console.WriteLine("Cooler: On");
        }
        else {
            System.Console.WriteLine("Cooler: Off");
        }
    }
}

class Heater {
    public Heater(float temperature) {
        Temperature = temperature;
    }

    public float Temperature {
        get { return _Temperature; }
        set { _Temperature = value; }
    }
    private float _Temperature;

    public void OnTemperatureChanged(object sender, Thermostat.TemperatureArgs args) {
        if (args.NewTemperature < Temperature) {
            System.Console.WriteLine("Heater: On");
        }
        else {
            System.Console.WriteLine("Heater: Off");
        }
    }
}

// Defining the Event Publisher, `Thermostat`
public class Thermostat {
    public class TemperatureArgs: System.EventArgs { // conventions
        public TemperatureArgs(float newTemperature) {
            NewTemperature = newTemperature;
        }

        public float NewTemperature {
            get { return _newTemperature; }
            set { _newTemperature = value; }
        }
        private float _newTemperature;
    }

    // Define the delegate data type
    // It is a norm:
    //      sender: reference of the to the object that invoke the delegate 
    //      args:   if of type `System.EventArgs` or derives from `System.EventArgs` but contains additional data
    public delegate void TemperatureChangeHandler(object sender, TemperatureArgs newTemperature);

    // Define the event publisher
    // delegate类型之前加event，赋一个空的delegate
    // an empty delegate represents a collection of zero listeners
    public event TemperatureChangeHandler OnTemperatureChange = delegate {};

    public float CurrentTemperature {
        get { return _CurrentTemperature; }
        set {
            if (value != CurrentTemperature) {
                _CurrentTemperature = value;
                // If there are any subscribers
                // then notify them of changes in 
                // temperature
                if (OnTemperatureChange != null) {
                    // Call subscribers
                    OnTemperatureChange(this, new TemperatureArgs(value));
                }
            }
        }
    }
    private float _CurrentTemperature;
}

class Program {
    public static void Main() {
        Thermostat thermostat = new Thermostat();
        Heater heater = new Heater(60);
        Cooler cooler = new Cooler(80);
        string temperature;

        // Register subscribers
        thermostat.OnTemperatureChange += heater.OnTemperatureChanged;
        thermostat.OnTemperatureChange += cooler.OnTemperatureChanged;

        Console.Write("Enter temperature: ");
        temperature = Console.ReadLine();
        thermostat.CurrentTemperature = int.Parse(temperature);
    }
}

// Define the event publisher
public event TemperatureChangeHandler OnTemperatureChange {
  add
  {
      System.Delegate.Remove(_OnTemperatureChange, value);
  }
  remove
  {
      System.Delegate.Combine(value, _OnTemperatureChange);
      
  }
}
protected TemperatureChangeHandler _OnTemperatureChange;