C#

Constraints are used in Generics to restrict the types that can be substituted for type parameters. Here we will see some of the commonly used types of constraints.

When we create a new instance of a generic type we can restrict the types we can substitute for type parameters using constraints. If we try to substitute a type that does not comply with the constraint then we get a compile-time error. We specify constraints using the where clause. The following are some of the main types of constraints we can use with generics:

where T: struct value type constraint
where T: class reference type constraint
where T: new() default parameter constraint
where T: <interface name> interface constraint

Value type constraint

This type of constraint specifies that the type argument should be a value type. If we try to substitute a non-value type for the type argument then we will get a compile-time error. If we declare the generic class using the following code then we will get a compile-time error if we try to substitute a reference type for the type parameter.

public class GenericType<T> where T:struct
{

The following line will throw a compile-time error. This is because string is a reference type, so because of the value type constraint it is not valid to substitute a string as the type parameter.

GenericType<string> gnericObj = new GenericType<string>(“ashish”);

Reference type constraint

This type of constraint specifies that the type argument should be a reference type. If we try to substitute a non-reference type for the type argument then we will get a compile-time error. If we declare the generic class using the following code then we will get a compile-time error when we try to substitute a value type for the type parameter.

public class GenericType<T> where T:class

The following line will throw a compile-time error since int is a value type:

GenericType<int> gnericObj = new GenericType<int>(1);

But the following line will compile properly since string is a reference type:

GenericType<string> gnericObj = new GenericType<string>(“ashish”);

We can implement other types of constraints in a similar manner. “Default constructor constraint” means that the type should have a default constructor and “interface constraint” means that the type should implement a specific interface type.

There are many advantage of using constraints. One of the biggest advantages is that in the case of an interface constraint we are sure that a type implements a specified method so we can call that method inside the generic type. Other constraints like the reference type and the value type constraints let us determine whether we can perform actions suitable for reference or value types. Such as if we apply the reference type constraint then we can use the null value check to determine if the type parameter points to a valid object.

.NET has many collection classes in the System.Collections namespace. Also these collection classes have many generic counterparts in the System.Collections.Generic namespace. These generic collections provide better type safety and performance than their non-generic counterparts.

The generic collection classes use various types of constraints. For example the “Icomparable<T>” interface sorts and determines the equality of items. The Icomparable interface has a “CompareTo” method that implementing classes should provide. So we can be sure that if a class implements Icomparable<T> then it can be sorted if used in a collection and also compared for equality.

Follow on:

Generics were introduced with the .NET framework 2.0 and have now become one of the most important and useful features of .NET. Generics use type parameters to specify the type argument when the type is instantiated. The client can specify the type parameter for the generic type while instantiating the type. So this causes reuse of code since the same generic code can be used for various types using type parameters. Using generics we can create generic interfaces, classes, methods, events and delegates.

Apart from code reuse, another very important use of generics is type safety since type errors are caught at compile time rather than at runtime. Generics are hugely used in collection classes. The System.Collections.Generic namespace includes several generic collection classes. In most cases we should use the generic collection classes in the System.Collections.Generic namespace instead of the non-generic classes in the System.Collections namespace.
We will first see how to use the standard List generic type then we see how to implement a generic class.

Using existing Generic collection class

We use the generic collection class List in the System.Collections.Generic namespace. The List class is the generic counterpart of the non-generic ArrayList class. The List class uses a type parameter that is specified when the List is instantiated and it is a type error to use the type for any other purpose than the type specified at the time of List instantiation.

So the following code works correctly:

While the following code gives a compilation error because of type mismatch between integer and string types.

So we get type safety by default when using generic types. If we had used the non generic ArrayList class instead of the generic List class we would have not gotten the compile time error but the run time error. Another advantage we got by using the generic type is that type casting and boxing is not required so this results in more optimized code.

Creating a new Generic class

We can create new Generic classes using type parameters. We specify the type parameter in angular brackets (< >) while declaring the class.

The following code is used to create a new generic class:

public class GenericType<T>
{
T obj;
// T used in non-generic constructor.
     public GenericType(T t)
{
obj = t;
}
public T GetObj()
{
return obj;
}
}

The identifier T is called the type parameter and is used in the generic types to specify various types at the time when the type is instantiated. It is used in the class as a placeholder for the exact type specified when the type is created.

In the code above we have declared the variable of type parameter t as the class variable.

We create a new instance of the preceding generic class using the following code:

GenericType<string> gnericObj = new GenericType<string>(“ashish”);
Console.WriteLine(gnericObj.GetObj());

The output of executing the code above is “ashish”. The GetObj() method above simply returns the value of the parameter passed in the constructor.

Follow on: