1. Decorator Pattern
2. Proxy Pattern
3. Bridge Pattern
4. Composite Pattern
5. Flyweight Pattern
6. Adapter Pattern
7. Façade Pattern

In the following posts to come, I will write about the Creational Patterns.

    1 public class GenericClone
    2 {
    3     public T DeepClone<T>() where T : class
    4     {
    5         object cloned = new object();
    6         BinaryFormatter formatter = new BinaryFormatter();
    7         using (MemoryStream stream = new MemoryStream())
    8         {
    9             formatter.Serialize(stream, this);
   10             stream.Flush();
   11             stream.Position = 0;
   12             cloned = formatter.Deserialize(stream);
   13         }
   14 
   15         return cloned as T;
   16     }
   17 }
   18 
   19 class Test
   20 {
   21     GenericClone getClone = new GenericClone();
   22     public void Clone()
   23     {
   24         Test deeptest = getClone.DeepClone<Test>();
   25     }
   26 }

Thing to note here is that the class which needs to be cloned has to be marked as Serializable for this method to work. To create a clone of a class we just have to create an object of the GenericClone class and call the DeepClone method as in the Test class. The problem here is that we need to have an object of the GenericClone class before we can clone the object. With C# 3.0, now we can write an extension method for the cloning process and call it on the object itself. Here is an example.

    1 public static class ExtensionClone
    2 {
    3     public static T DeepClone<T>(this object obj) where T : class
    4     {
    5         object cloned = new object();
    6         BinaryFormatter formatter = new BinaryFormatter();
    7         using (MemoryStream stream = new MemoryStream())
    8         {
    9             formatter.Serialize(stream, obj);
   10             stream.Flush();
   11             stream.Position = 0;
   12             cloned = formatter.Deserialize(stream);
   13         }
   14 
   15         return cloned as T;
   16     }
   17 }
   18 
   19 class Test
   20 {
   21     public void Get()
   22     {
   23         Test cloned = this.DeepClone<Test>();
   24     }
   25 }

As you can see this is a much cleaner way of cloning the object. I don't have to create an object of the ExtensionClone class to get my cloned object.

Extension Methods

Prior to C# 3.0, the only way to update member information of a compiled type, was to recode and recompile the code. But now with extension methods we can allow compiled type to obtain new functionality. This is immensely helpful  when you want to add functionality to a third party type where you are not allowed to change the code. When you create an extension method, it actually behave as if it was part of the original type. Lets see an example.

    1 class Extensions
    2 {
    3     public void DoSometing()
    4     {
    5         string originalString = "EXTENSIONS";
    6         string reversedString = originalString.Reverse();
    7 
    8         Console.WriteLine(originalString); //EXTENSIONS
    9         Console.WriteLine(reversedString); //SNOISNETXE
   10     }
   11 }
   12 
   13 public static class ExtensionClass
   14 {
   15     public static string Reverse(this string str)
   16     {
   17         char[] chr = str.ToCharArray();
   18         Array.Reverse(chr);
   19         return new string(chr);
   20     }
   21 }

LINQ

Language INtegrated Query(LINQ) enables you to write queries against objects. You can query against any object that implements the IEnumerable<T> interface. All queries are converted into method calls to the Enumerable class. This class contains extension methods that can be applied to any object that implements IEnumerable. Lets see an example.

    1 class LINQ
    2 {
    3     public void SelectFromList()
    4     {
    5         var list = new List<string> { "a", "b", "c", "d", "e" };
    6 
    7         var str = from s in list
    8                   where s.Contains("a")
    9                   select s;
   10 
   11         var str1 = list.Where(s => s.Contains("a")).Select(s => s);
   12 
   13     }
   14 }

Here the first LINQ statement is using a query syntax and the second is using a method syntax. The method syntax uses a lambda expression with Where and Select extension methods. These two LINQ statements are the same and gives out the same result.

Type Inference

When we are using type inference which was introduced in C# 3.0, the compiler determines the type of the variable at compile time. Here is an example of type inference.

    1 public class TypeInference
    2 {
    3     var globalStr = "Hello C# 3.0"; //Compile time error.
    4                               //The contextual keyword 'var' may 
    5                               //only appear within a local variable declaration
    6 
    7     public void TypeInferenceMethod()
    8     {
    9         var msg = "Hello C# 3.0"; //string
   10         var offset = 0; // int
   11 
   12         var temp; //Compile time error.
   13                   //Implicitly-typed local variables must be initialized
   14         temp = "Error";
   15     }
   16 }

Here the variable msg will be of type string and offset will be of type int. You have to note that these variables have to be initialized and can only be used as local variables or else you will get a compile time error as is the case with globalStr and temp.

Anonymous types 

Anonymous types are useful when we need to create an object of a class and initialize it without having a concrete class. Let me explain this with an example.

    1 public class AnonymousType
    2 {
    3     public void AnonymousTypeMethod()
    4     {
    5         var product = new { Id = 1, Name = "Product1" };
    6     }
    7 }

Here we create a type product with properties Id an Name. The good thing about this code is that there is no Product class present. The variable product does have a type though but we don't know its name. We just get a class with properties Id and Name already initialized. 

Lambda Expressions

Lambda expressions are a refined way of defining your methods. Anonymous methods were introduced in C# 2.0 which helped us to declare a method inline which was much simpler than the earlier version ( will show an example shortly ). Then came lambdas in C# 3.0 which took anonymous methods to a different level. Lets look at an example of all 3 forms.

    1 class Lambdas
    2 {
    3     //1. Using delegates
    4     static void UsingDelegate()
    5     {
    6         List<int> intList = new List<int> { 1, 2, 4, 5, 6 };
    7         Predicate<int> getEvenNumbers = new Predicate<int>(IsEven);
    8         List<int> evenNumbers = intList.FindAll(getEvenNumbers);
    9     }
   10 
   11     static bool IsEven(int i)
   12     {
   13         return (i % 2) == 0;
   14     }
   15 
   16     //2. Using anonymous methods
   17     static void UsingAnonymousMethod()
   18     {
   19         List<int> intList = new List<int> { 1, 2, 4, 5, 6 };
   20         List<int> evenNumbers =
   21             intList.FindAll(
   22                     delegate(int i)
   23                     {
   24                         return (i % 2) == 0;
   25                     }
   26                 );
   27     }
   28 
   29     //3. Using lambdas
   30     static void UsingLambdas()
   31     {
   32         List<int> intList = new List<int> { 1, 2, 4, 5, 6 };
   33         List<int> evenNumbers = intList.FindAll(i => (i % 2) == 0);
   34     }
   35 }

Here I have written 3 methods which basically creates an integer list and finds out all even numbers in it. The first method is done using the traditional delegate pattern. Here we create a predicate pointing to a method which checks for a number to be even. Then we call the FindAll method for the list and pass this predicate to get the list of even numbers. As you can see the IsEven method might not be used outside the scope of this method. To solve this issue C# introduced anonymous methods. In anonymous methods we can declare the method inline as can be seen the example. This saves us from writing a different method. When you look at the third method we see that a single line of code is doing all the work. In fact  i => (i % 2) == 0 is all that is needed to do the functionality that our predicate or delegate did. Lambda expression are internally converted into anonymous delegates. Just a quicker and neat way of doing things.

    1 public class AutoProp
    2 {
    3     public string AddedBy { get; set; }
    4     public DateTime AddedDate { get; set; }
    5 
    6     public int ViewCount { get; private set; }
    7 
    8     //Normal way of defining property
    9     private int id;
   10     public int Id
   11     {
   12         get { return id; }
   13         set { id = value; }
   14     }
   15 }

    1 public class Product
    2 {
    3     public int Id { get; set; }
    4     public string Name { get; set; }
    5 }
    6 
    7 public class ObjectInit
    8 {
    9     public void SetProduct()
   10     {
   11         //Normal way
   12         Product prod = new Product();
   13         prod.Id = 1;
   14         prod.Name = "Product1";
   15 
   16         //New way
   17         Product newProd = new Product() { Id = 2, Name = "Product2" };
   18     }
   19 }