C# Generics

Siddhesh Chalke

7 Comments

Join the conversation! Your thoughts help the community grow.

Rajanikant Hawaldar7y ago
how generic methods works if I pass index as -1?
- Rajanikant Hawaldar7y ago
  that's correct but list is private so i can't access it so i can't check like list count or length >=0 , there is a access to methods method take int and returns T so how to handle the exception and what to return
- Siddhesh Chalke7y ago
  1) Answer to your 1st statement is, You can always write a public method that can return size of the list.2) Answer to your 2nd statement is, According to me since this class most probably is going to be in a 'Class Library Project', it's better to throw an exception. That way other developers can handle this exception the way they want. try { return genericList[index]; } catch(Exception ex) { throw ex; }
- Siddhesh Chalke7y ago
  Your question is not 'Generics' specific, it is about 'List'. But to answer your question, if you send -1 index then above program will throw 'ArgumentOutOfRangeException'.
Ravi Patel7y ago
Nice explanation
Anurag Maheshwari7y ago
Very nice and clean explanation!
Amit Mohanty7y ago
Nice article !!!

What are Generics?

It’s kind of difficult to explain what ‘Generics’ are but if you have used a list before in your coding, you unknowingly know ‘Generics’.

Prerequisites

You should at least know ‘List’ Data Structures in C# and how to use them.

Usually, developers create a C# list in the following manner.

The red square box indicates generics. It restricts the addition of only ‘Integer’ items in the list.

Why Generics?

Before ‘Generics’ was introduced in C#, List was used in the following manner.

ArrayList arrayList = new ArrayList();
arrayList.Add(0);
arrayList.Add(10);
arrayList.Add("Sam");
arrayList.Add(30);
arrayList.Add("Jacob");

The problem with the above code is that you can add any ‘Type’ in list (Observe how ‘string’ and ‘integer’ are added to the list.)

If you do so, it will be a problem at the time of retrieval because if you try to fetch items at the index, it will return ‘object’ and you can’t do much with it.

The solution is to ‘Cast’ the retrieved ‘object’ to the required type as follows.

var v = (int)arrayList[1];

But in real life, lists are made up of thousands of elements. It’s inconvenient to verify each element and then cast it. In case casting is not possible, the program will throw an exception. Please see the following image.

You can see we are trying to cast ‘string’ to ‘int’ which is not possible, hence the code throws an exception.

To overcome this problem, ‘Generics’ were introduced.

When to use Generics?

Anytime you create a list, you are utilizing ‘Generics’; not creating them or using them.

private List<int> intList = new List<int>();

So, the question comes when to use ‘Generics’ and when to not.

Any time in your code you want the logic to be applicable to ‘All Types’, you can use ‘Generics’.

Explanation

Let’s assume that developers of the ‘List’ Data Structure for ‘Integers’ wrote the following code.

class MyListInteger
{
private List<int> intList = new List<int>();
public void Add(int number)
{
intList.Add(number);
}
public int GetItem(int index)
{
return intList[index];
}
}

Let’s assume they want to create the ‘List’ data structure for ‘string’ as well. They will have to repeat the code for ‘string’ as below.

class MyListString
{
private List<string> stringList = new List<string>();
public void Add(string item)
{
stringList.Add(item);
}
public string GetItem(int index)
{
return stringList[index];
}
}

Imagine if they have to repeat the code for every type, which is chaos.

‘Generics’ to the rescue.

You can create ‘Generics’ class for the above scenario as mentioned in the below code.

class MyList<T>
{
private List<T> genericList = new List<T>();
public void Add(T item)
{
genericList.Add(item);
}
public T GetItem(int index)
{
return genericList[index];
}
}

Where ‘T’ is called a placeholder or ‘Type parameter’. ‘T’ is usually referred to as ‘Type’.

When you create an object of the above class, all the ‘T’s are replaced by ‘Type’ that is used to create an object.

MyList<int> ml = new MyList<int>();

After the above line, all ‘T’s are replaced by ‘int’.

The class will look like below after the above initialization (Imaginary).

class MyList
{
private List<int> intList = new List<int>();
public void Add(int number)
{
intList.Add(number);
}
public int GetItem(int index)
{
return intList[index];
}
}