.NET 3.0 & 3.5 New Features

.NET 3.0 & 3.5 New Features

There are many features like Auto implemented property. Anonymous types, Partial methods, object initializes, implicitly typed local variables.

Auto Implemented Property

The property plays a significant role to set and get the values. In the previous versions we were doing like need to set the values to the temporarily local variable. Now that work exactly reduced in the .NET 3.0 version. Because it will be implicitly handled by the .Net compiler

Syntax :

[Access modifier] data type [Name of property]
{
    get {  };
    set {  };
}

For example we are going to create one property for send email

public string FromID {get; set ;}
public string ToID {get; set ;}
public string Subject {get; set ;}
public string Message {get; set ;}

In previous version we have done like this.

private string fname;
public string FirstName
{
    get
    {
       return fname
    }
    set
    {
       fname = value;
    }
}

Here in .NET 3.0, it became auto implemented property, that means in the runtime it will put one temp variable for assigning the values by the compiler.

Implicit Typed local variable

The new data type introduced in the .NET 3.0. Normally when you store the elements in the string with the integer value we need to do the type casting. The variable that will be declared with the var keyword and it will be inferred by the compiler at the time of execution.

var Total = 10 + 10;
var iTotal = 10 + 15.5;
var Name = "deepak" + "dwij";
var Name = "deepak" + 10;

It can be used to create an array in the similar way.

There are some restrictions while using this feature

1. We cannot do the increment and decrement operation like i++ or ++i .
2. We cannot declare the NULL value to the var variable.
3. It use be declare and initialize on the same statement in the local scope.
4. We cannot initialize the multiple var variables like others. Int I, j, k;.
5. We can't use the static keyword.

Implicitly Typed Arrays

var numbers = new[] { 1, 2, 3, 4, 5};
var names = new[] { "Deep", Doug, "Jim" };

Anonymous Types

An anonymous type is one of the new features introduced in the .NET 3.0 version. It is a read only property and can be used to assign the set of names constants with the values. These values cannot be changed the outside Anonymous type.

var Names = new
{
     FirstName = "deepak",
     LastName = "dwij",
     Age = "25"
};

It can be accessed with the following:

string fname = Names.FirstName;

Normally when we define in the enum, there we cannot assign any values.

It will take the order from 0 and will be incremented by one for the every constants in the enum list.

Here the value can be assigned.

Extension Methods(3.5 new feature)

Declaring Extension Methods:- We can create the extension of any existing method.Extension method behavior is similar to that of static methods.

You can declare them only in static classes. To declare an extension method, you specify the keyword this as the first parameter of the method, for example:

// Program.cs
public static class EMClass
{
    public static int ToInt32Ext(this string s)
    {
      return Int32.Parse(s);
    }
    public static int ToInt32Static(string s)
    {
      return Int32.Parse(s);
    }
}
class Program
{
   static void Main(string[] args)
   {
    string s = "9";
    int i = s.ToInt32Ext(); // LINE A
    Console.WriteLine(i);
    int j = EMClass.ToInt32Static(s); // LINE B
    Console.WriteLine(j);
    Console.ReadLine();
   }
}

As you can see from the above snippet, the differences between the extension method (ToInt32Ext) and the regular static method (ToInt32Static) are the following:

1. Extension methods have the keyword this before the first argument. Static methods do not have the this keyword in its argument declaration.
2. When extension methods are consumed, the argument that was declared with the keyword this is not passed. In the above code, Line A is an example of consuming the extension method ToInt32Ext. No argument is passed to it. When static methods are consumed, no arguments are skipped. All expected arguments must be entered. Line B is an example of this.
3. Extension methods can be defined only in a static class. For static methods, this is not a requirement. Static methods can exist in a regular class as well as in a static class.
4. Extension methods can be called only on instances values.

Object and Collection Initializers

.NET 3.0 is expected to allow you to include an initializer that specifies the initial values of the members of a newly created object or collection. This enables you to combine declaration and initialization in one step.

For instance, if you defined a Co-Ordinate class as follows:

public class CoOrdinate
{
     public int x ;
     public int y;
}

You then could declare and initialize a CoOrdinate object using an object initializer, like this:

var myCoOrd = new CoOrdinate{ x = 0, y= 0} ;


List<string> animals = new List<string>();
animals.Add("monkey");
animals.Add("donkey");
animals.Add("cow");
animals.Add("dog");
animals.Add("cat");

Now can be shortened to simply:

List<string> animals = new List<string> {
"monkey", "donkey", "cow", "dog", "cat" } ;

Lambda Expressions: The Espresso of Anonymous Methods

A lambda expression is an anonymous function that can contain expressions and statements, and can be used to create delegates or expression tree types. Lambda Expressions provide a more concise, functional syntax for writing anonymous methods.

All lambda expressions use the lambda operator =>, which is read as "goes to".

Earlier:

class Program
{
   delegate void DemoDelegate();
   static void Main(string[] args)
   {
      DemoDelegate myDelegate = new DemoDelegate(SayHi);
      myDelegate();
   }
  void SayHi()
  {
     Console.Writeline("Hi Deepak!!") ;
   }
}

In 2.0(Annonymous method)

class Program
{
  delegate void DemoDelegate();
  static void Main(string[] args)
   {
    DemoDelegate myDelegate = delegate()
     {
       Console.Writeline("Hi Deepak!!");
     };
    myDelegate();
   }
}

In .NET 3.0

You can write a lambda expression as a parameter list, followed by the => token, followed by an expression or statement block. The above code can now be replaced with the following code:

class Program
{
   delegate void DemoDelegate();
   static void Main(string[] args)
   {
     DemoDelegate myDelegate = () => Console.WriteLine("Hi Deepak!!") ;
     myDelegate();
   }
}