C# Features From 3.0 to 6.0

C# 3.0 features

1. Var keyword:
   
   Implicitly typed local variable. Need to initialize at the time of declaration. The data type of a ‘var’ variable will be determined when assigning values to variables. After assigning the variable value, the variable has a defined data type and cannot be replaced.
   
   E.g.
   
   1. var abc=1;
2. Auto Properties:
   
   Auto implemented properties.
   
   E.g.
   
   1. Public stirng Name {get; set;}
3. Anonymous Types:
   
   An anonymous type is a simple class created on the fly to store a set of values. To create an anonymous type, you use the new keyword followed by an object initializer, specifying the properties and values the type will contain.
   
   E.g.
   
   1. var EmpName= new {Name=”FirstName”, Age=20};
4. Extension Methods:
   
   Extension methods allow an existing type to be extended with new methods, without altering the definition of the original type. An extension method is a static method of a static class, where the “this” modifier is applied to the first parameter. The type of the first parameter will be the type that is extended.
   
   E.g.
   
   1. public static class ABC
   2. {
   3. public static int ChangeData(this string str)
   4. {
   5. return int.Parse(str);
   6. }
   7. }
5. Lambda Expressions:
   
   A lambda expression is an unnamed method written in place of a delegate instance.
   
   A lambda expression has the following form:
   
   (parameters) => expression-or-statement-block
   
   E.g.
   
   1. X=> x*x;

C# 4.0 features

1. Named and Optional Parameters:
   
   Optional Parameters:
   
   Optional parameters allows you to give a method parameter a default value so that you do not have to specify it every time you call the method. This comes in handy when you have overloaded methods that are chained together.
   
   E.g.
   
   1. public void Process( string data, bool IsAllowed = false, ArrayList data = null )
   2. {
   4. }
   The following statements are valid:
   
   1. Process(“Rakesh”);
   2. Process(“Rakesh”, true);
   3. Process(“Rakesh”,true,list); (where list is the object of List)
   Named Parameters:
   
   1. Process(“Rakesh”,list);
   Above statement is invalid as we have omitted 2nd bool parameter. But we can use the following method using named parameters feature.
   
   1. Process(“Rakesh”, data:list);
2. Dynamic:
   
   Dynamic are dynamically typed variables. No need to initialize the dynamic variables at time of declaration. Dynamic variables can be used to create properties and return values from a function. The following syntax is valid using dynamic.
   
   1. dynamic data=100;
   2. data=”Welcome to C#”;
3. Co-Variance and Contra-Variance:
   
   Co-Variance:
   
   Co- variance preserves assignment compatibility between parent and child during dynamic polymorphism.
   
   E.g.
   
   The following syntax is possible in C# 4.0:
   
   1. Public class Animal
   2. {}
   4. Public class Cat: Animal
   5. {}
   7. Public class Program
   8. {
   9. Public static void main()
   10. {
   11. IEnumerable < Animal > animals = new List < Cat > (); // not valid in earlier C# versions
   12. }
   13. }