.NET 4.0 introduced several new features including named and optional arguments, the dynamic type, covariance and contravariance, and improvements to the dynamic language runtime. Optional arguments allow omitting parameter values and using defaults. Named arguments specify parameters by name rather than position. The dynamic type acts as a placeholder known only at runtime. Covariance and contravariance define assignment compatibility for generic types. The dynamic language runtime was enhanced with expression trees to represent code semantics, call site caching, and interfaces for dynamic object interoperability.

1. .NET 4.0 FEATURES

2. NAMED AND OPTIONAL ARGUMENTS
Optional Arguments:
 Optional arguments enable you to omit arguments for some parameters.
 When a function has an optional parameter, the caller can decide whether to
provide a value or not.
 If the caller doesn't provide a value, the function uses a default value.

3. Named Arguments:
 Named arguments enable you to specify an argument for a particular
parameter by associating the argument with the parameter's name
rather than with the parameter's position in the parameter list.
 Named arguments free you from the need to remember or to look
up the order of parameters in the parameter lists of called methods.
Calculate(weight: 123, height: 64);

4. Dynamic:
 Dynamic is a new static type that acts like a placeholder for a type
not known until runtime.
 At compile time, an element that is typed as dynamic is assumed to
support any operation.
Ex:
dynamic dynamic_ec = new ExampleClass();
// The following line is not identified as an error by the
// compiler, but it causes a run-time exception.
dynamic_ec.exampleMethod1(10, 4);
//no method with two parameters

5. VAR DYNAMIC
Introduced in C# 3.0 Introduced in C# 4.0
Statically typed – This means
the type of variable declared is
decided by the compiler at
compile time.
Dynamically typed - This
means the type of variable
declared is decided by the
compiler at runtime time.
Need to initialize at the time
of declaration.
No need to initialize at the
time of declaration.
Errors are caught at compile
time.
Errors are caught at runtime
Visual Studio shows
intellisense since the type of
variable assigned is known to
compiler.
Intellisense is not
available since the type and its
related methods and
properties can be known at run
time only

6. Reflection Dynamic
Inspect (meta-data) Yes No
Invoke public members Yes Yes
Invoke private members Yes No
Caching No Yes
Static class Yes No

7. Covariance and Contravariance:
Covariance:
 Covariance preserves assignment compatibility.
 An object of a more derived type is assigned to an object of a less
derived type.
Contravariance:
 An object that is instantiated with a less derived type argument
is assigned to an object instantiated with a more derived type
argument.
 Assignment compatibility is reversed.

8. // Assignment compatibility.
string str = "test";
// An object of a more derived type is assigned to an object of a less derived type.
object obj = str;
// Covariance.
IEnumerable<string> strings = new List<string>();
IEnumerable<object> objects = strings;
// Contravariance.
// Assume that the following method is in the class:
// static void SetObject(object o) { }
Action<object> actObject = SetObject;
Action<string> actString = actObject;

9. Dynamic Language Runtime:
 The dynamic language runtime (DLR) is a runtime environment that
adds a set of services for dynamic languages to the common
language runtime (CLR).
 The DLR makes it easier to develop dynamic languages to run on the
.NET Framework and to add dynamic features to statically typed
languages.
 Dynamic languages can identify the type of an object at run time,
whereas in statically typed languages such as C# and Visual Basic
you must specify object types at design time.
 Examples of dynamic languages are Lisp, Smalltalk, JavaScript, PHP,
Ruby, Python, ColdFusion, Lua, Cobra, and Groovy.

11. Expression Trees:
 The DLR uses expression trees to represent language semantics. For this
purpose, the DLR has extended LINQ expression trees to include control flow,
assignment, and other language-modeling nodes.
Call Site Caching:
 A dynamic call site is a place in the code where you perform an operation on
dynamic objects.
 The DLR caches the characteristics of a and b (usually the types of these
objects) and information about the operation.
Dynamic Object Interoperability:
 The DLR provides a set of classes and interfaces that represent dynamic
objects and operations and can be used by language implementers and
authors of dynamic libraries.

12. int Fibonacci(int n)
{
if (n < 1)
{
return 1;
}
else
{
return Fibonacci(n ‐ 1) + Fibonacci(n ‐ 2);
}
}