New Features of C # 4.0
The new .NET Framework provides a better approach in terms of language support in C# Development with its version 4.0. With lots more features being added with the version, let us deal with new things in terms of method invocations and COM interoperability. These features enable us to create objects that can even conform to the standards of Dynamic Language Runtime. Some of the features which we would like to focus in this blog post are as follows:
1. Dynamic Lookup
2. Named and optional parameters
3. COM specific interop features
4. Variance
Dynamic Lookup
One of the core features introduced in C# 4.0 is called Dynamic Lookup . The function of the Dynamic Lookup allows one to invoke things dynamically at run time. In Framework 3.5 and lower version, we can create the method and invoke them. When you call object methods, the compiler checks for method are called, and raises an error. This compilation error can be over come with Dynamic Lookup. Using Dynamic Lookup we can call any method or property at runtime, and they are not checked until runtime. Not only method calls, but also field and property accesses, indexer and operator calls and even delegate invocations can be called dynamically. Look at the below scenario and know how each method, property, indexer and operator are called dynamically.
dynamic dyn= GetMyService();
dyn.Method(7); // calling methods
dyn.field = dyn.Property; // getting and settings fields and properties
dyn[“one”] = dyn[“two”]; // getting and setting thorugh indexers
int i = dyn + 3; // calling operators
string str = dyn(5,7); // invoking as a delegate
So at runtime a dynamic operation is called according to the nature of its target object d
Named and optional parameters
Optional arguments are widely used in VB for long time. Now this feature is included in the C # 4.0 too.
Optional arguments allows to omit arguments when calling methods. This is possible by defining a method with assigning default values to parameters.
Define the method mymethod with some default parameters.
public void mymethod(int a, int b = 50, int c = 100);
this method can be expressed in any one of the following way
mymethod(10, 30, 50); as usual calling the method
mymethod(10, 30,); omitting the parameter c
mymethod(10,); omitting the parameters b and c
Named Arguments allows you to pass the arguments by the corresponding parameter names.
myMethod(a:10, b:30, c:50);
The above method can be rewritten as
myMethod(c:50, b:30, a:10);
myMethod(a:10, c:50); // This call Omits the parameter “b”.
COM specific interop features
C# 4.0 Development provides much improved support for COM interoperability, making it far easier to call COM objects in side .NET code. As discussed in the above section, both dynamic lookup and named and optional parameters which help improve the function of interoperating with COM APIs such as the Office Automation APIs.
Variance
One of the core features included in C# 4.0 is called Variance. Variance is a property of operators that act on types or level. Variance can be understood in detail by going through the below scenario of
Covariance and Contra variance.
A variable of a higher level, can hold an instance of small level called Covariance.
Example:
CEO ceo = new CEO();
HOD hod = new HOD();
HOD hod = new CEO();
An instance smaller level is substituted for a higher level. This is called Contra variance.
public void GetSalary(CEO ceo) { }
HOD hod = new HOD();
GetSalary(HOD);