Introduction to Generic Methods in C#

When we create a method, class or interface, we usually specify the type of the parameter and its return type.

Ex.

C#

1 2 3 4 5 6 7 8

private void showValue(int val)     {         MessageBox.Show(val.ToString());     }

Invoke the above function using

C#

1 2 3 4 5

showValue(10);  // 10 displyed in message box

This will display 10 in the message box.

Now pass the string to the showValue function as shown below and you will get the compiler error “Invalid arguments” . That is because showValue function expects an integer and not a string;

C#

1 2 3 4 5

showValue(“This is 10”);    // Invalid arguments error

To solve the problem what we do is write another overloaded functionshowValue which takes the string as input as shown below.

C#

1 2 3 4 5 6 7 8 9 10 11 12 13

private void showValue(int val)     {         MessageBox.Show(val.ToString());     }       private void showValue(string val)     {         MessageBox.Show(val.ToString());     }

And invoke the above using the code

C#

1 2 3 4 5 6

showValue(10);     showValue(“This is 10”);

Now both will work fine.

Using Generics

In the above example we have duplicated the code MessageBox.Show(val.ToString()) in both the functions. This works correctly, but it is not efficient.  If we want to extend the function to handle double data type, then we need to write one more overloaded function repeating the code again.

The solution is to write the code once, which will handle all the types.  And that is where  generics come into the picture.

For Example the above code written in a generic way

C#

1 2 3 4 5 6 7 8

private void GenshowValue<T>(T val)     {         MessageBox.Show(val.ToString());     }

And invoke the function using

C#

1 2 3 4 5 6 7

GenshowValue<int>(10);     GenshowValue<string>("This is string");     GenshowValue<double>(10.7545);

Defining the Generic Method

Using Generics in C#

What is  <T>

<T> is just a place holder for the data type.  It is more like a blueprint for the type.  T is substituted by the actual type at the run time.

Instead of <T> you can use <X> and is perfectly valid

C#

1 2 3 4 5 6 7 8

private void GenshowValue<X>(X val)     {         messageBox.Show(val.ToString());     }

Multiple Parameters

Generic methods can have multiple parameters.

C#

1 2 3 4 5

private void GenshowValue<T>(T val1 , T v. inal2)

Parameters can be of different types. In the example below first parameter val1 is of a generic type, while second parameter val2 is of type int.

C#

1 2 3 4 5

private void GenshowValue<T>(T val1 , int val2)

You can have two generic type parameters of different type as shown below.

C#

1 2 3 4 5

private void GenshowValue<T, Y>(T val1 , Y val2)

Invoked as

C#

1 2 3 4 5

GenshowValue<int,string>(10, "This is string");

Constraints on Parameters

We can specify the restrictions on the types of parameters using the whereclause.  A compile time error is generated when you call your generic method with the wrong types

For Example

Where T:struct

The Value type like int, float, struct etc. must be used as the parameter

C#

1 2 3 4 5

private void GenshowValue<T>(T val)  where T:struct

and if invoked as

C#

1 2 3 4 5 6 7

GenshowValue<int>(10);                   //Works fine     GenshowValue<string>("This is string");  //Compile error because string is not value type     GenshowValue<double>(10.7545);           //Works fine

where T : class

Here reference type like string, class, arryays etc. must be used as the parameter. Example :

C#

1 2 3 4 5

private void GenshowValue<T>(T val)  where T:class

The Constrains for multiple generic types is as follows

C#

1 2 3 4 5

private void GenshowValue<T,Y>(T val) where T:struct where Y:struct

Returning a Generic type from method

We can specify the return type from a generic method as follows

C#

1 2 3 4 5 6 7 8 9

private T GenshowValue<X>(X val)     {         MessageBox.Show(val.ToString());        return val;     }

Generic Classes

Like methods classes can be made to act on generic types.  The concept is very much similar to the method.  In the example below,  we modified the code GenshowValue and moved it into the class.

C#

1 2 3 4 5 6 7 8 9 10 11

public class showValues<T>     {        public void show(T val) {            MessageBox.Show(val.ToString());        }            }

And  invoked as

C#

1 2 3 4 5 6 7 8 9 10 11

showValues<int> showInt = new showValues<int>();   //Generic class called with int type     showInt.show(10);             showValues<string> showString = new showValues<string>();  //Generic class called with string type     showString.show("This is string");     //showString.show(10);   //This will give compile time error

Generic Interfaces and delegates

The Interface and delegates can be made to use generic types similar to the class.

Advantageous of Using C# Generics

• Allows you to write code which has the similar logic but can be applied to various data types. This enables you to reuse the code
• Allows you to write type safe code as  C# Generics  are checked at the compile- time. If you use objects instead of generics, then casting to the correct type needs to be done at runtime.
• Using objects instead of Generics also has problem of boxing/unboxing of value types or casting in case of reference types.

Conclusion

C# Generic programming allows us the create highly reusable code. Code that can be reused in many different places and situations.  Generics  allows us to create methods, classes, interfaces, and delegates work with multiple types while still being type safe.