Generic

C# generics and C++ templates are very similar but they work differently. Generic exist to write code that is reusable across different types.

Let’s imagine we need a stack of integers if we didn’t have generic types, one solution is to hard code a separate version of a class for every required type “IntStack” but when we need stack of string have do the same way “StrStack”. This would cause considerable code duplication.

However this wouldn’t work aAnother solution would be write a stack that is generalizes by using Object as element type.s well hard coded “IntStack” & “StrStack” an “ObjectStack” require boxing & down casting that could not be checked at compile time.

int x = (int)stack.Pop(); // down casting

What we need is both a general implementation of a stack that works for all element type, and a way to easily specialize that stack to a specific element type for increased type safety and reduced boxing and casing.

Generics provide this by allowing parameterize element type.  Stack<T>  has the benefits of both “ObjectStack” and “IntStack”.

Test this example for further understanding.

    class Part

    {

        private string _PartId;

        private string _PartName;

        private string _PartDescription;

        private double _Weight;

        public string PartId { get { return _PartId; } }

        public Part(string PartId, string PartName, string PartDescription, double Weight)

        {

            _PartId = PartId;

            _PartName = PartName;

            _PartDescription = PartDescription;

            _Weight = Weight;

        }

        public override string ToString()

        {

            return string.Format("Part Id: {0}, Part Name:{1}, Part Description:{2}, weight:{3}", _PartId, _PartName, _PartDescription, _Weight);

        }

    }

 

   //the actual indexer, which accepts the generic type

    //note the type must be a class (not a value type)

    class Indexer<T> where T:class

    {

        struct ItemStruct

        {

            public string Key;

            public T value;

            public ItemStruct(string key, T value)

            {

                this.Key = key;

                this.value = value;

            }

        }

        List<ItemStruct> _items = new List<ItemStruct>();

        // T must be a class so that can return null if not found

        public T Find(string key)

        {

            foreach (ItemStruct _ItemStruct in _items)

            {

                if (_ItemStruct.Key == key)

                {

                    return _ItemStruct.value;

                }

            }

            return null;

        }

        public void Add(string key, T value)

        {

            _items.Add(new ItemStruct(key, value));

        }

    }

 

// Programe to Test it

    class Program

    {

        static void Main(string[] args)

        {

            Indexer<Part> indexer = new Indexer<Part>();

            Part p1 = new Part("001", "Mother Board", "Intel Chip set Mother Board", 0.75);

            Part p2 = new Part("002", "Processor", "Intel Core i5", 0.2);

            indexer.Add(p1.PartId, p1);

            indexer.Add(p2.PartId, p2);

            Part p = indexer.Find("002");

            Console.WriteLine(p.ToString());

           

            Console.ReadKey();

        }

    }