ashish shukla

Generics make it easy to reuse the code for different data types.This is possible because of type parameters.Type parameter  is placeholder for the actual data type which is specified using the type argument when the generic type is instantiated.

Though we can specify different data types as the type arguments but sometimes it is required to restrict the data types which can specified as the type arguments.We can restrict the data types using the constraints.

The different types of constraints are

• Reference type constraint    The type argument supplied for the type parameter should be a reference type .In the following example we are applying the class constraint to the GenericUser class.We are restricting the type parameter to the User class ,so only the User class object can be specified for the GenericUser class type parameter

public class GenericUser<T> where T : User
{
T user;
}
public class User
{
public string UserName
{
get;
set;
}
public User(string _userName)
{
UserName = _userName;
}
public void Hello()
{
Console.WriteLine("Hello {0}", UserName);
}
}

• Value type constraint  The type argument should be a value type.In the following example we are restricting the type argument to a value type.So the only value types such as int or decimal can be used as a type argument for the GenericValue class.

public class GenericValue<T> where T : struct
{
T value1;
}

• Base Class constraint  The type argument should derive from the base class.

public class Manager<T> where T : Employee
{
T emplyee;
}

public class Employee
{

}

In the above example as we are declaring a generic Manager class we are deriving it from the Employee  class.Since Manager is a type of employee so we want to restrict type argument to the Employee type.

• Interface constraint   The type argument should implement a specific interface.In the following example the generic class Student restricts the type parameter to implement the IComparable interface.This will allow the Students to be compared if we are inserting the Student objects in a list .So only the data types implementing the IComparable interface can be used as the type arguments.

 public class Student<T> where T : IComparable
 {

 }

 

• Default Parameter constraint  The type argument should have public parameterless constructor.This is specified using new() as:

public class Generic<T> where T : new()
{
T obj=new T();
}

This constraint must be the last one in list if more than one constraints are specified.

The main advantage of constraints is that the compiler is aware of a class member such as a method .If we try to call a class method which we supply as the type argument our code will not compile.So the following code will fail

public class GenericUser<T>
{
T user;
public GenericUser()
{
user.Hello();
}

}

If we want to use a method which belongs to a particular data type in our generic class then we can apply the class constraint.So we can use the  method of a data type as:

public class GenericUser<T> where T : User,new()
{
T user;
public GenericUser()
{
user = new T();
user.Hello();
}

}

public class User
    {
        public User()
        {

        }
        public string UserName
        {
            get;
            set;
        }
        public User(string _userName)
        {
            UserName = _userName;
        }
            public void Hello()
            {
                Console.WriteLine("Hello {0}", UserName);
            }
    }

In the above generic class as we are restricting the type arguments to the User class hence the compiler is aware of the presence of the Hello() method.

So as we have seen constraints in Generics restricts the type parameters to specific data types such as class or interface.They help the compiler know about the presence of data type members such as methods.

Follow on:

Generics were introduced in the  version 2.0 of the .NET framework.Generics allows the user to specify the data type when the generic type is declared and initialized.

Generics work with different data types

Generics such as generic method or generic class accepts type parameters and hence work on different data types.This means that we can create different versions of a single generic type by supplying different data types as type arguments when declaring and instantiating a generic type.For example we can create a string and int versions of a generic class.

So generics provide reusability as we declare just one version of a generic type and then use it for different data types.

Defining and using Generics

Generic class

We can define a generic type using the type parameters which are placeholders for the
actual types which are substituted when the generic type is defined and initialized.
Following are the steps to declare and use a generic type
Declare a generic class using type parameters

public class GenericClass<T>
{

private T property
public T Property
{
get { return property; }
set { property=value; }
}
}

Above we are declaring a Generic class called GenericClass which uses a type parameter called T.We can identify a generic class from the “<>” brackets after the class name.

The name specified inside the “<>” brackets is the type parameter.The type parameter represents
a data type such as int which is supplied when the generic class object is declared.Also the type
parameter can be used anywhere inside the class where any data type can be used such as
when declaring fields and properties.

Creating a generic class object

GenericClass<int> obj=new GenericClass<int>();

In the above code we are passing type argument int to the GenericClass type.So now we have an int version of the GenericClass type.

Generic methods

The difference between a generic method and a normal method is that a generic method accepts type parameters.

static void GenericMethod<T>(T parameter1)
{
T variable1;
}

In the above method we have declared a generic method called GenericMethod which accepts a type parameter T which is a placeholder for the actual data type.

We can call the above generic method as

int a;
GenericMethod<int>(a);

we can also omit the type argument while calling the generic method as

int a;
GenericMethod(a);

We do not supplied the type argument above as the compiler was able to infer the type parameter from the type of the supplied argument.Since type argument “a” is of type int hence compiler inferred the type parameter as an int.

It is important to understand few things about generic methods

• We can declare a generic method inside a non-generic class.
• Generic methods can be overloaded based on the type parameter.So we can have the following generic methods inside a non-generic class

void Method1<T>() { }
void Method2<T, U>() { }

Generic Interface

Generic interface is just like a normal interface except that it includes the type parameter

public interface IGeneric<T>
{
}

We can use the type parameter inside  the generic interface as:

public interface IGeneric<T>
{
void Method1(T t1);
}

Advantages of Generics

Generics provides the following advantages over non-generic types

• Since the same generic type can work with different data types so the same code can be reused across the different data types
• As the type parameters are type checked at compile time rather than runtime so errors are detected early on during the compilation stage
• Type casting is not required since the generic type is created for a particular type specified by the type parameter.This makes the code more efficient.For example if we use the generic object type for storing different datatypes then we need to use type casting or boxing/unboxing.

In the following example we are using both object type and the generic type for storing items in a stack.

Using the object type to store different items in a stack

object s = new object();
s.Push("1");
s.Push(2);

Using the generic type to store items in a stack

Stack<int> genericStack = new Stack<int>();
genericStack.Push("1");
genericStack.Push(2);

In the examples above the difference between the non-generic and generic version of the stack is :

In the first example a string value is stored in the stack.As a consequence of this while retrieving the value an error would be thrown if the incorrect cast used.In the second example even though we are trying to store a string value in the stack we will get a compile time error as the stack is for the int type.

Also in the second example we don’t need to cast the stored items to int type as the stack is for int type.This makes the code more efficient as compared to the first example.

So as we have seen generics in C# helps in writing code which works with different data types and also the code is more optimized then the non generic version.Also run time errors because of data type mismatch do not occur in the case of generics.

Follow on:

We pass data to the method using arguments.When we call the method we pass arguments which are assigned to the parameters defined by the method.After executing the logic method can return values to the caller using the return statement.

For example the following method accepts two parameters and returns the sum of the parameters as an integer return type:

public int Add(int x,int y)
{
return x + y;
}

When we pass values to the method using method arguments ,the parameters are assigned the arguments used to call the method.Now if the method modifies the parameters then the arguments used to call the method are not effected.This is useful since it prevents the side effects of modifying the parameter values from propagating to the rest of the program.So we can say that arguments are passed by value by default as the copy of the arguments is assigned to the parameter.

But sometimes it may be required that the argument and parameter are same or argument and parameter refer to the same memory location.We can easily implement this using the ref and out parameters.

ref parameters

When we pass the ref type parameters the parameter becomes an alias for the argument.So whatever changes we make to the method parameter affects the argument used to call the method.

public static void UpdateValues(ref int x, ref int y)
{
x = x + 10;
y = y + 10;
}

static void Main(string[] args)
{
int a=1, b=1;
UpdateValues(ref a, ref b);
Console.WriteLine("a={0},b={1}", a, b);
}

If we execute the above code then we can see that the values of x and y are updated and is reflected even outside the method:

 

The values of x and y are reflected in the calling method since the variables a and b refers to the same memory location as x and y.This happens when we pass the parameters by reference.

out parameters

c# requires that every method parameter is assigned a value when the method is called.For example if we define a method as:

public static void UpdateValues( int x, int y)
{
x = x + 10;
y = y + 10;
}

then if we try to call the above method without assigning the parameter values then the compiler will complain that the argument variables are unassigned

 

But what if don’t have the parameter value when calling the method or if we want to return multiple values from the method which are not known when the method is called ? As we can not use normal method parameters ,we use out parameters in such as a scenario.

static void Main(string[] args) {
int a, b;
UpdateValues(out a, out b);
}

public static void UpdateValues( out int x, out int y)
{
x = 0; y = 0;
x = x + 10;
y = y + 10;
}

In the above code though we have not assigned the parameters still the compiler doesn’t complain as we have declared the parameters as out parameters.

ref and out parameters in c# are used for passing the parameters by reference instead of passing  the parameters by value.out parameters differs from the ref parameters as we can pass the parameters without assigning them when calling the method.

Follow on:

C# Preprocessor directives are commands for the compiler so they affect the build process.Since they affect the build process so they are useful in several common scenarios.Here we will look into some of the Conditional Preprocessor directives in C#.Conditional Preprocessor directives are used to include or exclude portions of code in the build.

When writing code we often want to execute some code only in the development environment but not in the release build of the application.One commonly used way to disable the code from executing in the development environment and enable the code in the release build is to comment out the code in the development environment and then uncomment while deploying.

The problem with this method is that we can forget to uncomment the code.If we are commenting the code at lots of places then it is very likely to forget to uncomment the code.Also we sometimes need to build the code differently for different platforms.The solution to the mentioned scenarios is using the compilation symbols.

For example it is a common requirement to compile certain portions of the code while debugging.Visual studio by default creates DEBUG compilation symbol only in the debug configuration.

#if DEBUG
//Code to execute only in the debug configuration
#endif

Similarly if we want to execute certain code only in the release build we can use the following

#if !DEBUG
//Code to execute only in the release configuration
#endif

 #if and #endif

These are the preprocessor directives for selectively executing the code.So if we have a requirement for two separate versions of a code then instead of creating two different code bases or copies we can use the #if and #endif directives so that the code is executed only when a certain condition is met.

We can easily write code that will be executed only in the debug build as:

#if DEBUG
Console.WriteLine("Currently testing the application!");
Console.WriteLine("This code will not go to production.");
#endif

We may not realize the use of this directive by just looking at the above code but imagine if we are using the test code at hundreds of places then what pain it would be by manually going to each and every line where the test code is being used and then delete or uncomment the code.If we are selectively compiling the code as above then we just need to remove the compilation symbol and the code will not be included in the release build.

Defining the Compilation symbol
If we need more compilation symbols then the ones provided by Visual Studio by default ,such as DEBUG,then we are free to create new ones using the #define directive

There is a #define directive that is used to define the compilation symbol.

For example we can define a new compilation symbol called TEST as:
#define TEST

Follow on: