GENERIC TYPE

PUBLISHED 10/03/2023

CONTENTS

SECTIONS

• GENERIC TYPE

  • ADVANTAGES OF GENERICS

• GENERIC CLASS

  • GENERIC CLASS CHARACTERISTICS

  • INSTANTIATING GENERIC CLASS

• GENERIC FIELDS

• GENERIC METHODS

  • INSTANTIATING GENERIC METHODS

KEYWORDS

• TYPE PARAMETER --> a placeholder for a particular type specified when creating an instance of the generic type

GENERIC TYPE

Generic in C# means not specific to a particular data type.

C# allows programmers to define generic class, interfaces, abstract classes, fields, methods, static methods, properties, delegates, events, and operators using the Type Parameter and without the specific data type

TYPE PARAMETER --> a placeholder for a particular type specified when creating an instance of the generic type --> Declared by specifying a type parameter in angled brackets after a type name

TypeName<T> --> Where T is a type parameter

ADVANTAGES OF GENERICS

1. Increase the reusability of the code --> Do not need to rewrite code to handle different data types

2. Generics are type-safe --> program will throw compile-time errors if you try to use a different data type than the one specified in the definition

3. Generics has a performance advantage because it removes the possibilities of boxing and unboxing

GENERIC CLASS

Generic classes are defined using a type parameter in an angled bracket after the class name

class DataStore<T>
{
    public T data {get; set;}
}

• DataStore is a generic class

• T is the Type Parameter

  • Can be used as a type of field, property, method parameter, return type, or delegates in the DataStore Class

IT IS NOT REQUIRED TO USE THE TERM T TO REFERENCE A TYPE PARAMETER

--> Programs can give any name to a type parameter -->Generally T is used when there is only ONE type parameter referenced --> It is recommended to use a more readable type parameter name as per requirement

--> TSession --> TKey --> TValue

You can also define multiple type parameters separated by a comma

class KeyValuePair<TKey, TValue>
{
    public TKey key {get; set;}
    public TValue value {get; set;}
}

GENERIC CLASS CHARACTERISTICS

1. A generic class increases the reusability -->the more type parameters used, the more reusable the code becomes --> too much generalization makes code difficult to understand and maintain

2. A generic class can be a base class to other generic or non-generic classes or abstract classes

3. A generic class can be derived from other generic or non-generic interfaces, classes, or abstract classes

INSTANTIATING GENERIC CLASS

A program can create an instance of generic classes by specifying an actual data type in angle brackets

DataStore<String> store = new DataStore<string>();

The above line of code creates an instance of the generic class DataStore. It specifies the string type in angle brackets while creating the instance... --> T will be replaced with a string type wherever T is used in the entire class @ compile-time --> The type of Data property would be string

GENERIC FIELDS

A generic class can include generic fields, which CANNOT be initialized

class DataStore<T>
{
    public T data;
    public T[] data = new T[10]; //Creates a generic array
}

GENERIC METHODS

A method declared with the type parameters for its return type or parameters is called a generic method

class DataStore<T>
{
    private T[] _data = new T[10];
    
    public void AddOrUpdate(int index, T item)
    {
        _data[index] = item;
    }

    public T GetData(int index)
    {
        if(index >= 0 && index < 10)
        {
            return _data[index];
        }
        else
        {
            return default(T);
        }
    }
}

The AddOrUpdate() and the GetData() methods are generic methods

--> The actual data type of the item parameter will be specified at the time of instantiating the DataStore<T> class

INSTANTIATING GENERIC METHODS

DataStore<string> cities = new DataStore<string>();
cities.AddOrUpdate(0, "Mumbai");
cities.AddOrUpdate(1, "Chicago");
cities.AddOrUpdate(2, "London");

DataStore<int> empIds = new DataStore<int>();
empIds.AddOrUpdate(0, 50);
empIds.AddOrUpdate(1, 65);
empIds.AddOrUpdate(2, 89);

A non-generic class can also include generic methods by specifying a type parameter in angle brackets with the method name