Why Generic Programming

Generic programming in C# allows you to create classes, methods, interfaces, and other structures with
placeholders for the types they store or use. This provides several key benefits:

1. Type Safety: Generics ensure that you can only use the specified type, reducing runtime errors.
For example, a List<int> will only accept integers, preventing accidental addition of other types.

2. Reusability: You can write a single class or method that works with any data type. This reduces
code duplication and makes your code more maintainable. For instance, a generic list class can
store integers, strings, or any other type without needing separate implementations.

3. Performance: Generics can improve performance by eliminating the need for boxing and
unboxing when working with value types. This is because the type is specified at compile time,
allowing for more efficient code generation.

4. Flexibility: Generics allow you to create more flexible and reusable code. For example, you can
create a generic method that swaps two variables of any type:

C#

static void Swap<T>(ref T lhs, ref T rhs)

T temp = lhs;

lhs = rhs;

rhs = temp;

AI-generated code. Review and use carefully. More info on FAQ.

5. Consistency: Using generics helps maintain consistency across your codebase. For example,
the .NET collections library uses generics extensively, providing a consistent way to work with
different types of collections.

Generics are widely used in the .NET framework, especially in collections like List<T>, Dictionary<TKey,
TValue>, and Queue<T>, among others12.

Generic
Generics in C# allow you to define classes, methods, and interfaces with a placeholder for the type of
data they store or use. This makes your code more flexible and reusable. Let’s go through a simple
example to illustrate this.

Generic Class Example

Here’s a basic example of a generic class:

C#

using System;

public class Box<T>

{
public T Item { get; set; }

public void DisplayItem()

{
Console.WriteLine("The item is: " + Item);
}
}

public class Program

{
public static void Main()
{
// Creating a Box for an integer
Box<int> intBox = new Box<int>();
intBox.Item = 123;
intBox.DisplayItem(); // Output: The item is: 123

// Creating a Box for a string

Box<string> strBox = new Box<string>();
strBox.Item = "Hello, Generics!";
strBox.DisplayItem(); // Output: The item is: Hello, Generics!
}
}
Explanation

1. Generic Class Definition: The Box<T> class is defined with a type parameter T. This means T can
be any type (e.g., int, string, etc.).

2. Property: The Item property is of type T, so it can hold any type of data.

3. Method: The DisplayItem method prints the value of Item.

4. Instantiation: In the Main method, we create instances of Box for different types
(int and string).
Generic Method Example

You can also create generic methods. Here’s an example:

C#

using System;

public class Utilities

{
public static void Print<T>(T value)
{
Console.WriteLine("Value: " + value);
}
}

public class Program

{
public static void Main()
{
Utilities.Print(100); // Output: Value: 100
Utilities.Print("Generics are powerful!"); // Output: Value: Generics are powerful!
}
}
Explanation

1. Generic Method Definition: The Print<T> method is defined with a type parameter T.

2. Method Body: The method prints the value passed to it.

3. Method Call: In the Main method, we call Print with different types of arguments
(int and string).

Generics help you write more flexible and reusable code by allowing you to work with any data type
without sacrificing type safety12.

Constrain a generic type

In C#, you can constrain a generic type using the where keyword. This allows you to specify certain
requirements that the type argument must meet. Here are some common constraints you can apply:

Types of Constraints

1. Reference Type Constraint: Ensures the type is a reference type.

C#
public class MyClass<T> where T : class
{
// T must be a reference type
}

2. Value Type Constraint: Ensures the type is a value type.

C#
public class MyStruct<T> where T : struct
{
// T must be a value type
}

3. Default Constructor Constraint: Ensures the type has a parameterless constructor.

C#
public class MyClass<T> where T : new()
{
public T CreateInstance()
{
return new T();
}
}

4. Base Class Constraint: Ensures the type is or derives from a specified base class.
C#
public class MyClass<T> where T : MyBaseClass
{
// T must be MyBaseClass or derived from MyBaseClass
}

5. Interface Constraint: Ensures the type implements a specified interface.

C#
public class MyClass<T> where T : IMyInterface
{
// T must implement IMyInterface
}

6. Unmanaged Constraint: Ensures the type is an unmanaged type.

C#
public class MyClass<T> where T : unmanaged
{
// T must be an unmanaged type
}

Example with Multiple Constraints

You can also combine multiple constraints:
C#
public class MyClass<T> where T : class, IMyInterface, new()
{
// T must be a reference type, implement IMyInterface, and have a parameterless constructor
}

Practical Example
Here’s a practical example that combines several constraints:
C#
using System;

public interface IDisplayable

{
void Display();
}

public class MyClass<T> where T : class, IDisplayable, new()

{
public void Show()
{
T obj = new T();
obj.Display();
}
}

public class DisplayItem : IDisplayable

{
public void Display()
{
Console.WriteLine("Displaying item...");
}
}

public class Program

{
public static void Main()
{
MyClass<DisplayItem> myClass = new MyClass<DisplayItem>();
myClass.Show(); // Output: Displaying item...
}
}

In this example:
  T must be a reference type (class), implement the IDisplayable interface, and have a
parameterless constructor (new()).
Constraints help ensure that the types used with your generics meet specific requirements, making your
code safer and more predictable
Arithmetical Operation on Generic
In C#, performing addition on generic types requires some additional considerations because operators
like + are not directly supported on generic types. However, with the introduction of .NET 7 and C# 11,
you can use the new generic math interfaces to achieve this.
Here’s how you can use the + operator on a generic type by leveraging the INumber<T> interface:
1. Define a Generic Method with Constraints: Use the INumber<T> interface to constrain your
generic type to numeric types.
2. Implement the Addition: Use the + operator within the method.
Here’s an example:
C#
using System.Numerics;

public static class MathOperations

{
public static T Add<T>(T left, T right) where T : INumber<T>
{
return left + right;
}
}

class Program
{
static void Main()
{
int resultInt = MathOperations.Add(3, 5);
double resultDouble = MathOperations.Add(2.5, 4.3);

Console.WriteLine($"Integer addition: {resultInt}");

Console.WriteLine($"Double addition: {resultDouble}");
}
}
AI-generated code. Review and use carefully. More info on FAQ.
In this example:
 The Add method is generic and constrained to types that implement the INumber<T> interface.
 The INumber<T> interface includes the + operator, allowing you to perform addition on the
generic type T.
This approach ensures type safety and allows you to perform mathematical operations on any numeric
type that implements INumber<T>1.
========================================
Generic Collection
2. Generic Collections

Generic Collections work on the specific type that is specified in the program whereas non-generic
collections work on the object type.
a. Specific type
b. Array Size is not fixed
c. Elements can be added / removed at runtime.
C# List
1. using System.Collections.Generic;
2.
3. protected void Button1_Click(object sender, EventArgs e)
4. {
5. List<int> lst = new List<int>();
6. lst.Add(100);
7. lst.Add(200);
8. lst.Add(300);
9. lst.Add(400);
10. foreach (int i in lst)
11. {
12. Response.Write(i+"<br>");
13. }
14. }
C# Dictonary
1. using System.Collections.Generic;
2.
3. protected void Button1_Click(object sender, EventArgs e)
4. {
5. Dictionary<int, string> dct = new Dictionary<int, string>();
6. dct.Add(1, "cs.net");
7. dct.Add(2, "vb.net");
8. dct.Add(3, "vb.net");
9. dct.Add(4, "vb.net");
10. foreach (KeyValuePair<int, string> kvp in dct)
11. {
12. Response.Write(kvp.Key + " " + kvp.Value);
13. Response.Write("<br>");
14. }
15. }

C# SortedList
1. using System.Collections.Generic;
 2.

3. protected void Button3_Click(object sender, EventArgs e)

4. {
5. SortedList<string, string> sl = new SortedList<string, string>();
6. sl.Add("ora", "oracle");
7. sl.Add("vb", "vb.net");
8. sl.Add("cs", "cs.net");
9. sl.Add("asp", "asp.net");
10.
11. foreach (KeyValuePair<string, string> kvp in sl)
12. {
13. Response.Write(kvp.Key + " " + kvp.Value);
14. Response.Write("<br>");
15. }
16. }

C# Stack
1. using System.Collections.Generic;

2.

3. protected void Button4_Click(object sender, EventArgs e)

4. {
5. Stack<string> stk = new Stack<string>();
6. stk.Push("cs.net");
7. stk.Push("vb.net");
8. stk.Push("asp.net");
9. stk.Push("sqlserver");
10.
11. foreach (string s in stk)
12. {
13. Response.Write(s + "<br>");
14. }
15. }

C# Queue
1. using System.Collections.Generic;

2. protected void Button1_Click(object sender, EventArgs e)

3. {
4. Queue<string> q = new Queue<string>();
5.
6. q.Enqueue("cs.net");
7. q.Enqueue("vb.net");
8. q.Enqueue("asp.net");
9. q.Enqueue("sqlserver");
10.
11. foreach (string s in q)
12. {
13. Response.Write(s + "<br>");
14. }
15. }