C# is an Object-oriented programming language. C# comes with simplicity, expressiveness and great performance to meet the programmer productivity.
In the previous article, we have studied about generic constraints
with examples. Now, let's see generic subclassing
, type parameters
in this chapter.
The main objective of this article is to learn
generic type parameters
in C# programming
We can subclass a generic class like we do for non-generic class
. Take a look at the below example in which the subclass can leave the base class's type parameter as open.
class MySecnd<T> : MyClass<T>
Or it can close the parameters of generic types with concrete types. For example
class MyInt : MyClass<int>
We can also declare the subtypes with with the type arguments like below,
class SubClass<T,TKey> : MyClass<T>
Generic Type Parameters
Type parameter is a place holder for that type in which the client specifies when they instantiate a variable
of the generic type
For example, let's take
GenericList<T>. In order to use this, client code must declare a constructed type and need to specify a type argument inside the braces (<>) to instantiate that constructed type.
We can use any type as the type argument but that must be recognized by the compiler.
GenericList<int> MyList = new GenericList<int>();
In order to use a class as type argument, we should follow the below approach,
GenericList<MyClass> Test = new GenericList<MyClass>();
For structs also it is same like above, i.e,
GenericList<MyStruct> Exam = new GenericList<MyStruct>();
What is delegate?
is the C#
's keyword that helps to make method objects. It is often used for event handlers
to specify the handler type.
Let's have a simple example of using delegate
delegate void Name(string name);
static void Main()
// Using lambda expression to specify the delegate
Name myname = m => Console.WriteLine(m);
myname.Invoke("Krishna"); // Invoking the delegate
In the above example, we have a delegate
. In the Main()
method, we have created instance to the delegate and specified it by using the lambda expression.
Finally, invoking the delegate will calls the method
Name() and compiles it to print the following lines in your console,
What is a lambda expression?
Lambda expressions provides an easy and simple way to specify the methods. It is little complex to represent the syntax for delegate functions. Hence lambda expressions are used.
In this, separation of parameters and the method body is done by using '
Note: Lambda can be passed to the method that receives an
public delegate void MyDel<T>(T prop); // Generic delegate declaration
public static void Product(int i)
And we can create instance to that delegate like below,
MyDel<int> d = new MyDel<int>(Product);
There is a new feature called method group conversion, which is applicable for generic as well as concrete delegate types.
It allows us to write the above line like below,
In this article, we have studied with generic subclassing, generic type parameters and delegates in C#. Hope you understand.
Thanks for reading,