using System;

using System.Collections.Generic;

/*

 We have learned about the collection in the previous section, e.g. ArrayList, BitArray, SortedList, Queue, Stack and Hashtable. These types of collections can store any type of items. 

 For example, ArrayList can store items of different data types:

    ArrayList arList = new ArrayList();

    arList.Add(1);

    arList.Add("Two");

    arList.Add(true);

    arList.Add(100.45);

    arList.Add(DateTime.Now);

 The limitation of these collections is that while retrieving items, you need to cast into the appropriate data type, otherwise the program will throw a runtime exception. 

 It also affects on performance, because of boxing and unboxing.  Boxing and unboxing is on the heap not the stack.  Thus slower due to conversion between object ref and typed value.

 To overcome this problem, C# includes generic collection classes in the System.Collections.Generic namespace.

 The following are widely used generic collections: 

​

    Generic Collections         Description

    List<T>                     Generic List<T> contains elements of specified type. It grows automatically as you add elements in it.

    Dictionary<TKey,TValue>     Dictionary<TKey,TValue> contains key-value pairs.

    SortedList<TKey,TValue>     SortedList stores key and value pairs. It automatically adds the elements in ascending order of key by default.

    Hashset<T>                  Hashset<T> contains non-duplicate elements. It eliminates duplicate elements.

    Queue<T>                    Queue<T> stores the values in FIFO style (First In First Out). It keeps the order in which the values were added. It provides an Enqueue() 

                                    method to add values and a Dequeue() method to retrieve values from the collection.

    Stack<T>                    Stack<T> stores the values as LIFO (Last In First Out). It provides a Push() method to add a value and Pop() & Peek() methods to retrieve values.

​

A generic collection gets all the benefit of generics. It doesn't need to do boxing and unboxing while storing or retrieving items and so performance is improved. 

​

*/

​

​

public class Program

{

    public static void Main()

    {

        //Example: Generic List<T> Initialization

        //List<int> intList = new List<int>();  OR  IList<int> intList = new List<int>();

        //In the object-oriented programming, it is advisable to program to interface rather than concrete class. So use IList<T> type variable to create an object of List<T>.

        IList<int> intList = new List<int>();

        intList.Add(10);

        intList.Add(20);

        intList.Add(30);

        intList.Add(40);

        IList<string> strList = new List<string>();

        strList.Add("one");

        strList.Add("two");

        strList.Add("three");

        strList.Add("four");

        strList.Add("four");

        strList.Add(null);

        strList.Add(null);

        IList<Student> myStudentList = new List<Student>();

        myStudentList.Add(new Student("James", 1));

        myStudentList.Add(new Student("John", 2));

        myStudentList.Add(new Student("Luke", 3));

        myStudentList.Add(new Student("Matthew", 4));

        myStudentList.Add(new Student("Mark", 5));

        //IList<T> We can also use Initializer Syntax to shorten our statement

        IList<Student> myDetentionList = new List<Student>(){

            new Student("Saul",10),

            new Student("Cain",20),

            new Student("Judas",30),

            new Student("Pilate",40)

        };

        //List<T>

        List<string> booksBible = new List<string>(){

            {"Genesis"},

            {"Exodus"},

            {"Numbers"},

            {"Judges"}

        };

​

        //List<T> includes more helper methods than IList<T> interface.  

        //To iterate List

        Console.WriteLine("Iterate List<T>");

        booksBible.ForEach(li => Console.WriteLine(li));

        //To iterate IList.  .ForEach not an available method for IList

        Console.WriteLine("{0}Iterate IList<T>",System.Environment.NewLine);

        foreach (var li in myStudentList) Console.WriteLine("Student {0} {1}", li.ID, li.Name );

        //List items can be accessed via indexer [].

        IList<int> intListQuick = new List<int>() { 10, 20, 30, 40 };

        int elem = intList[1]; // returns 20

​

​

    }

}

​

public class Student

{

    private string _name;

    private int _id;

    public Student(string name, int id){

        _name = name;

        _id = id;

    }

    public string Name {

        get{ return _name; }

        set{ _name = value; }

    }

    public int ID { 

        get{ return _id; }

        set{ _id = value; }

    }   

}

​

​

​

​