delegate void Print (string s); 
 Print delegateVariable = new Print(realMethod); 
 public void realMethod (string myString)
 {
 MessageBox.Show(myString);
  }

public delegate void Print (string s); 
Print delegateVariable = delegate (string myString) 
{MessageBox.Show(myString) ;};

public delegate void Print (string s); 
Print delegateVariable = delegate 
{MessageBox.Show(myString) ;};

 static my Delegate myFunc()
 {
 int x=0;
 myDelegate result = delegate {return ++x;}
 return result;
 }

// File: MyClassP1.cs
public partial class MyClass
{
    public void method1() 
    {
    }
}
// File: MyClassP2.cs
public partial class MyClass
{
    public void method2() 
    {
    }
}

         Using the partial keyword indicates that other parts of the class, struct, or interface can be defined within the namespace. All the parts must use the partial keyword. All of the parts must be available at compile time to form the final type. All the parts must have the same accessibility (public, private, etc).
        If any of the parts are declared abstract, then the entire type is considered abstract. If any of the parts are declared sealed, then the entire type is considered sealed. If any of the parts declare a base type, then the entire type inherits that class.
       All of the parts that specify a base class must agree - but parts that omit a base class still inherit the base type. Parts can specify different base interfaces, and the final type implements all of the interfaces listed by all of the partial declarations. Any class, struct, or interface members declared in a partial definition are available to all of the other parts - the final type is the combination of all the parts at compile time.

•	Nested types can be partial, even if the type they are nested within is not partial itself. For example:

class Container
{
    partial class Nested
    {
        int i;
    }
    partial class Nested
    {
        int j;
    }
}
•	Nested partial types are allowed in partial type-definitions, for example:


partial class MyClass 
{
   partial class NestedClass {}
}
partial class MyClass
{
   partial class NestedClass {}
}

Some on partial classes Restrictions

There are several rules to follow when working with partial class definitions:
•	All partial-type definitions meant to be parts of the same type must be modified with partial. For example, the following class declarations generate an error: 
partial public class A { } 
public class A { }   // Error, must be marked partial



•	All partial-type definitions meant to be parts of the same type must be defined in the same assembly and the same module (.exe or .dll file). Partial definitions cannot span multiple modules.
•	The class name and generic-type parameters must match on all partial-type definitions. Generic types can be partial. Each partial declaration must use the same parameter names in the same order.
•	The following keywords on a partial-type definition are optional, but if present on one partial-type definition, cannot conflict with the keywords specified on another partial definition for the same type: 
•	public 
•	private 
•	protected 
•	internal 
•	abstract 
•	sealed 
•	base class
•	new modifier (nested parts)
•	generic constraints
Nullable Types:

              A variable of nullable type can represent all the values of its underlying type, plus an additional null value. This is particularly useful when dealing with databases and other data types containing elements that may not be assigned a value, or which may not exist. For example, a Boolean field in a database can store the values true or false, or it may contain neither true nor false.




Nullable Types have the following properties:
•	Nullable types are used to create variables that can contain an undefined        state.
•	The syntax T? is shorthand for System.Nullable, where T is a data type. The two forms are interchangeable.
•	The HasValue property returns true if the variable contains a value, or false if it is null.
•	The Value property returns a value if one is assigned, otherwise a System.InvalidOperationException is thrown.
•	The default value for a nullable type variable sets HasValue to false. The Value is undefined.

Summary


      In this i article i explained 3 new features in c#2.0