ASP.NET Tech Stuffs

Tuple: Return multiple values from function

2011-12-26T07:39:00.000-08:00

How do you return multiple values from function?

Option 1: use out parameters. But this will just bloat your function signature if the list is long
Option 2: Encapsulate all return values as properties of class and just return the object of that class. But what if that class is not reusable. Will you be just adding the dumb classes to increase assembly size and abusing the OOPs.

Here comes the solution "Tuple" in .NET 4.

By using Tuple type you can return upto 8 items at a time. These items could be value type or reference type.

Actually if you use the instance approach, you can pass a tuple inside Tuple. That means you can return a tuple of any number of items.

There are few points to note though
1. tuple items are read only (there is no set accessor for items). That makes its items immutable.
2. The items can be accessed by using "Item" property. For e.g. to access 2nd item, you have to call myTuple.Item2.

let's take an scenario where you need this kind of structure

 public static Tuple<string,string,string,string> GetAny4ItemsOnMyDesk()
        {
            //Instance approach
            return new Tuple<string, string, string, string>("Laptop", "Phone", "Notebook", "Pen");
 
            //By using static method
            //return Tuple.Create("Laptop", "Phone", "Notebook", "Pen");
 
        }

This is clear in the above example that you will not like to create a dumb class to contain "unrelated" things. Actually Tuple stucture can be used to contain "miscellaneous but related" items.

Now lets print my desk items from Main

static void Main(string[] args)
        {
            var ItemsOnMyDesk = GetAny4ItemsOnMyDesk();
            StringBuilder sb = new StringBuilder();
            sb.Append("Item 1: " + ItemsOnMyDesk.Item1);
            sb.AppendLine();
            sb.Append("Item 2: " + ItemsOnMyDesk.Item2);
            sb.AppendLine();
            sb.Append("Item 3: " + ItemsOnMyDesk.Item3);
            sb.AppendLine();
            sb.Append("Item 4: " + ItemsOnMyDesk.Item4);
            sb.AppendLine();
            Console.WriteLine(sb.ToString());
          
            Console.ReadLine();
 
        }

This will print my 4 items on my desk.

You can use other data structures like keyvaluepair, collection, array etc to serve same purpose. tuple is like anonymous class generated on compile time so its object resides on heap only which gives you struct kind of datastructure out of the box.
Tuple type is widely used in functional language like "Haskell" and dynamic language like "Python. Since it is of finite size and immutable structure, it is faster than list and performs better than keyvaluepair struct when passed to a function (though data retrieval is faster in keyvaluepair).

Thanks for reading.

How to return private collection

2011-07-22T06:10:00.000-07:00

Did you ever try returning a private array like following?

    public class TestPrivateArrays
    {
        private string[] names;
 
        public string[] Names { 
            get
            {
                return names;
            } 
        }
}
            //initialize collection in constructor
            names = new string[] { "Abhishek", "Tiwari" };

And you thought, no one from the external world can modify it? Wrong. Since client still has direct reference of each items of collection/Array, he has full liberty to modify it.

     TestPrivateArrays tpa = new TestPrivateArrays();
     tpa.Names[0] = "Modified"; //my private array gets modified here

So question is whether you can stop your client modifying your array. Answer is yes, you just need to know how to return your collection items as readonly.

1. Return clone of Array

    public class TestPrivateArrays
    {
        private string[] names;
 
        public string[] Names { 
            get
            {
                return (string[])names.Clone();
            } 
        }

You can see, even if client tries to modify the array item, he won't be able to do so. since he is actually modifying a copy of that array but whenever he tries to get the array item, he will get the original one i.e. the unmodified one.

2. Return readonly collection

If you are using .NET generics for e.g. list. You can return the collection as readonly in the following manner.

        private List<string> listNames;
 
        public IList<string> ListNames
        {
            get
            {
                return listNames.AsReadOnly();
            }
        }

            //initialize collection in constructor
            listNames = new List<string> { "Abhishek", "Tiwari" };

Now if user tries to modify the collection, he will get a runtime error saying that collection is readonly (see following).

3. Use some inbuilt readonly collection

you can find a datastructure called ReadOnlyCollection under System.Collections.ObjectModel which is strong typed and templatized. You can use that in following manner.

        private System.Collections.ObjectModel.ReadOnlyCollection<string> colNames;
        public System.Collections.ObjectModel.ReadOnlyCollection<string> ColNames
        {
            get
            {
                return colNames;
            }
        }

            //initialize collection in constructor
            colNames = new System.Collections.ObjectModel.ReadOnlyCollection<string>(new List<string> { "Abhishek", "Tiwari" });

Note that if user tries to modify this collection, he will get compile time error (remember in case of list, it was runtime error because when you modify the list, it evaluates its isReadOnly property at runtime).

Thanks for reading the post.

"toString" method in JavaScript

2011-07-21T07:26:00.000-07:00

Every object in JavaScript has 'toString' method by default. This method returns the representation of that object in string format. If you have ever called alert on an object in mistake, you would have come across this message in alert box '[object, Object]'. Actually when you put alert on object itself, it is assumed that you want to see the internal representation of the object and its 'toString' method is invoked which returns the default string for any object as mentioned before.

So what if you want to make your object representation more meaningful or let say you want to debug your code and just put alert here and there and wants to see what your object looks like at different point of time. Here comes overriding 'toString' method. C#/VB.NET developers, remember yourself overriding toString method of base class "Object". This is exactly similar to that.

Let me take an example as following

function Employee(name, age, company) {
    this.employeeName = name;
    this.age = age;
    this.company = company;
 
    this.toString = function () {
        return "Employee " + this.employeeName + " of age " + this.age +

" working in " + this.company;
    }
}

What I am doing here is
basically forming a meaningful string from my Employee object properties. Now
let me put an alert on employee object.

    <script language="javascript" type="text/javascript">
          window.onload = function () {
            var e = new Employee("Abhishek", "30", "abcSoftware");
            alert(e);
        }
    script>

When I run this code, on
my window onload I get following popup.




As I said before, I can
use this method for debugging purposes or in general conveying a better
representation of my object (for e.g. if you are writing a JS library, you
would like your users to get a meaningful message while putting an alert on
your objects, won't you?)
Note: If you put alert on
function name itself for e.g. alert(Employee), it would be 'toString' method of function type that will be called
and it will print your entire function in the alert box. Try that.
Thanks for reading.

Javascript intellisense in Visual Studio 2010

2011-07-21T03:17:00.000-07:00

Web developers always found difficult to write code when it comes to writing in any scripting language. There are many reasons contributing to it like lack of debugging features, intellisense support, no early catch on errors etc. If you know what editors like Visual Studio gives you for other contemporary strongly typed language (C#, VB.NET etc) you will find difference of an era.

I am an ardent user of Visual Studio and would like to share with you that there are many good features that have been bundled with VS 2010 to support intellisense and debugging for JavaScript. If you know them all, you will surely thank Visual Studio team for making your life easy like never before.

Let me explain some of the intellisense support here.

Type inference in JavaScript

JavaScript is a dynamic language and does not support explicit type declarations, due to which, earlier there used to be a generic pop up showing properties for all types. VS2010 can now infer the type as soon as the assignment happens and shows only relevant properties. See the below example, it is showing the properties applicable to a number.

As you know, being a loose typed language, I can change type of any variable at any time. so what if at some point of time i assign a string to my variable "num".

You can see, now VS intellisense shows me properties only relevant to a string. Great, isn't it!!
Kindly note that it does not matter that you are writing inline scripting or inside an external file. Same intellisense works beautifully at all the places.

You can see above, it now shows the properties of a DOM element only.

Intellisense to Functions

Why you have always been asked to decorate your methods with comments during your code review, it is not just to let others understand more about your functions right there but also to give descriptive knowledge to the consumer of your methods about how that method can be called, what purpose that method serve, information about parameters and returning object etc.
By default, VS can show you the name of the function and input parameter if it is put correctly in the scope.

Let say I have written a method "FOO" in my test.js

I included my test.js correctly in my aspx page and now call the method

You can see, without looking at the external file, I know what parameters "foo" expects and can correctly call it.

Wonder, if you could also add some intellisense hint to your method? check this now.

put a summary block under your function as following. this is written exactly the same way, you write it on top of your C#,VB.NET method. so don't need to remember the template, just copy it from any of your C#/VB code page.

and now let me call the method once again and let the magic continue

Getting intellisense amongst external JS files

Do you feel jittery when you need to call a function but don't know how to exact type it and the function is hidden somewhere under the plethora of JS files you are referring in your page (Javascript is case sensitive) or what if you want to make sure you don't write the function with the same name written elsewhere, or just for the sake of simplicity of coding you want everything under the scope (variable, functions etc) visible infront of you before writing even a single line of code as it happens when you write code in C# (you can see every public/protected/internal/private class/methods in the intellisense as per the scope).

There can be many reasons, you always desired intellisense to be available not just inline but also spanning it across external files as well under the scope. Let me tell you it is fairly possible with VS 2010.

Let say I created a new js file and want to reference my test.js (having function FOO, as explained above). What you need to do, just go drag your test.js into your new javascript file. VS automatically add the reference in following manner

Now you have complete access to everything written in test.js to your new file. You can add as many references as you want in your new file. VS interpreter will automatically discover that file and present you the full intellisense support.

Hope the article would have given you some insight on inbuilt intellisense support of JavaScript in VS. You can explore more on it and be able to write faster code with lesser number of errors.

Happy coding and thanks for reading!

Credit goes to Scott Gu. Reference article: http://weblogs.asp.net/scottgu/archive/2007/06/21/vs-2008-javascript-intellisense.aspx

Beware of Constants

2011-04-20T06:55:00.000-07:00

Let say I have a third party library having code as following

namespace Test

{

public class TestClass

{

public const string NAME = "Abhishek Tiwari";

}

My application uses this library and prints this name on console in following manner

internal class Program

{

private static void Main(string[] args)

{

Console.WriteLine(Test.TestClass.NAME);

Console.ReadLine();

}

After sometime my library provider company is owned by some other company and changes the const value to something public const string NAME = "I am no more Abhishek Tiwari";

Now as being a loyal customer to that company, you get the new version of the library and replace the old version by it and now click on your executable again.

Whack!!! You still see "Abhishek Tiwari" written on the console.

So what happened in the background is mystery for you but before you bang your head here and there in confusion, let me solve this puzzle for you.

Actually when you last built your project, your compiler has put the hard-coded values in place of consts everywhere in your IL so those consts values no more refer to any part of the code whatsoever. If you look into the IL, you will find something like

//My IL (compiled code)

internal class Program

{

private static void Main(string[] args)

{

Console.WriteLine("Abhishek Tiwari");

Console.ReadLine();

}

So even if now I have updated the third party without rebuilding my code (since it is essentially not required) my IL will remain same, and in my IL const "NAME" which was linked to third party is vanished, leaving hard coded const value behind.

Get working code from TestConst

I hope if you are a third party provider, you will keep this in mind to avoid any shock. I am not sure what is the best possible solution for this (will keep you posted, if I come across any) but for now you can change your "const" type by "static readonly" so that your library consumer can always see the modifications.

** Thanks to Shailendra (Author in aspnettechstuffs) for sharing this valuable information with me.

Design By Contracts

2011-04-19T07:02:00.000-07:00

Putting validations all over the places in your code is just like convoluting your code. You must have wondered sometime how good it would be if I could decorate my class with another class at runtime with all the validations. There are certainly options available with latest .NET framework for e.g. you can use injection to add behavior to your classes at runtime. You may use Unity or any other container to do so. If you are design freak, you must have understood that by all means any implementation to provide change in runtime behavior can be done by using "Decorator pattern" only. I will discuss about this in some other article but what I am going to share with you in this article is how to use Code Contracts.

Code contract is something which is already present in the framework 4 under the namespace System.Diagnostic.Contracts and heavily used by .NET internal code for e.g. if you expand ICollection, IComparable etc interfaces you will find them using contracts.

Unfortunately code contracts feature comes by default with Visual Studio Premium and Ultimate edition but if you are using lower version like Professional one, you can still download the external library and make a use of them.

Ok so enough background now let’s jump into the implementation part.

As I said earlier, if you are not using VS 2010 Premium or Ultimate edition, you can download the Code Contract extension from Code Contract Extension

Fair enough, now I am taking a use case where I am providing user a Math divide functionality and I want to make sure that user does not divide the number by zero.

One way I can do it this

public class MathFunctions

{

public double Divide(double number, double divider)

{

Debug.Assert((divider == 0), "cannot divide by zero");

return number / divider;

}

This will make sure that as soon as my client passes zero, he gets an exception. I can implement divide function as

if(divider!=0)

return number / divider;

throw new ArgumentException();

But this is essentially not part of my business logic and henceforth should not be part of my function. Now I need a way to inject the validation at runtime. Let's see how we can do the same using contracts.

Refer System.Diagnostics;System.Diagnostics.Contracts; namespaces in your code.

I now define an interface which will contain the required method signatures. I will decorate this interface with contract so that my compiler could inject the contract into all concrete implementers of my interface.

[System.Diagnostics.Contracts.ContractClass(typeof(ITestContractCodeContract))]

public interface ITestContract

{

double Divide(double number, double divider);

}

You see I am telling compiler that my interface carries a contract which is explicitly implemented in class ITestContractCodecontract. Now time to write the contract class.

[System.Diagnostics.Contracts.ContractClassFor(typeof(ITestContract))]

public class ITestContractCodeContract : ITestContract

{

public double Divide(double number, double divider)

{

Contract.Requires<ArgumentException>((divider > 0.0), "You cannot divide by zero");

Contract.Ensures((number != 1), "abc");

return default(double);

}

Again I am decorating this class to tell compiler that this class carries contract for my interface. There are many methods which you would like to look in Contract class (see my references below) but since mostly you would like to write some precondition and postcondition, I am using Requires and Ensures methods of Contract class in my example. Requires provide you a precondition and Ensures provide you a postcondition contract.

Now what my contract class means to runtime, it says that any class implementing my interface divide function if and when called, should first validate (before going into divide function implementation) that divider is not zero and if contract is not broken it should run through the concrete implementation of divide and as soon as it comes out of that function it should make sure my postcondition contract (number not equal to 1) is not breaking.

let me write one concrete implementation of my interface

public class ActualTestContract : ITestContract

{

public double Divide(double number, double divider)

{

//Debug.Assert((divider == 0), "cannot divide by zero");

if(divider!=0)

return number / divider;

throw new ArgumentException();

}

Now let me call my concrete class and check what happens

internal class Program

{

private static void Main()

{

ITestContract test = new ActualTestContract();

double division = test.Divide(1, 0);

Console.WriteLine("division value is " + division);

Console.Read();

}

You see my call actually breaks both pre and post condition but so far if you are copying the above mentioned code in a project and trying to run, you won't get any exception. Actually there is a config setting in your Project -> Properties ->Code contract tab (you will get it only if you have installed the extension) -> check runtime contract checking

If you do so, you will get assertions for both pre and post condition. Please note that if you are using VS2010 premium or ultimate edition, you will get these assertions failing on compile time, since it uses static code analyzer which is able to look into your code contract implementation and evaluate it on compile time it would be able to catch exceptions like NullReference, ArgumetOutOfRange etc.

There might be a case when you want some validations to be applied to your class level. You can do so by writing a method in your class and putting an attribute "ContractInVariantMethod" for e.g.

[ContractInvariantMethod]

private void ObjectInvariant()

{

Contract.Invariant((this.definition != string.Empty), "You have to have definition properly defined in the class");

}

The code will be evaluated as soon as instance of this class is visible to any client. It says that no matter what, my instance cannot have empty definition (assume definition is a property inside my class).

If you want to understand more of Contracts Refer following links

MSDN article on code contracts

I am attaching herewith my implementation code for you to debug and get a real feel of Code contracts.

TestContract Project

Hope this article has helped you understanding the power of decoration and how you can keep your code clean by separating out the aspects (validation, logging, exceptions etc).

Thanks for reading..

Anonymous method exposed

2011-04-14T02:42:00.000-07:00

In this post, I am going to explain what Anonymous function is and how CLR interprets them.

Anonymous functions were introduced in .NET 2.0. They provide you the in place code block where a delegate object is acceptable. Anonymous method can reduce the overhead of declaring a function and you can declare them right at the point of the invocation.

    public class AnonymousFunction
    {
        public delegate void delFunc();
        public void Test()
        {
            int i = 4;
            delFunc delFunc = delegate
            {
                i += 1;
                int j = 0;
                if (i > 1)
                {
                    Action<int> del = delegate { j += 1; i += 1; };
                    del(8);
                }
                Console.WriteLine("i: " + i.ToString() + " j: " + j.ToString());
            };
            delFunc();
        }
    }

You can see in the code above that we have used anonymous methods to give implementation to our delegates delFunc and del. The key point to note here is the variable scope within the anonymous method block. An anonymous method has all the variables available to it that your code can access at the point where anonymous method is declared. This makes it anonymous method even more useful but on the other hand writing anonymous methods all the places can make your code unmanageable as well.

Now the question comes, how compiler interprets them. For compiler any method should have an associated type so it has to be either instance method or static one. Compiler checks what all resources your anonymous method is using and based on take the decision how it needs to be implemented in your MSIL.

Compiler essentially creates a private class for each anonymous method and makes all variables used inside your anonymous method as the member variable of that private class and sets those member variables from outside (invocation point) with the value of same variables declared in the main class.

To get more understanding of it, let’s see what intermediate code compiler will emit for the above mentioned code. I am simplifying the actual compiler code here for your better understanding

private sealed class MyClassForDelFuncAnonymousMethod
{
    // Fields
    public int i;
 
    // Methods
    public void MYDelFuncAnonymousMethod()
    {
        this.i++;
        int j = 0;
        if (this.i > 1)
        {
            MyClassForDelAnonymousMethod oMyClassForDelAnonymousMethod = new MyClassForDelAnonymousMethod();  
oMyClassForDelAnonymousMethod.j = j;
oMyClassForDelAnonymousMethod.oMyClassForDelFuncAnonymousMethod = this;
 
        Action<int> del=  oMyClassForDelAnonymousMethod.MYDelAnonymousMethod(8);
 
        }
        Console.WriteLine("i: " + this.i.ToString() + " j: " + j.ToString());
    }
 
    // Nested Types
    private sealed class MyClassForDelAnonymousMethod
    {
        // Fields
        public AnonymousFunction.MyClassForDelFuncAnonymousMethod oMyClassForDelFuncAnonymousMethod;
        public int j;
 
        // Methods
        public void MYDelAnonymousMethod (int)
        {
            this.j++;
     this.oMyClassForDelFuncAnonymousMethod.i++;
        }
    }
}
 
 
public void Test()
{
    int i = 4;
        MyClassForDelFuncAnonymousMethod oMyClassForDelFuncAnonymousMethod = new MyClassForDelFuncAnonymousMethod();
oMyClassForDelFuncAnonymousMethod.i = i;
        i++;
        k++;
 
        AnonymousFunction.delFunc delFunc = new AnonymousFunction.delFunc(oMyClassForDelFuncAnonymousMethod.MYDelFuncAnonymousMethod)
 
}

Typeof vs GetType (how to compare types)

2011-04-13T00:58:00.000-07:00

Let say I have implemented few classes in following manner

Public Interface IA

Property Id As String

End Interface

Public Class A

Private _id As Integer

Public Overridable Property Id As Integer

Get

Return _id

End Get

Set(ByVal value As Integer)

_id = value

End Set

End Property

End Class

Public Class B

Inherits A

Implements IA

Public Property Id As String Implements IA.Id

Get

End Get

Set(ByVal value As String)

End Set

End Property

End Class

Now I write switch statement to compare type like these ways

Dim a As IA = New B

a.Id = "2"

Dim b As A = New B

b.Id = "2"

Dim t As String = a.GetType.ToString

Select Case t

Case GetType(A).ToString

Console.WriteLine("type is a")

Case GetType(B).ToString

Console.WriteLine("type is b")

End Select

Select Case True

Case TypeOf a Is A

Console.WriteLine("type is a")

Case TypeOf a Is B

Console.WriteLine("type is b")

End Select

Select Case True

Case TypeOf b Is A

Console.WriteLine("type is a")

Case TypeOf b Is B

Console.WriteLine("type is b")

End Select

Now note that the yellow one will print “type is b” but green one will print “type is a”. actually "is" operator traverses the complete hierarchy to match the type so typeof a is “IA”,”A”,”B” all true. But GetType does not return you the type of reference instead actual type since it is calculated on runtime so it will just give you a.GetType = B only.

Now let me share with you some interesting methods from System.Type namespace which works ofcourse on runtime and can be very handy.

Let me first define some dummy interfaces, classes and their relations.

interface IBase
    {

    }
    interface IA : IBase
    {

    }

    class A : IA
    {

    }

    class B : A
    {

    }

Now let me create few objects out of that

IBase ibase = new B();

IA ia = new B();

A a = new A();

B b = new B();

Now I want to see if type of my object b is derived from type of my object a. There are two methods

1. Type.IsAssignableFrom

2. Type.IsSubclassOf

// x.IsAssignableFrom(y) returns true if:
// (1) x and y are the same type
// (2) x and y are in the same inheritance hierarchy
// (3) y is implemented by x
// (4) y is a generic type parameter and one of its constraints is x

IsSubclassOf function does just reverse of IsAssignableFrom. So if (typeof)x.IsAssignableFrom(typeof(y)) is true then (typeof)y.IsSubclassOf(typeof)x) will also be true.

Kindly note that the above two functions are valid on concrete types only. I will explain how to get types for interface in a minute, hang on.

let's get some working examples (refer above mentioned classes and objects)

1. ia.GetType().IsAssignableFrom(a.GetType()) will return false since actual type of ia is "B".

2. a.GetType().IsAssignableFrom(ia.GetType()) will return true since object of type of ia ("B") can be assigned to type of a ("A")

3. b.GetType().IsAssignableFrom(a.GetType()) will return false since b is not assignable from a type

Now some examples of IsSubclassOf

1. a.GetType().IsSubclassOf(ia.GetType()) will return false since ia (type "B") is not base class of a (type "A").

2. b.GetType().IsSubclassOf(a.GetType()) will return true since "B" is subclass of "A".

Let's discuss about checking the interface type now

If I want to see how many interfaces are implemented by the type of my object we can use GetInterfaces method

Type[] types = ia.GetType().GetInterfaces();

will give me types[0] = "IBase" and types[1] = "IA"

If I want to see whether a particular type is implemented by my object type, I can use GetInterface method and pass interface name as string parameter.

Type type = ia.GetType().GetInterface("IA");

will return me IA (interface type) since type of ia ("B") implements it.

similarly

Type type = b.GetType().GetInterface("IBase");

will also return me IBase type since my object b has that in its hierarchy.

Now what if I do something like

Type type = ia.GetType().GetInterface("I");

where I is some unrelated interface. you might have guessed it correctly type object will be null and we can tell that my object type never has interface "I" type in its complete hierarchy.

Covariance vs Contravariance

2011-04-11T06:27:00.000-07:00

Variance is actually nothing new in .NET but .NET 4 has extensively used them in its framework and that makes it essential to understand. Variance actually provides you the implicit conversion (instead of explicit typecasting everywhere).

Covariance happens when you assign something more derived in the hierarchy to less derived so that assignment compatibility is preserved for e.g.

//Example of Covariance

//String (more derived type) is direcly assignable to Object(less derived type>

IEnumerable<string> stringCollection = new List<string>();

IEnumerable<object> objectCollection = stringCollection;

IEnumerable<object> obj = new List<string>();

Contravariance is just opposite to Covariance and happens when you assign something less derived in the hierarchy to more derived type such that assignment compatibility is reversed for e.g.

//Example of Contravariance

//More derived type delegate is assignable to delegate containing less derived type

Action<object> o = WriteToConsole;

Action<string> o1 = o;

public static void WriteToConsole(object o){}

So the question comes where they are actually supported in framework

1. Covariance in arrays (since C# 1.0)

2. Covariance and Contravariance in delegates, also known as “method group variance” (since C# 2.0)

3. Variance for generic type parameters in interfaces and delegates (since C# 4.0)

Let’s learn examples for each of them

Covariance in Arrays:

class Program

{

static void Main(string[] args)

{

//Covariance in array

//I can directly assign more derived type to its one of the base types in hierarchy

object[] obj = new string[10];

obj[0] = "Abhishek";

Console.WriteLine(obj[0]);

//Not 100% safe, check following line which will compile but throw runtime exception

//Exception: ArrayTypeMismatchException

obj[1] = new object();

Console.Read();

}

Covariance and Contravariance in Delegates:

class Program

{

static void Main(string[] args)

{

//Covariance in delegate

Func<object> myFuncExForCovariance = GetMyName;

Console.WriteLine(myFuncExForCovariance());

//Contravariance in delegate

Action<string> myActionExForContravariance = PrintMyName;

myActionExForContravariance("Abhishek");

Console.Read();

}

static String GetMyName()

{

return "Abhishek";

}

static void PrintMyName(object s)

{

Console.WriteLine(s);

}

Does this look scary? How to find when it is supporting covariance or Contravariance? Actually .Net 4 provides you syntax for that. If type is “out” it means it is Contravariance and you can assign less derived type. If type is “in” it means it is covariance and you can assign more derived type. So if you look at the metadata of the delegates used above, you would be able to understand it clearly

// Type parameters:

// T:

// The type of the parameter of the method that this delegate encapsulates.This

// type parameter is contravariant. That is, you can use either the type you

// specified or any type that is less derived. For more information about covariance

// and contravariance, see Covariance and Contravariance in Generics.

public delegate void Action<in T>(T obj);

// Type parameters:

// TResult:

// The type of the return value of the method that this delegate encapsulates.This

// type parameter is covariant. That is, you can use either the type you specified

// or any type that is more derived. For more information about covariance and

// contravariance, see Covariance and Contravariance in Generics.

public delegate TResult Func<out TResult>();

Infact you can write your own delegates and interfaces using the same syntax of variance.

class Program

{

public delegate TResult MyCustomDelegate<in Tin1, in Tin2, out TResult>(Tin1 input1, Tin2 input2);

static void Main(string[] args)

{

MyCustomDelegate<Dog, Dog, object> mydel = TestMyDelegateWithVariance;

Console.WriteLine(mydel(new Dog(), new Dog()));

Console.Read();

}

public static string TestMyDelegateWithVariance(Animal i, Animal j)

{

return (i.legs + j.legs).ToString();

}

class Animal

{

public int legs { get; set; }

public Animal()

{

legs = 2;

}

class Dog : Animal

{

public Dog()

{

legs = 4;

}

This will print 4 + 4 = 8 as expected.

The point to note is that covariance and Contravariance is meant for reference types only, the concept is not applicable on value types.

//will run fine

IEnumerable<object> oRefToRef = new List<String>();

//will throw a compile time error, need explicit typecasting

IEnumerable<object> o = new List<int>();

Variance on generic interfaces:

class Program

{

static void Main(string[] args)

{

//The following conversion will work fine due to variance

ITestVariance<Dog, Animal> myTestVariance = new ConcreteTestVariance<Animal, Dog>();

//Following will demand for explicit conversion since wrong usage of variance constraint

ITestVariance<Dog, Animal> myTestVariance = new ConcreteTestVariance<PamellianDog, Animal>();

Console.Read();

}

interface ITestVariance<in T, out T1>

{

}

//following interface is invariant in nature since it does not specify

//in/out paramater

interface ITestInVariance : ITestVariance

{

}

//following interface is variant in nature

interface IDerTestVariance<in T, out T1> : ITestVariance

{

}

//classes and structs are always invariant (remember only delegates and interfaces

//of generic types can support variance)

class ConcreteTestVariance : ITestVariance where T1 : T

{

}

class Animal

{

public int legs { get; set; }

public Animal()

{

legs = 2;

}

class Dog : Animal

{

public Dog()

{

legs = 4;

}

class PamellianDog : Dog { }

The following interfaces from framework already support variance

IEnumerable (T is covariant)
IEnumerator (T is covariant)
IQueryable (T is covariant)
IGrouping (TKey and TElement are covariant)
IComparer (T is contravariant)
IEqualityComparer (T is contravariant)
IComparable (T is contravariant)

The following delegates from framework has inbuilt variance support

Action delegates from the System namespace, for example, Action and Action (T, T1, T2, and so on are contravariant)
Func delegates from the System namespace, for example, Func and Func (TResult is covariant; T, T1, T2, and so on are contravariant)
Predicate (T is contravariant)
Comparison (T is contravariant)
Converter (TInput is contravariant; TOutput is covariant.)