20     class Item1

   21     {

   22         /// <summary>

   23         ///  With generics, you can create simple functions to visit every item

   24         ///  in a collection

   25         /// </summary>

   26         public void TestGenerics1()

   27         {

   28             List<int> lst = new List<int>() { 1, 2, 3, 4 };

   29             Action<int> delPrint = Print;

   30             EnumerateAll(lst, delPrint);

   31 

   32             // could also call EnumerateAll using the following syntax

   33             EnumerateAll(lst, Print);

   34         }

   35         private void EnumerateAll<T>(IEnumerable<T> collection, Action<T> action)

   36         {

   37             foreach (T obj in collection)

   38                 action(obj);

   39         }

   40 

   41         private void Print<T>(T obj)

   42         {

   43             Trace.WriteLine("Item is: ", obj.ToString());

   44         }

   45 

   46         /// <summary>

   47         /// To sort an array of objects that does not implement IComparable<T>,

   48         /// you can supply a delegate that matches System.Comparison<T> delegate

   49         /// </summary>

   50         public void TestGenerics2()

   51         {

   52             List<string> lst = new List<string> { "B2", "B1", "A2", "A1" };

   53             lst.Sort(MyStringComparison);

   54             Trace.WriteLine(lst.ToString());

   55         }

   56 

   57         private int MyStringComparison<T>(T x, T y)

   58         {

   59             string s1 = x as string;

   60             string s2 = y as string;

   61 

   62             if ((x == null) || (y == null)) return -1;

   63 

   64             if (s1[0] < s2[0])

   65                 return -1;

   66             if (s1[0] > s2[0])

   67                 return 1;

   68             else

   69             {

   70                 if (s1[1] < s2[1])

   71                     return -1;

   72                 if (s1[1] > s2[1])

   73                     return 1;

   74                 else

   75                     return 0;

   76             }

   77         }

   78 

   79 

   80         /// <summary>

   81         /// System.Convertr<T,S> generic delegate converts one input object into a

   82         /// corresponding output:

   83         ///    public delegate TOutput Converter<TInput, TOutput>(TInput input)

   84         ///   

   85         /// Converter is therefore a delegate that takes an input of type TInput

   86         /// and returns an object of type TOutput

   87         /// </summary>

   88         public void TestGenerics3()

   89         {

   90             // Create an array of PointF points (note use of C# 3.0 Object Initializers)

   91             PointF[] ptsFloat = new PointF[] { new PointF{X=1.1F, Y=1.1F},

   92                                             new PointF{X=2.1F, Y=2.1F},

   93                                             new PointF{X=3.1F, Y=3.1F}};

   94 

   95             // Now convert to a list of Point points

   96             IEnumerable<Point> ptsInt = Transform<PointF, Point>(ptsFloat, PointFToPoint);

   97 

   98         }

   99 

  100         private Point PointFToPoint(PointF srcPoint)

  101         {

  102             return new Point((int)srcPoint.X, (int)srcPoint.Y);

  103         }

  104 

  105         /// <summary>

  106         ///  Transform has two type parameters: TInput and TOutput, which represent the input

  107         ///  and output types for the transform

  108         /// </summary>

  109         private IEnumerable<TOutput> Transform<TInput, TOutput>(IEnumerable<TInput> collSrc, Converter<TInput, TOutput> converter)

  110         {

  111 

  112             List<TOutput> lst = new List<TOutput>();

  113             foreach (TInput item in collSrc)

  114                 lst.Add(converter(item));

  115 

  116             return lst;

  117         }

  118 

  119         /// <summary>

  120         /// In .NET 1.1, you had to create a class derived from EventArgs, then create

  121         /// the delegate definition to refer to the derived class, and then create an event

  122         /// definition to match the delegage:

  123         ///    public MyEventArgs : EventArgs { ... }

  124         ///    public delegate void MyEventHandler(object sender, MyEventArgs args);

  125         ///    public event MyEventHandler MyEvent

  126         ///   

  127         /// .NET 2.0 now includes a generic definition for the event handler:

  128         ///    public delegate void EventHandler<TEventArgs>(Object sender, TEventArgs e) where TEventArgs : EventArgs

  129         ///   

  130         /// Now declaring MyEvent looks like:

  131         ///    public event EventHandler<MyEventArgs> MyEvent;

  132         /// </summary>

  133         public void TestGenerics4()

  134         {

  135             this.MyEvent += new EventHandler<MyEventArgs>(Item1_MyEvent);

  136 

  137             MyEvent(this, new MyEventArgs("hello from generic event handler"));

  138         }

  139 

  140 

  141         public event EventHandler<MyEventArgs> MyEvent;

  142         public class MyEventArgs : EventArgs

  143         {

  144             private string msg;

  145 

  146             public MyEventArgs(string messageData)

  147             {

  148                 msg = messageData;

  149             }

  150             public string Message

  151             {

  152                 get { return msg; }

  153                 set { msg = value; }

  154             }

  155         }

  156 

  157         void Item1_MyEvent(object sender, Item1.MyEventArgs e)

  158         {

  159             Trace.WriteLine(e.Message);

  160         }

  161     }

class Item2

{

    /// <summary>

    /// The alternative to not using contraints is to perform lots of casting and runtime

    /// checks. AreEqual<T> is a generic method that tests if two objects are equal using

    /// IComparable<T>. Becasue AreEqual<T> does not declare any contraints on T, it must

    /// therefore check for the presence of IComparable<T>

    /// Not specifying necessary constraints means that your methods/classes could easily

    /// be misused, producing exceptions or runtime errors when client programmers guess

    /// wrong

    /// </summary>

    public bool AreEqual<T>(T lhs, T rhs)       //lhs, rhs: left-hand side and right-hand side

    {

        // If either parameter is null, return false

        if ((lhs == null) || (rhs == null)) return false;

 

        // Check that lhs implements IComparable<T>

        IComparable<T> ILhs = lhs as IComparable<T>;

        if (ILhs != null)

            return (ILhs.CompareTo(rhs) == 0);

        else

            throw new InvalidOperationException("lhs does not implement IComparable<T>");

    }

 

    /// <summary>

    /// The equivalent method is much simpler if you specify that T must implement IComparable<T>

    /// This method trades run time errors (see exception code in AreEqual) with compile-time

    /// errors: compiler generates errors if lhs or rhs does not derive from IComparable<T>

    ///

    /// </summary>

    public bool AreEqualWithConstraints<T>(T lhs, T rhs) where T : IComparable<T>

    {

        // No need to perform runtime checks

        return (lhs.CompareTo(rhs) == 0);

    }

 

    /// <summary>

    /// If AreEqual2<T> is defined in a generic type (say, Stack<T>) that declares the

    /// IEquatable<T> constraint, it will call IEquatable<T>.Equals. Otherwise, the C#

    /// compiler cannot assume that IEquatable<T> is present and will instead call

    /// System.Object.Equals

    ///

    /// This example illustrates the basic difference between C# generic and C++ Templates

    /// In C#, the compiler must generate IL using only the information specified in constraints.

    /// Even if the type specified for a specific instantiation has a better method (ie,

    /// IEquatable<T>.Equals), it will not be used unless it was specified when the generic type

    /// (Stack<T>) was compiled.

    ///

    /// So, must every using AreEqual2<T> implement IEquatable<T>? The answer is no. Rather than

    /// adding a IEquatable<T> constraint on AreEqual2<T>, in the function body check for existence

    /// of IEquatable<T>, and if not present, transparently downgrade to the less preferred

    /// Object.Equals method. See AreEqual3<T>

    /// </summary>

    public bool AreEqual2<T>(T lhs, T rhs)

    {

        return lhs.Equals(rhs);

    }

 

    /// <summary>

    ///

    /// </summary>

    public bool AreEqual3<T>(T lhs, T rhs)

    {

        // If either parameter is null, return false

        if ((lhs == null) || (rhs == null)) return false;

 

        // Check that lhs implements IComparable<T>

        IEquatable<T> ILhs = lhs as IEquatable<T>;

        if (ILhs != null)

            return (ILhs.Equals(rhs));

        else

            return lhs.Equals( rhs );

 

    }

 

    /// <summary>

    /// Recall that the new() constraint indicates to the compiler that a generic type parameter

    /// (T in Stack<T>) supports a public default constructor (constructor with no params). In some

    /// cases you can replace the new() constraint by replacing 'new' calls with default(), which is

    /// an operator that initialzes a variable to its default value (0s for value types and null for

    /// reference types).

    ///

    /// The following method wraps a factory method (FactoryFunc delegate) to create an object

    /// of type T. If the factory method fails to create an object of type T, it returns the value

    /// returned by the default constructor. This method must therefore specify the new() constraint.

    /// Also because of the test for null, the behavior is different for value types. Value types

    /// cannot be null and therefore the caluse under the if statement will never be executed (the

    /// JIT compiler will remove the null test if T is a value type). Therefore, be careful when

    /// adding new() constraint as it creates assumptions about how an object will be constructed.

    /// </summary>

    public delegate T FactoryFunc<T>();

    public T Factory<T>( FactoryFunc<T> MakeNewT) where T : new ()

    {

        T val = MakeNewT();

        if (val == null)

            return new T();        // replace with default(T) and remove the 'new()' constraint

        else

            return val;

    }

}

 

// Test class that implements IComparable<T>

class Order : IComparable<Order>

{

    public int nOrderID;

 

    public Order(int id) { nOrderID = id; }

    #region IComparable<Order> Members

    public int CompareTo(Order other)

    {

        if ((this == null) && (other == null)) return 0;

        if ((this == null) && (other != null)) return -1;

        if ((this != null) && (other == null)) return 1;

        return nOrderID.CompareTo(other.nOrderID);

    }

    #endregion

}

 

// Test class that does not implement IComparable<T>

class Customer

{

    public int nCustomerID;

 

    public Customer(int id) { nCustomerID = id; }

}

class Item3

{

    public void TestReverseEnumerable()

    {

        List<int> lst = new List<int>();

        lst.Add(1);

        lst.Add(2);

        lst.Add(3);

        ReverseEnumerable<int> re = new ReverseEnumerable<int>(lst);

        foreach (int n in re)

            Trace.WriteLine( n );

 

    }

}

 

/// <summary>

/// Helper class

/// Recall that IEnumerable<T> exposes an enumerator which supports a simple iteration

/// over a collection of type T

///

/// ReverseEnumerable constructor takes an input parameter that supports IEnumerable<T>.

/// IEnumerable<T> does not support random access

/// </summary>

class ReverseEnumerable<T> : IEnumerable<T>

{

    private IList<T> originalSequence;

    IEnumerable<T> sourceSequence;

 

    // Constructor

    public ReverseEnumerable(IEnumerable<T> sequence)

    {

        sourceSequence = sequence;

 

        // Make use of the fact that many types that implement IEnumerable<T> also implement

        // IList<T>. This improves the efficiency of the code by not having to create an unnecessary

        // copy of sequence. IList<T> enables a more efficient algorithm than does IEnumerable<T>

        // and we have not forced consumers of this class to provide more functionality

        // If 'sequence' does not implement IList<T>, 'originalSequence' is null, and this works

        // fine as it gets initialized in GetEnumerator() function.

        originalSequence = sequence as IList<T>;

    }

 

    #region IEnumerable<T> Members

    public IEnumerator<T> GetEnumerator()

    {

        // Create a copy of the source sequence so it can be reversed

        if (originalSequence == null)

            originalSequence = new List<T>(sourceSequence);

 

        // Return an object that implements IEnumerator<T>

        return new ReverseEnumerator<T>(originalSequence);                           

    }

 

    #endregion

 

    #region IEnumerable Members

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()

    {

        return this.GetEnumerator();

    }

    #endregion

}

 

/// <summary>

/// Helper class

/// Recall that IEnumerator<T> supports a simple iteration over a collection of type T

/// </summary>

class ReverseEnumerator<T> : IEnumerator<T>

{

    private int nCurrentIndex;

    private IList<T> collection;

 

    // Constructor

    public ReverseEnumerator(IList<T> source)

    {

        collection = source;

        nCurrentIndex = source.Count;       // nCurrenIndex starts from the end

    }

 

    #region IEnumerator<T> Members

    public T Current

    {

        get { return collection[nCurrentIndex]; }

    }

    #endregion

 

    #region IDisposable Members

    public void Dispose()

    {

        // No implementation is needed as there are no unmanaged resources

    }

    #endregion

 

    #region IEnumerator Members

    object System.Collections.IEnumerator.Current

    {

        get { return this.Current;  }

    }

 

    public bool MoveNext()

    {

        return (--nCurrentIndex >= 0);

    }

 

    public void Reset()

    {

        nCurrentIndex = collection.Count;

    }

    #endregion

}

/// <summary>

/// This is a helper class that illustrates a pattern for serialization/deserialization

/// This is a non-generic version that can serialize any arbitrary type

///

/// XmlPersistenceManager works but its use requires a type be specified as it (the type)

/// cannot be inferred. There is also the issue of type safety: every time you call

/// LoadFromFile() you must cast or convert the returned object. There is also a hidden

/// inefficiency: every call to one of the class methods create a new XmlSerializer which

/// can indirectly create lots of temporary object that are not needed.

/// </summary>

internal static class XmlPersistenceManager

{

    private static object LoadFromFile(Type typeToLoad, string strFilePath)

    {

        // If file does not exist, return the defautl value for object (i.e., null)

        if (!File.Exists(strFilePath))

            return default(object);

 

        // Otherwise, load stream from file and convert to an object

        using (TextReader tr = new StreamReader(strFilePath))

        {

            XmlSerializer serializer = new XmlSerializer(typeToLoad);

            return serializer.Deserialize(tr);

        }

    }

 

    private static void SaveToFile(string strFilePath, object ob)

    {

        Type typeToSave = ob.GetType();

        using (TextWriter tw = new StreamWriter(strFilePath))

        {

            XmlSerializer serializer = new XmlSerializer(typeToSave);

            serializer.Serialize(tw, ob);

        }

    }

}

 

/// <summary>

/// The following is a generic version of XmlPersistenceManager that is type-safe

/// and efficient

/// </summary>

internal static class GenericXmlPersistenceManager<T>

{

    // Cache the serializer once it is created

    private static XmlSerializer serializer = null;

    private static T LoadFromFile(string strFilePath)

    {

        // Create the XmlSerializer once, and cache it for the rest of time as each

        // XmlSerializer is tied to a specific Type class

        if (serializer == null)

            serializer = new XmlSerializer(typeof(T));

 

        // If file does not exist, return the defautl value for object (i.e., null)

        if (!File.Exists(strFilePath))

            return default(T);

 

        // Otherwise, load stream from file and convert to an object

        using (TextReader tr = new StreamReader(strFilePath))

        {               

            return (T)serializer.Deserialize(tr);

        }

    }

 

    private static void SaveToFile(string strFilePath, T ob)

    {

        // Create the XmlSerializer once, and cache it for the rest of time as each

        // XmlSerializer is tied to a specific Type class

        if (serializer == null)

            serializer = new XmlSerializer(typeof(T));

 

        using (TextWriter tw = new StreamWriter(strFilePath, false))

        {               

            serializer.Serialize(tw, ob);

        }

    }

}

public class Item5

{

    internal void TestLeakableGenericClass()

    {

        // Note that 'OrderEngine_v1' is responsible for creating an instance

        // of BookORder

        OrderEngine_v1<BookOrder> v1 = new OrderEngine_v1<BookOrder>();

        v1.ProcessOrder_CanCauseLeak("test");

        v1.ProcessOrder_NoLeak("test");

 

        // Note that we are now responsible for creating and managing BookOrder

        // object

        BookOrder bo = new BookOrder();

        using (bo as IDisposable)

        {

            OrderEngine_v2<BookOrder> v2 = new OrderEngine_v2<BookOrder>(bo);

            v2.ProcessOrder("test");

 

        }   // bo.Dispose() called her, IF bo implements IDisposable

    }

}

 

/// <summary>

/// Helper class to illustrate possible resource leaks when using generic type parameters

/// In method ProcessOrder_CanCauseLeak, we create and use an instance of the generic

/// type parameter (T). But what if T was a disposable type that required Dispose to be

/// explicitly called? You will introduce a resource leak if T implements IDisposable

/// </summary>

public class OrderEngine_v1<T> where T : IOrder, new()

{   

    /// <summary>

    /// Create an instance of T. What if T required Dispose to be called on it? You get

    /// a resource leak

    /// </summary>       

    public void ProcessOrder_CanCauseLeak(string name)

    {

        // Create an instance of T. Note that we own and control the instance

        T order = new T();

        order.CreateOrder(name);

    }

 

    /// <summary>

    /// To prevent the possibility of a resouce leak as in ProcessOrder_CanCauseLeak, in every

    /// case where you create a local variable of type T, you need to check whether T implements

    /// IDisposable, and, if so, dispose of it correctly

    /// </summary>

    public void ProcessOrder_NoLeak(string name)

    {

        // Create an instance of T. Note that we own and control the instance

        T order = new T();

 

        // Note that casting syntax inside using. The compiler creates a hidden local variable that

        // stores a reference to the order cast as an IDisposable. If T does not implement IDisposable,

        // then the value of this local variable is null. In those cases, the compiler does not call

        // Dispose(), because it checks against null before doing this extra work. However, in all cases

        // where T implements IDisposable, the compiler generates a call to the Dispose() method upon

        // exiting the using block.

        using (order as IDisposable)

        {

            order.CreateOrder(name);

        }

    }       

}

 

/// <summary>

/// In OrderEngine_v1, an instance of T was created as a local variable inside a function.

/// Things can get more complicated when the generic class needs to create and use an instance

/// of T as a member variable (see _order member variable below).

///

/// The recommended approach is to change the interface of the generic type so as to let the

/// user of the class be responsible for

///     1. Creating an instance of the generic type parameter (T), and

///     2. Calling Dispose on the generic-type-parameter instance

/// </summary>

public class OrderEngine_v2<T> where T : IOrder

{

    T _order = default(T);

 

    // Constructor

    public OrderEngine_v2(T order)

    {

        // We do not create the order. The user of the class create 'order' and passes it in

        // Contrast this to OrderEngine_v1 methods

        _order = order;

    }

 

    public void ProcessOrder(string name)

    {

        // No need to check for IDisposable. This responsibility has been moved to the user.

        _order.CreateOrder(name);

    }

}

 

public interface IOrder

{

    void CreateOrder(string strName);

}

 

// BookOrder is a type argument for OrderEngine_v1<T>

public class BookOrder : IOrder

{

    public string _strBookName;

 

    #region IOrder Members

    public void CreateOrder(string strName)

    {

        _strBookName = strName;

 

        // Other required steps ...

    }

    #endregion

}

 

// DVDOrder is a type argument for OrderEngine_v1<T>

public class DVDOrder : IOrder

{

    public string _strDVDName;

 

    #region IOrder Members

    public void CreateOrder(string strName)

    {

        _strDVDName = strName;

 

        // Other required steps ...

    }

    #endregion

}

class Item6

{

    /// <summary>

    /// Incorrect approach to use an Add() method on T in a generic class

    /// </summary>

    public void DoNotUseCode()

    {

        DoNotUse.OrderEngine<DoNotUse.BookOrder> oe = new DoNotUse.OrderEngine<DoNotUse.BookOrder>();

        DoNotUse.BookOrder bo1 = new Samples.DoNotUse.BookOrder(10);

        DoNotUse.BookOrder bo2 = new Samples.DoNotUse.BookOrder(20);

        DoNotUse.BookOrder boSum = oe.AddOrder(bo1, bo2);           

    }

 

    /// <summary>

    /// Correct approach to use an Add() method on T in a generic class.

    /// </summary>

    public void UseThisCode()

    {

        UseThis.OrderEngine<UseThis.BookOrder> oe = new UseThis.OrderEngine<UseThis.BookOrder>();

        UseThis.BookOrder bo1 = new UseThis.BookOrder(1);

        UseThis.BookOrder bo2 = new UseThis.BookOrder(2);           

        UseThis.BookOrder sum = oe.AddOrder(bo1, bo2, delegate(UseThis.BookOrder o1, UseThis.BookOrder o2)

        {

            int nTotal = o1.nTotal + o2.nTotal;

            UseThis.BookOrder s = new Samples.UseThis.BookOrder(nTotal);

            return s;

        });

    }

 

    /// <summary>

    /// This method illustrates the use of delegate-based contracts to create algorithms that

    /// operate on sequences. In this example, Merge helper method enumerates both input sequences,

    /// and for each pair of items in the input sequence, it calls the merger delegate to return a

    /// new constructed TOutput object

    ///

    /// </summary>

    public void GenericMerge()

    {

        float[] dXValues = { 2, 4, 6, 8, 10 };

        float[] dYValues = { 1, 3, 5, 7, 9 };

 

        IEnumerable<PointF> Points = Merge(dXValues, dYValues, delegate(float x, float y)

        {

            return new PointF(x, y);

        });

    }

 

    private IEnumerable<TOutput> Merge<T1, T2, TOutput>(IEnumerable<T1> XValues, IEnumerable<T2> YValues, Func<T1, T2, TOutput> merger)

    {

        // Get enumerators to help traverse Xvalues and YValues arrays

        IEnumerator<T1> XEnumerator = XValues.GetEnumerator();

        IEnumerator<T2> YEnumerator = YValues.GetEnumerator();

 

        // Iterator over both X and Y enumerators

        while (XEnumerator.MoveNext() && YEnumerator.MoveNext())

        {

            yield return merger(XEnumerator.Current, YEnumerator.Current);

        }

    }

}

 

namespace DoNotUse

{

    // Created by class developer

    interface IAdd<T>

    {

        T Add(T other);

    }

 

    // Created by class developer

    class OrderEngine<T> where T : IAdd<T>

    {

        public T AddOrder(T order1, T order2)

        {

            T orderSum = order1.Add(order2);

            return orderSum;

        }

    }

 

    // Created by developer wishing to use OrderEngine<T>

    class BookOrder : IAdd<BookOrder>

    {

        public int nTotal = 0;

        public BookOrder(int tot) { nTotal = tot; }

        public BookOrder Add(BookOrder other)

        {

            int nSum = this.nTotal + other.nTotal;

            BookOrder sum = new BookOrder(nSum);               

            return sum;

        }

    }

}

 

namespace UseThis

{

    class OrderEngine<T>

    {

        public T AddOrder(T order1, T order2, Func<T, T, T> AddFunc)

        {

            T sum = AddFunc(order1, order2);

            return sum;

        }

    }

 

    class BookOrder

    {

        public int nTotal = 0;

        public BookOrder(int tot) { nTotal = tot; }

    }

}

class Item7

{

    /// <summary>

    /// The output of the first WriteMessage(ob) shows an important concept:

    /// WriteMessage<T>(T obj) is a better match than WriteMessage(MyBase b) for an object that is

    /// derived from MyBase. That's because the compiler can make an exact match by substituting

    /// MyDerived for T in that message, and WriteMessage(MyBase) requires an implicit conversion.

    /// </summary>

    public void Test()

    {

        Item7NS.MyDerived ob = new Item7NS.MyDerived();

 

        // Generic methods are always perfect matches, so they win over base class methods.

        WriteMessage(ob);                               // WriteMessage<T>(T ob)

 

        // The following two statements show how to control which methods get invoked

        WriteMessage((Item7NS.IMyInterface)ob);         // WriteMessage(IMyInterface ob)

        WriteMessage((Item7NS.MyBase)ob);               // WriteMessage(MyBase ob)

 

        Item7NS.MyOtherDerived ob2 = new Item7NS.MyOtherDerived();

        WriteMessage(ob2);                              // WriteMessage<T>(T ob)

        WriteMessage((Item7NS.IMyInterface)ob2);        // WriteMessage(IMyInterface ob)

 

    }

 

    private void WriteMessage(Item7NS.MyBase ob)

    {

        Trace.WriteLine("WriteMessage(MyBase ob)");

    }

    private void WriteMessage(Item7NS.IMyInterface ob)

    {

        Trace.WriteLine("WriteMessage(IMyInterface ob)");

    }

    private void WriteMessage<T>(T ob)

    {

        Trace.WriteLine("WriteMessage<T>(T ob)");

    }

}

 

namespace Item7NS

{

    class MyBase { /* Empty implementation */ }

 

    interface IMyInterface

    {

        void DoSomething();

    }

 

    class MyDerived : MyBase, IMyInterface

    {

        #region IMyInterface Members

        public void DoSomething()

        {

            Trace.WriteLine("MyDerived.IMyInterface.DoSomething");

        }

        #endregion

    }

 

    class MyOtherDerived : IMyInterface

    {

        #region IMyInterface Members

        public void DoSomething()

        {

            Trace.WriteLine("MyDerived.IMyInterface.DoSomething");

        }

        #endregion

    }

class Item8

{

    public void Test()

    {

        // Utilities is a generic class. Every call to methods on Utilities<> must

        // specify the generic type parameter T

        double dMax = Item8NS.Utilities<double>.Max(1.0, 1.2);

        int nMax = Item8NS.Utilities<int>.Max(3, 4);

 

        // Utilities2 is no longer a generic class. It is a non-generic class with

        // generic methods. If there is a specific version of the parameter type,

        // the compiler calls that version. If there isn't a specific version, the

        // compiler calls the generic version

        double dMax2 = Item8NS.Utilities2.Max(1.0, 1.01);

        int nMax2 = Item8NS.Utilities2.Max<int>(1, 2);

    }

}

 

namespace Item8NS

{

    /// <summary>

    /// A generic utility class rather than generic methods.  Every call to methods

    /// of this class must specify the generic type parameter.

    ///

    /// Many of the built-in types already have accessible Max and Min methods defined.

    /// Math.Max() and Math.Min() are defined for all the numeric types. Instead of using

    /// those, your generic class always picks up the version you've created using Comparer<T>.

    /// That works, but it forces extra runtime checks to determine whether a type implements

    /// IComparer<T>, followed by a call to the correct method

    /// </summary>

    /// <typeparam name="T"></typeparam>

    public static class Utilities<T>

    {

        public static T Max(T lhs, T rhs)

        {

            bool bLhsBigger = (Comparer<T>.Default.Compare(lhs, rhs) < 0);

            return (bLhsBigger) ? lhs : rhs;

        }

 

        public static T Min(T lhs, T rhs)

        {

            bool bLhsBigger = (Comparer<T>.Default.Compare(lhs, rhs) < 0);

            return (bLhsBigger) ? lhs : rhs;

        }

    }

 

    /// <summary>

    /// Utilities2 is no longer a generic class. It is a non-generic class with generic

    ///  methods. If there is a specific version of the parameter type, the compiler calls

    ///  that version. If there isn't a specific version, the compiler calls the generic

    ///  version.

    /// 

    /// Whenever you use a new type Max<T> or Min<T> , a new version of Max<T> or Min<T> is

    /// generated by the compiler. If you had instead applied the type parameter to the class

    /// declaration as in Utilities<T>, every Min or Max would be forced to hold only one type.

    /// Either approach is valid, but the semantics are very different.

    /// </summary>

    public static class Utilities2

    {

        // Generic methods

        public static T Max<T>(T lhs, T rhs)

        {

            bool bLhsBigger = (Comparer<T>.Default.Compare(lhs, rhs) < 0);

            return (bLhsBigger) ? lhs : rhs;

        }

        public static T Min<T>(T lhs, T rhs)

        {

            bool bLhsBigger = (Comparer<T>.Default.Compare(lhs, rhs) < 0);

            return (bLhsBigger) ? lhs : rhs;

        }

 

        // Overloadsc

        public static double Max(double lhs, double rhs)

        {

            return Math.Max(lhs, rhs);

        }

    }

 

}

class Item9

{

    public void Test()

    {

        Item9NS.Tuple<string, long> details = GetNameAndID();

    }

    private Item9NS.Tuple<string, long> GetNameAndID()

    {

        return new Item9NS.Tuple<string, long>("Yazan", 123);

    }

}

 

namespace Item9NS

{

    /// <summary>

    /// A tuple is just a composite type that n elements. Note how IEquatable<T>

    /// is defined: IEquatable<Tuple<T1, T2>> and IEquatable<T>.

    ///

    /// This tuple can be the return type for any method that has two logical return

    /// values.

    /// </summary>

    public class Tuple<T1, T2> : IEquatable<Tuple<T1, T2>>

    {

        private readonly T1 first;

        private readonly T2 second;

 

        public Tuple(T1 t1, T2 t2)

        {

            first = t1;

            second = t2;

        }

        public T1 First { get { return first;}}

        public T2 Second {get {return second;}}

 

        #region IEquatable<Tuple<T1,T2>> Members

 

        public bool Equals(Tuple<T1, T2> other)

        {

            int nFirstCompare = Comparer<T1>.Default.Compare(this.first, other.first);

            int nSecondCompare = Comparer<T2>.Default.Compare(this.second, other.second);

            bool bEqual = (nFirstCompare == 0) && (nSecondCompare == 0);               

            return bEqual;

        }

 

        #endregion

    }

}

namespace Item10NS

{

    /// <summary>

    /// In addition to implementing the generic IEquatable<T> and IComparable<T>, this class

    /// also implements the non-generic IComparable. Notice that the non-generic IComparable

    /// interface is defined using explicit interface implementation. This practice ensures

    /// that no one accidentally gets the classic interface instead of the preferred generic

    /// interface. In normal use, the compiler will choose the generic method over the explicit

    /// interface method. Only when the called method has been typed to the classic interface

    /// (IComparable) will the compiler generate a call to that interface member

    ///

    /// </summary>

    public class Name : IEquatable<Name>, IComparable<Name>, IComparable

    {

        private string _strFirst;

        private string _strLast;

 

        public string First

        {

          get { return _strFirst; }

          set { _strFirst = value; }

        }

 

        public string Last

        {

          get { return _strLast; }

          set { _strLast = value; }

        }

 

        #region IEquatable<Name> Members

        public bool Equals(Name other)

        {

            // If null is passed, equality should be false

            if (object.ReferenceEquals( other, null)) return false;

 

            int nFirstComp = StringComparer.CurrentCulture.Compare(this.First, other.First);

            int nSecondComp = StringComparer.CurrentCulture.Compare(this.Last, other.Last);

            return ((nFirstComp == 0) && (nSecondComp == 0));

        }

        #endregion

 

        #region IComparable<Name> Members

        public int CompareTo(Name other)

        {

            // If null is passed in, indicate that this object is greater

            if (Object.ReferenceEquals( null, other)) return 1;

 

            int nFirstComp = StringComparer.CurrentCulture.Compare( this.First, other.First);

            if (nFirstComp != 0) return nFirstComp;

 

            int nSecondComp = StringComparer.CurrentCulture.Compare( this.Last, other.Last);

            return nSecondComp;

        }

        #endregion

 

        #region IComparable Members

        int IComparable.CompareTo(object obj)

        {

            if (obj.GetType() != this.GetType())

                throw new InvalidOperationException("obj is not a Name object");

 

            return this.CompareTo(obj as Name);

        }

        #endregion

 

        // Implementing IEquatable<T> means implementing operator== and operator!=

        public static bool operator ==(Name lhs, Name rhs)

        {

            if (lhs == null) return (rhs == null);

            return lhs.Equals(rhs);

        }

 

        public static bool operator !=(Name lhs, Name rhs)

        {

            if (lhs == null) return (rhs != null);

            return !lhs.Equals(rhs);

        }

 

        // Implementing IComparable<T> implies there is an ordering relation. We should therefore implement

        // operator <, >, <=, and >=

        public static bool operator <(Name lhs, Name rhs)

        {

            if (lhs == null) return (rhs != null);

            return (lhs.CompareTo(rhs) < 0);

        }

 

        public static bool operator >(Name lhs, Name rhs)

        {

            if (lhs == null) return false;

            return (lhs.CompareTo(rhs) > 0);

        }

 

        public static bool operator <=(Name lhs, Name rhs)

        {

            if (lhs == null) return true;

            return (lhs.CompareTo(rhs) <= 0);

        }

 

        public static bool operator >=(Name lhs, Name rhs)

        {

            if (lhs == null) return (rhs == null);

            return (lhs.CompareTo(rhs) >= 0);

        }

    }

}

class Item12

{

    private int numberToCompute = 0;

    private int highestPercentageReached = 0;

 

    public void TestBackgroundWorker()

    {

        // Create a BackgroundWorker object and set its events to control and monitor

        // the the background thread

        BackgroundWorker bw = new BackgroundWorker();

        bw.ProgressChanged += new ProgressChangedEventHandler(bw_ProgressChanged);

        bw.Disposed += new EventHandler(bw_Disposed);

        bw.RunWorkerCompleted += new RunWorkerCompletedEventHandler(bw_RunWorkerCompleted);

        bw.DoWork += new DoWorkEventHandler(bw_DoWork);

 

        // These properties control how the foreground and background threads interact

        bw.WorkerReportsProgress = true;

        bw.WorkerSupportsCancellation = true;

 

        // Setup the thread function and start it

        numberToCompute = 100;

        highestPercentageReached = 0;           

        bw.RunWorkerAsync(numberToCompute);

 

    }

 

    # region Event handlers for BackgroundWorkder in TestBackgroundWorker

 

    /// <summary>

    /// Background thread is finished when the DoEvent handler function exits.

    /// </summary>

    void bw_DoWork(object sender, DoWorkEventArgs e)

    {

        BackgroundWorker bw = sender as BackgroundWorker;

        e.Result = ComputeFibonacci((int)e.Argument, bw, e);

    }   // RunWorkerCompleted event fired here.

 

    /// <summary>

    /// Note the RunWorkerCompletedEventArgs.Error property that contains

    /// any exception information generated by the thread function.

    /// </summary>

    void bw_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)

    {

        if (e.Cancelled)

            Trace.WriteLine("Operation cancelled");

        else if (e.Error != null)

            Trace.WriteLine("Error: " + e.Error.Message);

        else

            Trace.WriteLine("Result: " + e.Result.ToString());

    }

 

    void bw_Disposed(object sender, EventArgs e)

    {

        Trace.WriteLine("");

    }

 

    void bw_ProgressChanged(object sender, ProgressChangedEventArgs e)

    {

        Trace.WriteLine("Progress: " + e.ProgressPercentage);

    }

    #endregion

 

    // This is the method that does the actual work. For this

    // example, it computes a Fibonacci number and

    // reports progress as it does its work.

    long ComputeFibonacci(int n, BackgroundWorker worker, DoWorkEventArgs e)

    {

        // The parameter n must be >= 0 and <= 91. Fib(n), with n > 91, overflows a long.

        // Note that the exception will be reported in RunWorkerCompletedEventArgs.Error

        // property

        if ((n < 0) || (n > 91))

            throw new ArgumentException("value must be >= 0 and <= 91", "n");

 

        long result = 0;

 

        // Abort the operation if the user has canceled.

        // Note that a call to CancelAsync may have set

        // CancellationPending to true just after the

        // last invocation of this method exits, so this

        // code will not have the opportunity to set the

        // DoWorkEventArgs.Cancel flag to true. This means

        // that RunWorkerCompletedEventArgs.Cancelled will

        // not be set to true in your RunWorkerCompleted

        // event handler. This is a race condition.

        if (worker.CancellationPending)

        {

            e.Cancel = true;

        }

        else

        {

            if (n < 2)

            {

                result = 1;

            }

            else

            {

                result = ComputeFibonacci(n - 1, worker, e) +

                         ComputeFibonacci(n - 2, worker, e);

            }

 

            // Report progress as a percentage of the total task.

            int percentComplete = (int)((float)n / (float)numberToCompute * 100);

            if (percentComplete > highestPercentageReached)

            {

                highestPercentageReached = percentComplete;

                worker.ReportProgress(percentComplete);

            }

        }

 

        return result;

    }

}

class Item13

{

    private object _obLock = new object();

    private int _nTotal = 0;

 

    // The following two methods are identical

    public void IncrementTotalWithLock()

    {

        lock (_obLock)

        {

            _nTotal++;

        }

    }

    public void IncrementTotalWithMonitor()

    {

        System.Threading.Monitor.Enter(_obLock);

        try

        {

            _nTotal++;

        }

        finally

        {

            System.Threading.Monitor.Exit(_obLock);

        }

    }

 

    /// <summary>

    /// Monitor.Enter locks a box containing _nTotal while Monitor.Exit unlocks

    /// a different box containing _nTotal

    /// </summary>

    public void IncrementTotal_Wrong1()

    {

        // Multiple threads call Monitor.Enter successfully because each thread is locking

        // a different object (eacah call to Enter creates a different box for _nTotal)

        System.Threading.Monitor.Enter(_nTotal);

        try

        {

            _nTotal++;

        }

        finally

        {

            // SynchronizationLockException because Monitor.Exit is attempting to unlock

            // an object that was no locked in the first case (call to Monitor.Exit creates

            // yet another object containing _nTotal)

            System.Threading.Monitor.Exit(_nTotal);

        }

    }

 

    public void IncreamentTotal_WithTimeout()

    {

        if (Monitor.TryEnter(_obLock, 1000))

        {

            try

            {

                _nTotal++;

            }

            finally

            {

                Monitor.Exit(_obLock);

            }

        }

        else

            throw new SynchronizationLockException("Timeout expired on _obLock");

    }

 

    public void IncreamentTotal_WithTimeout_Better()

    {

        using (LockHolder lh = new LockHolder( _obLock, 1000))

        {

            if (lh.Locked)

            {

                _nTotal++;

            }

        }   // Monitor.Exit called here

    }

}

 

/// <summary>

/// Class to wraps Monitor.Enter/Exit calls

/// </summary>

class LockHolder : IDisposable

{

    private bool _bLocked = false;

    private object _obLock = null;

    public LockHolder(object obLock, int nMillisecondTimeout)

    {

        _bLocked = Monitor.TryEnter(obLock, nMillisecondTimeout);

        _obLock = obLock;

    }

 

    public bool Locked

    {

        get { return _bLocked; }

        set { _bLocked = value; }

    }

 

    #region IDisposable Members

    public void Dispose()

    {

        if (Locked)

        {

            Monitor.Exit(_obLock);

            Locked = false;

        }

    }

    #endregion

}

class Item14

{

    public Item14NS.LockingDemo dnu = new Item14NS.LockingDemo();

    /// <summary>

    /// Bad locking strategy.

    /// In this call, the calling thread acquires a lock on dnu by virtue of calling lock(this)

    ///  ('this' and 'dnu' represent the same object.) However, if different threads were calling

    ///  TestBadLockApproach1, then a deadlock situation can potentially arise as dnu is publicly

    ///  accessible, and different codes my actually call lock(dnu). At one point this will lead

    ///  to a deadlock as we do not know who is locking 'dnu'

    /// </summary>

    public void TestLockingApproaches()

    {           

        dnu.MethodWithBadLock();

        dnu.Method1WithGoodLock();

        dnu.Method2WithGoodLock();

        Item14NS.LockingDemo.StaticMethodWithGoodLock();

    }

}

 

namespace Item14NS

{

    class LockingDemo

    {

        private int _nSum = 0;

        private object _obInstanceLock = new object();

 

        static int _nStaticSum = 0;

        static private object _obStaticLock = new object();

        public void MethodWithBadLock()

        {

            // Do not use lock(this)

            lock(this)

            {

                _nSum++;

            }

        }

 

        public void Method1WithGoodLock()

        {

            // Use this approach

            lock (_obInstanceLock)

            {

                _nSum++;

            }

        }

 

        /// <summary>

        /// Same as Method1WithGoodLock buts shows that there is no need to lock the

        /// entire function.

        /// </summary>

        public void Method2WithGoodLock()

        {               

            Func1WithNoSynchronization();

 

            lock (_obInstanceLock)

            {

                _nSum++;

            }

 

            Func2WithNoSynchronization();

        }

 

        static public void StaticMethodWithGoodLock()

        {

            // Use this approach

            lock (_obStaticLock)

            {

                _nStaticSum++;

            }

        }

 

        private void Func1WithNoSynchronization() { /* Add any implementation here*/ }

        private void Func2WithNoSynchronization() { /* Add any implementation here*/ }

    }

}

class Item15

{

    public void TestUnknownCodeCallingIntoSynchedCode()

    {

        // Create object and hookup events.

        System.Threading.Thread.CurrentThread.Name = "Item15Thread";

        Item15NS.WorkerClass ob = new Item15NS.WorkerClass();

        ob.RaiseProgress += new EventHandler<EventArgs>(ob_RaiseProgress);

 

        // Call method that locks code

        ob.DoWork();

 

    }

 

    /// <summary>

    /// Event handler that calls back into the sender. Calling into the sender attempts to acquire a

    /// lock that is already acquired by the code that fired the event in the first place.

    /// </summary>

    void ob_RaiseProgress(object sender, EventArgs e)

    {

        Item15NS.WorkerClass ob = sender as Item15NS.WorkerClass;

        Trace.WriteLine("ThreadName: " + System.Threading.Thread.CurrentThread.Name + ". Progress: " + ob.Progress);

    }

}

 

namespace Item15NS

{

    public class WorkerClass

    {

        private int progressCounter = 0;           

        private object syncHandle = new object();

        public event EventHandler<EventArgs> RaiseProgress;

 

        public void DoWork()

        {

            for (int count = 0; count < 100; count++)

            {

                lock (syncHandle)

                {

                    System.Threading.Thread.Sleep(100);

                    progressCounter++;

 

                    // An event is raised from within a syncrhonized region. Not good

                    // Move this block of code just outside the lock scope (see commented code)

                    if (RaiseProgress != null)

                        RaiseProgress(this, EventArgs.Empty);

                }

 

                //Comment RaiseProgress event raising inside lock and uncomment this code

                // for proper operation

                /*if (RaiseProgress != null)

                    RaiseProgress(this, EventArgs.Empty);

                */

            }

        }

 

        public int Progress

        {

            get { lock (syncHandle) { return progressCounter;} }

        }

    }

}

namespace Item16NS

{

    /// <summary>

    ///  The following ControlExtensions static class contains generic methods for any invoke delegate

    ///  having up to two parameters. You can add more overloads by adding more parameters. Further,

    ///  it contains methods that use those delegate definitions to call the target, either directly or

    ///  through the marshalling provided by Dispatcher

    /// 

    /// Typical usage is:

    ///     this.InvokeIfNeeded( (() => toolStripStatusLabel1.Text = "Test"), DispatcherPriority.Normal);

    ///    

    ///  Inside the ControlExtensions class, the generic method handles the check for CheckAccess, meaning

    ///  that you don't need to remember it each time.        

    /// </summary>

    public static class WPFControlExtensions

    {

        public static void InvokeIfNeeded(this DispatcherObject ctl, Action doit, DispatcherPriority priority)

        {               

            if (!ctl.Dispatcher.CheckAccess())

            {                   

                ctl.Dispatcher.Invoke(priority, doit);

            }

            else

            {

                doit();

            }

        }

        public static void InvokeIfNeeded<T>( this DispatcherObject ctl, Action<T> doit, T args, DispatcherPriority priority)

        {

            if (!ctl.Dispatcher.CheckAccess())

            {

                ctl.Dispatcher.Invoke(priority, doit, args);

            }

            else

            {

                doit(args);

            }

        }

    } 

}

class Item17

{

    /// <summary>

    /// The following function shows how to use 'yield return' and generates the following output:

    ///

    ///    Entering UpdatePrice

    ///    Evaluating 1

    ///Updated price: 10

    ///

    ///    Re-entering after yield return

    ///    Evaluating 2

    ///Updated price: 20

    ///

    ///    Re-entering after yield return

    ///    Evaluating 3

    ///Updated price: 30

    ///

    ///    Re-entering after yield return

    ///    Evaluating 4

    ///Updated price: 40

    ///

    ///    Re-entering after yield return

    ///    Evaluating 5

    ///Updated price: 50

    ///

    ///    Re-entering after yield return

    ///    Exiting UpdatePrice

    /// </summary>

    public void TestIterators()

    {

        // Create a test list

        List<int> lstPrices = new List<int>() { 1, 2, 3, 4, 5 };

 

        // Call a function that uses 'yield return'. Observe trace outputs

        foreach (int n in UpdatePrice(lstPrices, 10))

            Trace.WriteLine("Updated price: " + n + Environment.NewLine);

    }

 

    /// <summary>

    /// The following function shows how to use 'yield return' on a generic type,

    /// and generates the following output:

    ///    Entering GenericUpdatePrice

    ///    Evaluating 1

    ///Updated price: -10

    ///

    ///    Re-entering after yield return

    ///    Evaluating 2

    ///Updated price: -20

    ///

    ///    Re-entering after yield return

    ///    Evaluating 3

    ///Updated price: -30

    ///

    ///    Re-entering after yield return

    ///    Evaluating 4

    ///Updated price: -40

    ///

    ///    Re-entering after yield return

    ///    Evaluating 5

    ///Updated price: -50

    ///

    ///    Re-entering after yield return

    ///    Exiting GenericUpdatePrice

    /// </summary>

    public void TestGenericIterators()

    {

        // Create a test list

        List<int> lstPrices = new List<int>() { 1, 2, 3, 4, 5 };

 

        foreach (int n in GenericUpdatePrice<int>(lstPrices, -10, UpdatePriceFunc))

            Trace.WriteLine("Updated price: " + n + Environment.NewLine);

    }

 

    /// <summary>

    /// Creating simple iterators with 'yield return' allows you to construct complex

    /// pipelined algorithms

    /// </summary>

    public void TestAllIterators()

    {

        // Create a test list

        List<int> lstPrices = new List<int>() { 1, 2, 3, 4, 5 };

        List<int> lstTempPrices = new List<int>();

        List<int> lstModifiedPrices = new List<int>();

        // Call a function that uses 'yield return'. Observe trace outputs

 

        int nFactor1 = 10;

        int nFactor2 = 10;

        foreach (int n in UpdatePrice(lstPrices, nFactor1))

        {

            lstTempPrices.Add(n);

            Trace.WriteLine("Updated price: " + n + Environment.NewLine);

        }

 

        foreach (int n in GenericUpdatePrice<int>(lstTempPrices, nFactor2, UpdatePriceFunc))

        {

            lstModifiedPrices.Add(n);

            Trace.WriteLine("Updated price: " + n + Environment.NewLine);

        }

    }

 

    /// <summary>

    /// The yield return statement plays an interesting trick: It returns a value and retains

    /// information about its current location and the current state of its internal iteration

    /// </summary>

    private IEnumerable<int> UpdatePrice(IEnumerable<int> prices, int nFactor)

    {

        Trace.WriteLine("\tEntering UpdatePrice");

        foreach (int price in prices)

        {               

            Trace.WriteLine("\tEvaluating " + price);

            yield return (price * nFactor);

            Trace.WriteLine("\tRe-entering after yield return");

        }

        Trace.WriteLine("\tExiting UpdatePrice");

    }

 

    /// <summary>

    /// A generic version of UpdatePrice() function

    /// </summary>

    private IEnumerable<T> GenericUpdatePrice<T>(IEnumerable<T> prices, T nFactor, Func<T, T, T> UpdatePriceFunc)

    {

        Trace.WriteLine("\tEntering GenericUpdatePrice");

        foreach (T price in prices)

        {

            Trace.WriteLine("\tEvaluating " + price);

            yield return UpdatePriceFunc(price, nFactor);

            Trace.WriteLine("\tRe-entering after yield return");

        }

        Trace.WriteLine("\tExiting GenericUpdatePrice");

    }

 

    private int UpdatePriceFunc(int nPrice, int nFactor)

    {

        return nPrice * nFactor;

    }

}

class Item18

{

    /// <summary>

    /// Shows predicate usage using anonymous delegates and lambda expressions

    /// for List<T>.RemoveAll( predicate<T> match ) function. Internally, this

    /// remove function calls your delegate method successively for every item

    /// in the list. Whenever the delegate returns true, that element is removed

    /// from the list.

    /// </summary>

    public void TestGeneralPredicates()

    {

        // Create a list with data

        List<int> lstNumbers = new List<int>() { 1, 2, 3, 2, 3, 2, 2, 3};

 

        // Use an anonymous delegate to remove all items that match a specific condition

        // In this case, removes all elements whose value is 2

        int nConditionValue = 2;

        lstNumbers.RemoveAll(

            delegate(int nCollectionMember)

            {

                return nCollectionMember == nConditionValue;

            });       

 

        // Use a lambda expression to remove all items that match a specific condition

        // In this case, removes all elements whose value is 3

        nConditionValue = 3;

        lstNumbers.RemoveAll( (int nCollectionMember) => nCollectionMember == nConditionValue );

    }

 

    /// Shows action usage using anonymous delegates and lambda expressions

    /// for List<T>.ForEach( Action<T> action ) function. Internally, this

    /// ForEach function calls your delegate method successively for every item

    /// in the list and applies the Action function to each item

    public void TestGeneralActions()

    {

        // Create a list with data

        List<int> lstNumbers = new List<int>() { 1, 2, 3, 2, 3, 2, 2, 3 };

 

        // Use an anonymous delegate to visit each item in lstNumbers

        List<int> lstUpdatedNumbers = new List<int>();

        lstNumbers.ForEach(delegate(int nCollectionMember)

        {

            lstUpdatedNumbers.Add(nCollectionMember * 10);

        });

 

        // Use a lambda expression to visit each item in lstNumbers

        lstUpdatedNumbers.Clear();

        lstNumbers.ForEach((int nCollectionMember) => lstUpdatedNumbers.Add(nCollectionMember * 10));           

    }

 

    /// <summary>

    /// Shows how to decouple iteration from action or logic to be applied for each item

    /// </summary>

    public void TestDecouplingIterations()

    {

        List<int> lstNumbers = new List<int>() { 1, 2, 2, 3, 4, 5, 2 };

 

        List<int> lstFilteredNumbers = new List<int>();

        int nFilterValue = 2;

        foreach (int number in Filter(lstNumbers, (int nCollectionMember) => nCollectionMember != nFilterValue))

            lstFilteredNumbers.Add(number);

    }

 

    /// <summary>

    /// Helper method that decouples iteration logic from action to be applied to

    /// each iteration item. Note that each element in the input sequence is evaluated

    /// using the Predicate method and if the Predicate returns true, that element is

    /// returned as part of the output sequence. ~The main point is that and developer

    /// can write a method on a type that tests a condition, and the method will be

    /// compatible with this filter method

    /// </summary>

    private IEnumerable<T> Filter<T>(IEnumerable<T> input, Predicate<T> predicate)

    {

        // Check we have a valid prediate

        if (predicate == null) throw new ArgumentException("Predicate is null");

 

        foreach (T item in input)

            if (predicate(item))

                yield return item;

    }

}

class Item19

{

    /// <summary>

    /// Creates a sequence inefficiently. Note the following:

    /// 1.  First, this technique assumes that you're putting the results into a IList<double>.

    ///     If clients want to store the results in some other structure they must convert it.

    /// 2.  Creating the entire list doesn't give client code a chance to stop the generation

    ///     function based on a specified condition. It will always generate the requested number

    ///     of elements. As written, it can't be stopped if the user wants to stop the process

    ///     for paging or for any other reason.

    /// 3.  This method could be the first stage of several transformations on a sequence of data.

    ///     In that case, this method would be a bottleneck in the pipeline: Every element would

    ///     have to be created and added to the internal collection before the next step could

    ///     continue.

    ///    

    /// You can remove all those limitations by making the generation function an iterator method.

    /// See TestCreateSequenceEfficiently() method

    ///

    /// </summary>

    public void TestCreateSequenceInefficiently()

    {

        IList<double> lst = CreateSequence<double>(10, 5, 10, (int nItem) => Convert.ToDouble(nItem));

    }

    private IList<T> CreateSequence<T>(int nElementCount, int nStartAt, int nStep, Converter<int, T> converter)

    {

        List<T> lst = new List<T>();

 

        for (int i = 0; i < nElementCount; i = i + 1)

        {

            lst.Add(converter(nStartAt + (i*nStep)));

        }

        return lst;

    }

 

    /// <summary>

    /// Improves on the inefficiencies of TestCreateSequenceInefficiently() by generating a sequence

    /// of numbers via 'yield return'. This code does not make any assumptions regarding the storage

    /// location for the generated sequence. Results can be saved in a List or a BindingList or any

    /// other list

    /// </summary>

    public void TestCreateSequenceEfficiently()

    {

        Queue<double> q = new Queue<double>(CreateSequence2<double>(10, 5, 10, (int nItem) => Convert.ToDouble(nItem)));

 

        List<double> lst = new List<double>(CreateSequence2<double>(10, 5, 10, (int nItem) => Convert.ToDouble(nItem)));

 

        // The previous statement is equivlant to:

        List<double> lst2 = new List<double>();

        foreach (double item in CreateSequence2<double>(10, 5, 10, (int nItem) => Convert.ToDouble(nItem)))

            lst.Add(item);           

    }

    private IEnumerable<T> CreateSequence2<T>(int nElementCount, int nStartAt, int nStep, Converter<int, T> converter)

    {

        for (int i = 0; i < nElementCount; i = i + 1)

        {

            yield return converter(nStartAt + (i * nStep));

        }         

    }

 

    /// <summary>

    /// It's easy to stop the enumeration if you use TakeWhile<> extension method. The sequence

    /// generation short-circuits as soon as the first nonconforming value is found. That can

    /// result in a significant performance improvement.

    ///

    /// Of course, any condition can be used to determine when the enumeration should stop. You

    /// can check to see whether the user wishes to continue, poll another thread for input, or

    /// do anything else needed by your application. The enumerator method provides a simple

    /// means of interrupting the enumeration anywhere in the sequence. This deferred execution

    /// means that only the elements requested.

    /// </summary>

    public void TestStoppingSequenceGeneration()

    {

        int nStopAtValue = 20;

        IEnumerable<int> collection = CreateSequence2<int>(10, 5, 10, (int nItem) => Convert.ToInt32(nItem)).

                                            TakeWhile((int val) => val < nStopAtValue);

        List<int> lst = new List<int>();

        foreach (int item in collection)

            lst.Add(item); 

    }

}

class Item20

{

    public void Test1()

    {

        // One way to generate a sequence. The logic to generate the sequence is

        // contained within the CreateSequence method

        foreach (int n in Item20NS.Utility.CreateSequence(10, 0, 5))

            Trace.WriteLine(n);

 

        // A better way to generate sequences (using lambda expressions)

        int nStartAt = 0;

        int nStep = 5;

        IEnumerable<int> aSeq1 = Item20NS.Utility.CreateSequence_V2<int>(10, (i) => nStartAt + (i * nStep));

        foreach (int n in aSeq1)

            Trace.WriteLine(n);

 

        // A better way to generate sequences (using anonymous delegates)

        IEnumerable<int> aSeq2 = Item20NS.Utility.CreateSequence_V2<int>(10, delegate(int i)

            {

                return nStartAt + (i * nStep);

            });

        foreach (int n in aSeq2)

            Trace.WriteLine(n);

    }

 

    public void Test2()

    {

        // Create a sequence that will be summed

        IEnumerable<int> sequence = new int[] {1,2,3,4,5};

 

        // A simple algorithm to add up the elements of a sequence

        int nSum = Item20NS.Math.Sum(sequence);

 

        // Same as above but creates instead a general-purpose accumulator by factoring out the sum

        // operation and replacing it with a delegate;

        int nSum2 = Item20NS.Math.Sum_V2<int>(sequence, (value, total) => value + total);

    }

}

 

namespace Item20NS_DoNotUse

{

    // Improper extra coupling

    public interface IPredicate<T>

    {

        bool Match(T objectToFind);

    }

 

    public class List<T>

    {

        public void RemoveAll(IPredicate<T> predicate)

        {

            // Invoke the predicate on the collection wrapped by this instance                  

        }

    }

 

    // This class must be implemented by the user the Item20NS.List<T> class

    public class MyPredicate : IPredicate<int>

    {

        private int _nTarget;

        public bool Match(int nValue)

        {

            return nValue == _nTarget;

        }

    }

}

 

namespace Item20NS

{

    /// <summary>

    /// The following two classes illustrate how to use functions as parameters to separate algorithms

    /// from the specific data types on which they operate.

    /// </summary>

    public class Utility

    { 

        /// <summary>

        /// This version of CreateSequence contains the logic to create the sequence

        /// based on the given parameters. Compare this method with CreateSquence2

        /// </summary>

        static public IEnumerable<int> CreateSequence(int nCount, int nStart, int nStep)

        {

            for (int i = 0; i < nCount; i++)

                yield return nStart + (i * nStep);

        }

 

        /// <summary>

        /// Improved on CreateSequence method above by taking a function parameter to specify

        /// how the sequence should be generated

        /// </summary>

        static public IEnumerable<T> CreateSequence_V2<T>(int nCount, Func<int, T> generator)

        {

            for (int i = 0; i < nCount; i++)

                yield return generator(i);

        }

    }

 

    public class Math

    {

        static public int Sum(IEnumerable<int> sequence)

        {

            int nTotal = 0;

            foreach (int nItem in sequence)

                nTotal += nItem;

 

            return nTotal;

        }

 

        static public T Sum_V2<T>(IEnumerable<T> sequence, Func<T, T, T> accumulator)

        {

            if (accumulator == null) return default(T);

 

            T total = default(T);

            foreach (T item in sequence)

                total = accumulator(item, total);

 

            return total;

        }

    }

}

namespace Item21DoNotUse

{

    /// <summary>

    /// Any methods having the same name should perform essentially the same function. For example,

    /// the 2 Add() methods should do the same thing. However, because the two Add() methods do

    /// semantically different things, then they should have different names. Therefore, when

    /// overloading methods, different overloaded methods should provide different parameter lists,

    /// never different actions.

    ///

    /// Ambiguity problems arise when methods have similar arguments and the compiler must make a

    /// choice. In the simplest case, there is only one parameter for any of the possible overloads

    /// for the Scale() methods. By creating all these overloads, you have avoided introducing any

    /// ambiguity. You probably wonder why all those Scale() overloads were not replaced with a

    /// single generic method. That's because C# generics don't support that practice in the way

    /// C++ templates do. With C# generics, you can't assume that arbitrary methods or operators

    /// are present in the type parameters (the only methods that are available are those of

    /// System.Object). You must specify your expectations using constraints. Of course, you might

    /// think about using delegates to define a method constraint. But in this case, that technique

    /// only moves the problem to another location in the code where both the type parameter and the

    /// delegate are specified.

    /// </summary>

    public class Vector

    {

        private List<double> values = new List<double>();

 

        /* ADD */

        // Add a value to the internal list.

        public void Add(double number)

        {

            values.Add(number);

        }

 

        // Add values to each item in the sequence.

        public void Add(IEnumerable<double> sequence)

        {

            int index = 0;

            foreach (double number in sequence)

            {

                if (index == values.Count)

                    return;

                values[index++] += number;

            }

        }

 

        /* SCALE */

        public void Scale(short scaleFactor)

        {

            for (int index = 0; index < values.Count; index++)

                values[index] *= scaleFactor;

        }

 

        public void Scale(int scaleFactor)

        {

            for (int index = 0; index < values.Count; index++)

                values[index] *= scaleFactor;

        }

 

        public void Scale(float scaleFactor)

        {

            for (int index = 0; index < values.Count; index++)

                values[index] *= scaleFactor;

        }

 

        public void Scale(double scaleFactor)

        {

            for (int index = 0; index < values.Count; index++)

                values[index] *= scaleFactor;

        }

    }

 }

namespace Item23NS

{

    public class MyEventArgs : EventArgs

    {

        private bool _bCancel;

        public bool Cancel

        {

            get { return _bCancel; }

            set { _bCancel = value; }

        }

    }

 

    /// <summary>

    /// MyClass contains the OnStart event whos argument type (MyEventArgs) contains a Cancel

    /// flag. Suppose that there are multiple subscribters to OnStart; One subscriber might request

    /// a cancel, and the second might reverse that request. The foregoing definition does not

    /// guarantee that this behavior can't happen. Having multiple subscribers and a mutable event

    /// argument means that the last subscriber in the chain can override every other subscriber.

    /// There's no way to enforce having only one subscriber, and there is no way to guarantee that

    /// you're the last subscriber. You could modify the event arguments Cancel flag to ensure that

    /// once the cancel flag is set, no subscriber can turn it off (see MyEventArgs2)

    /// </summary>

    public class MyClass

    {

        private event EventHandler<MyEventArgs> OnStart;

 

        public void RunProcess()

        {

            // Add code to run some specific process

            // ...

 

            // Let all subscribers know that a process has been started

            MyEventArgs args = new MyEventArgs();

            args.Cancel = false;

            if (OnStart != null)

            {

                // Fires event on each subscriber that has a handler for this event

                OnStart(this, args);

            }

 

            // Cancel process if a user sets MyEventArgs.Cancel to true

            // But what if one user sets MyEventArgs.Cancel to true and then

            // another user sets it to false? See MyEVentArgs2 class

            if (args.Cancel == true)

            {

                // Add logic to cancel process

            }

        }

    }

 

    /// <summary>

    /// Improves on MyEventArgs class by ensuring that once the Cancel flag is set to true, no subscriber

    /// can reset it back to false. Note the use of assymetric accessor on Cancel's set property.

    /// </summary>

    public class MyEventArgs2 : EventArgs

    {

        private bool _bCancel;

        public bool Cancel

        {

            get { return _bCancel; }

            private set { _bCancel = value; }

        }

 

        public void CancelRequest()

        {

            Cancel = true;

        }

    }

}

internal class Item24

{

    internal void TestEvents1()

    {

        // Hook up events

        EventDemo ob = new EventDemo();

        ob.OnProgress1 += new delProgress(ob_OnProgress1);

        ob.OnProgress2 += new delProgress(ob_OnProgress2);

 

        // Call methods on 'ob' to fire events

        ob.ShowProgress1();

        ob.ShowProgress2();

    }

 

    internal void TestVirtualEvents()

    {

        // Static type is P. Run-time type is D

        D derived = new D();

        P parent = derived;

 

        // Hook up handlers for case1_event through derived and parent classes

        parent.case1_event += new EventHandler(parent_case1_event);

        derived.case1_event += new EventHandler(derived_case1_event);

 

        // Fire both events. Note the following:

        // The compiler does not generate a protected backing field on the parent class P. Instead, it

        // generates two private backing fields - one in P and one in D. Secondly, when we execute both

        // functions below, we'll see that it is the derived delegate field that gets both of the handlers

        // hooked up to it.

        derived.DerivedCase1Event();    // Calls derived_case1_event() and parent_case1_event() handlers

        parent.ParentCase1Event();      // Calls nothing as parent.case1_event is null

 

        // Using workaround

        derived.RaiseCase1Event();

        parent.RaiseCase1Event();

    }

 

    void derived_case1_event(object sender, EventArgs e)

    {

        Trace.WriteLine("derived_case1_event");

    }

 

    void parent_case1_event(object sender, EventArgs e)

    {

        Trace.WriteLine("parent_case1_event");

    }

 

    void ob_OnProgress2(double dPercent)

    {

        Trace.WriteLine("ob_OnProgress2");

    }

 

    void ob_OnProgress1(double dPercent)

    {

        Trace.WriteLine("ob_OnProgress1");

    }

}

 

namespace Item24NS

{

    internal delegate void delProgress(double dPercent);

 

    /// <summary>

    /// Conceptually, an event is a pair of methods: add accessor and remove accessor.

    /// Each method takes a single parameter of a specific delegate type. 'add' and

    /// 'remove' accessors are invoked via 'e+=d' and 'e-=d' expressions, respectively.

    /// </summary>

    internal class EventDemo

    {

        // _del is a reference type of type delProgress

        private delProgress _del;

 

        // Declare the OnProgress1 event using field-like syntax. In this syntax, the

        // event is declared with no add or remove accessors. The compiler automatically

        // generates default accessors (similar to those that were manuall defined for

        // OnProgress2 event), and add an anonymous private delegate that stores the

        // invocation list for the event

        internal event delProgress OnProgress1;

 

        // Declare the OnProgress2 event using manual syntax. With this syntax,

        // it is obvious that events are similar to properties, except that both

        // accessors (add and remove) must always be present

        private object _obLock = new object();

        internal event delProgress OnProgress2

        {

            add

            {

                lock (_obLock) { _del += value; }

            }

            remove

            {

                lock (_obLock) { _del -= value; }

            }

        }

 

        // Public inteface

        public void ShowProgress1()

        {

            // OnProgress1 is a field-like event, but the following calls refer

            // not to the event itself, but to the anonymous private delegate

            // created by the compiler.

            if (OnProgress1 != null)

                OnProgress1(0.1);

        }

 

        public void ShowProgress2()

        {

            // OnProgress2 event was created manually. Note here that unlike

            // OnProgress1 event, we have to use the underlying delegate for

            // OnProgress2 event

            if (_del != null)

                _del(0.3);

        }

    }

 

    internal class DerivedEventDemo : EventDemo

    {

        public void ShowProgress1FromDerived()

        {

            // The following code does not compile because the derived class does

            // not have access to the compiler-generated private anonymous delegate

            // Error: The event 'MoreEffectiveCS.Design.Item24NS.EventDemo.OnProgress1'

            // can only appear on the left hand side of += or -= (except when used from

            // within the type 'MoreEffectiveCS.Design.Item24NS.EventDemo')

            /*

            if (base.OnProgress1 != null)

                base.OnProgress1(0.5);

            */

        }

    } 

}

 

namespace Item24NS2

{

    /// <summary>

    /// Consider a parent class P which declares a virtual event, and some derived

    /// class D which overrides it. Note that there are four combinations with respect

    /// to usage of field-like or user-defined syntaxes:

    ///     1. P declares a field-like event. D declares a field-like event

    ///     2. P declares a field-like event. D declares a user-defined event

    ///     3. P declares a user-defined event. D declares a field-like event

    ///     4. P declares a user-defined event. D declares a user-defined event

    ///    

    /// </summary>

    class P

    {

        // P contains an automatically-generated private delegate field backing case1_event,

        // and two virtual accessors that add and remove from the delegate

        public virtual event EventHandler case1_event;

 

        // P contains an automatically-generated private delegate field backing case2_event,

        // and two virtual accessors that add and remove from the delegate

        public virtual event EventHandler case2_event;

 

 

        public virtual event EventHandler case3_event

        {

            add { }

            remove { }

        }

        public virtual event EventHandler case4_event

        {

            add { }

            remove { }

        }

 

        public void ParentCase1Event()

        {

            // case1_event will be null!

            if (case1_event != null)

                case1_event(this, null);

        }

 

        public virtual void RaiseCase1Event()

        {

            if (case1_event != null)

                case1_event(this, null);

        }

    }

 

    class D : P

    {

        // D.case1_event contains two overriding accessors, who add and remove from the delegate

        // contained in P. Notice that for this to work, the delegate in P must be elevated from

        // private to protected

        public override event EventHandler case1_event;

 

        // D does not have access to P.case2_event's backing field.

        public override event EventHandler case2_event

        {

            add { }

            remove { }

        }

 

        // D has a backing field generated for case3_event, which is private

        public override event EventHandler case3_event;

 

        // This is just the typical virtual/override pattern.

        public override event EventHandler case4_event

        {

            add { }

            remove { }

        }

 

        public void DerivedCase1Event()

        {

            if (case1_event != null)

                case1_event(this, null);

        }

 

        public override void RaiseCase1Event()

        {

            if (case1_event != null)

                case1_event(this, null);

        }

    }

}

class Item25

{

    public void DoNotPromoteThisPattern()

    {

        OrderManager om = new OrderManager();

        try

        {

            om.ProcessOrder(10);

        }

        catch (Exception ex)

        {

            Trace.WriteLine(ex.Message);

        }

    }

 

    public void PromoteThisPattern()

    {

        OrderManager om = new OrderManager();

        try

        {

            if (!om.TryProcessOrder(10))

            {

                Trace.WriteLine("Order is invalid");

            }

        }

        catch (Exception ex)

        {

            Trace.WriteLine(ex.Message);

        }

    }

}

 

namespace Item25NS

{

    /// <summary>

    /// This pattern requires you to write four methods: two public methods, and two private methods.

    /// The TryProcessOrder() method validates all input parameters and any internal object state

    /// necessary to perform the work. Then it calls the DoProcessOrder() method to perform the task.

    /// ProcessOrder() simply calls the DoProcessOrder() method and lets any failures generate exceptions.

    /// This idiom is used in .NET because there are performance implications involved in throwing

    /// exceptions, and developers may wish to avoid those costs by testing conditions before allowing

    /// methods to fail.

    /// </summary>

    class OrderManager

    {

        #region Public interface

        public void ProcessOrder(int nOrderID)

        {

            DoProcessOrder(nOrderID);

        }

 

        public bool TryProcessOrder(int nOrderID)

        {

            // Is the order valid

            if (!IsOrderValid(nOrderID)) return false;

 

            // We have a valid order. Process the order

            DoProcessOrder(nOrderID);

            return true;

        }

        #endregion

 

        #region Helpers

        /// <summary>

        /// Processes an order. Throws exceptions if it fails.

        /// </summary>

        private void DoProcessOrder(int nOrderID)

        {

            // Do we have a valid order ID

            if (nOrderID == -1)

                throw new InvalidOperationException("Received invalid order ID");

 

            // Continue processing order

            // ...

        }

 

        /// <summary>

        /// Checks that an order exists

        /// </summary>

        private bool IsOrderValid(int nOrderID)

        {

            // Do we have a valid order ID

            if (nOrderID == -1) return false;

 

            // Check order against database

            // ...

            return true;

        }

        #endregion

    }

}