C# Basics - Generic

Purpose of Generic

When we program, we often come across code blocks with very similar structure but handle different data. We have no choice but to write multiple instance calls to handle different data types. At this point, is there a way to use the same method to deal with different types of parameters passed in? The Generic is specifically to solve this problem.

Let’s look at some codes.

namespace Generic
{
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
        }

        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            Test1 t1 = new Test1();
            Test2 t2 = new Test2();
            Test3 t3 = new Test3();
        }
    }

    public class Test1
    {
        public string v1;
        public string v2;
        public string v3;

        public void Test(string v)
        {
        }
    }
    public class Test2
    {
        public int v1;
        public int v2;
        public int v3;

        public void Test(int v)
        {
        }
    }

    public class Test3
    {
        public double v1;
        public double v2;
        public double v3;

        public void Test(double v)
        {
        }
    }
}

Test1, Test2, and Test3 have the same class structure, the only difference is they are handling different type of fields. Once we are required to handle another type of data, like float, we have to create another class specilized for float type, which is unacceptable and inconvinince.

Generic will help solve the problem.

namespace Generic
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
        }

        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            //Call generic class with the needed type.
            TestGeneric<float> testGeneric = new TestGeneric<float>();
        }
    }

    public class TestGeneric<T>
    {
        public T v1;
        public T v2;
        public T v3;

        public void Test(T v)
        {

        }
    }
}

Create a Generic is to add <T> to the class and change the type of fields to T. When you wanna use the class, simply call the class with replace T with the type you need in < > as below.

TestGeneric<float> testGeneric = new TestGeneric<float>();

Generic Type Constraints

C# allows you to use constraints to restrict client code to specify certain types while instantiating generic types. The way to add constraint is to use where keyword after a generic difinition.

public class Test<T> where T: [Type]

Let’s look at the previous example.

namespace Generic
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
        }

        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            //Call generic class with the needed type.
            TestGeneric<float> testGeneric = new TestGeneric<float>();
        }
    }

    //Add constratint of struct to generic class.
    public class TestGeneric<T> where T:struct
    {
        public T v1;
        public T v2;
        public T v3;

        public void Test(T v)
        {

        }
    }
}

where T:struct means the class is being restricted as using only value type.

//int is a value type, so it is valid to be called by generic class.
TestGeneric<int> testGeneric = new TestGeneric<int>();

//string is reference type, so it returns error.
TestGeneric<string> testGeneric2 = new TestGeneric<string>();

Based on different types of constraint, Generic can be used in many ways.

Generic Methods

This is a method to get the max one between two values.

public static T Max<T>(T a, T b) where T : IComparable<T>
{
    return a.CompareTo(b) > 0 ? a : b;
}

int maxInt = Max(1, 2);
double maxDouble = Max(1.2, 3.4);

Generic Interfaces

This is a Generic Interfaces can be used for database management.

public interface IRepository<T> where T : class
{
    T GetById(int id);
    void Add(T entity);
    void Update(T entity);
    void Delete(T entity);
}

public class ProductRepository : IRepository<Product>
{
    // implementation goes here...
}

Generic Delegate

This is a generic delegate that defines an input parameter T and a return value TResult.

public delegate TResult Func<in T, out TResult>(T arg);

Func<int, bool> isEven = n => n % 2 == 0;
bool result = isEven(4);

---

Good Day
😎