Using Generics With C#

Using Generics With C#

Generics are most frequently used with collections and the methods that operate on them. Version 2.0 of the .NET Framework class library provides a new namespace, System.Collections.Generic, which contains several new generic-based collection classes.

Generics are different from generic collections. Generic collections are emerged from generic concept. It helps us to maximize code reuse, performance and type safety.

Generics are strongly type collections.

Generics help to decouple the data-type from the logical code snippet which makes the code to reuse again and again.

We can also create classes and pass to it the generic parameter as type.

We can use generics in our code by calling the namespace "using System.Collections.Generic;".

Microsoft applied generic concept on

.NET collections to make generic collections.

Arraylist to make list generic collections.

Hashtables to make Dictionary.

Stacks and Queues to make Stacks and Queues generics.

Example:   public class GenericsClass<T>

    {

   public bool Compare( T a , T b)

        {

            if(a.Equals( b))

            {

                return true;

            }

            return false;

        }    }

     }

    class Program

    {

    public static void Main()

    {

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

            bool checkintData =  obj.Compare(10, 10);

            Console.WriteLine("Int data Check:{0}", checkintData);

            GenericsClass<string> obj1 = new GenericsClass<string>();

            bool StringData = obj1.Compare("indian", "indian");

            Console.WriteLine("String data Check:{0}", StringData);    }

    }

OutPut :  True, True

Advantages of Generic:

Type safety - this ensures that the method, class, or interface etc. works only on the correct data type. For example, if you use string when calling a generic method, then all the values passed in as expected to be strings. If you pass in an int value parameter, the compiler will detect that as an error and the program will not be able to compile.

Errors/Exceptions are caught at compile time as opposed to runtime errors/exceptions - if given a choice between compile time and runtime errors, 100% of developers choose compile time errors so should you. The last thing we want is errors crashing the program when the users are working with it.

Re-usability & Flexibility - in the above example on the problem statement, we declared more than one method and the only difference was the data type of the parameters that we passed. With generics, you only have to create one method and re-use it with any data type that you want

Write clean code - we do not need to write methods, class or interfaces that contain complex logic that checks the data type of the parameter values passed in.