Collections In C#

using System;
class Arrays {
    public void arrayExample {
        //Declaring an Array
        int[] array = new int[8];
        //Adding value to array
        array[0] = 55;
        array[1] = 78;
        array[2] = 99;
        array[4] = 13;
        array[5] = 9;
        //Length of the Array
        Console.WriteLine("Length of the Array: " + array.Length);
        //printing the elements of Array
        Console.WriteLine("Elements in Array are: ");
        foreach(int elementsArray in array) {
            Console.Write(elementsArray + " ");
        }
        //Sorting of array elements
        Array.Sort(array);
        //Printing Sorted Elements
        Console.WriteLine("\nElements After Sorting: ");
        foreach(int sortElements in array) {
            Console.Write(sortElements + " ");
        }
        //Reversing the Elements
        Array.Reverse(array);
        //Printing Reversed Array
        Console.WriteLine("\nReversed Array");
        foreach(int reversedArray in array) {
            Console.Write(reversedArray + " ");
        }
        //Copying Array elements to other Array
        int[] copyArray = new int[10];
        //Copy will Take Source Array Destination Array and no of elements we wanna copy
        Array.Copy(array, copyArray, 6);
        //Printing elements of array copyArray
        Console.WriteLine("Elements in New Array");
        foreach(int copyArrayElements in copyArray) {
            Console.Write(copyArrayElements + " ");
        }
        //Resizing Array
        Array.Resize(ref array, 10);
        //New Size of the Array
        Console.WriteLine("\nAfter Resizing Length of the Array:" + array.Length);
    }
}

Length of the Array: 8
Elements in Array are:
55 78 99 0 13 9 0 0
Elements After Sorting:
0 0 0 9 13 55 78 99
Reversed Array
99 78 55 13 9 0 0 0 Elements in New Array
99 78 55 13 9 0 0 0 0 0
After Resizing Length of the Array:10

using System;
using System.Collections;
class Array_List {
    public void arrayListExample() {
        //Creating Array List
        ArrayList arlist = new ArrayList();
        //Length of Array List
        Console.WriteLine("Length of Array List is: " + arlist.Capacity);
        //Adding Values in Array List
        arlist.Add(1); //Int Value
        arlist.Add("Hello C# Developers"); //String Value
        arlist.Add(true); //Boolean Value
        arlist.Add(DateTime.Now); //DateTime
        arlist.Add(1.2); //Double value
        Console.WriteLine("Data Added Successfully!!");
        //Again Check for Length of ArrayList
        Console.WriteLine("After Adding the Data Length of ArrayList is: " + arlist.Capacity);
        //Printing elements from ArrayList
        Console.WriteLine("Elements In ArrayList are: ");
        foreach(object values in arlist) {
            Console.WriteLine(values);
        }
        //Adding Element in Middle of the Array List
        arlist.Insert(2, "Inserted In Between");
        //Printing Result
        Console.WriteLine("Elements After Inserting value in Middle:");
        foreach(object newValues in arlist) {
            Console.WriteLine(newValues);
        }
        //Removing Element from the Middle of the Array List
        arlist.RemoveAt(4);
        //Printing Result
        Console.WriteLine("Elements After Removing one Element from Middle: ");
        foreach(object updatedValues in arlist) {
            Console.WriteLine(updatedValues);
        }
    }
}

Length of Array List is: 0
Data Added Successfully!!
After Adding the Data Length of ArrayList is: 8
Elements In ArrayList are:
1
Hello C# Developers
True
04/04/2022 09:55:25
1.2
Elements After Inserting value in Middle:
1
Hello C# Developers
Inserted In Between
True
04/04/2022 09:55:25
1.2
Elements After Removing one Element from Middle:
1
Hello C# Developers
Inserted In Between
True
1.2

using System;
using System.Collections;
class SortedListEx {
    public void SortedListExample() {
        //Creating new Sorted List
        SortedList sortedList = new SortedList();
        //Adding Key Value Pairs to SortedList
        sortedList.Add(4, "This is Fourth");
        sortedList.Add(3, "This is Third");
        sortedList.Add(2, 2);
        sortedList.Add(1, DateTime.Now);
        //Printing Values
        foreach(object values in sortedList.Values) {
            Console.WriteLine(values);
        }
    }
}

04/04/2022 12:20:28
2
This is Third
This is Fourth

using System;
using System.Collections;
class StackEx {
    public void StackExample() {
        //Creating Stack
        Stack stack = new Stack();
        //Pushing Values into it
        stack.Push(1);
        stack.Push("Second");
        stack.Push(3.0);
        stack.Push(true);
        stack.Push(null);
        stack.Push(DateTime.Now);
        stack.Push("This is to be Popped");
        //Popping Out Value
        stack.Pop();
        //Printing Out Values inside Stack
        Console.WriteLine("Values Inside the Stacke Are:");
        foreach(object values in stack) {
            Console.WriteLine(values);
        }
        //Values at top of the Stack
        Console.WriteLine("Values at Top of the Stack is:" + stack.Pop());
    }
}

Values Inside the Stacke Are:
04/04/2022 13:08:48
True
3
Second
1
Values at Top of the Stack is:04/04/2022 13:08:48

Queue is used in FIFO (First In First Out) Collections of Object. Generally, if we need to retrieve the values in a manner in which they are stored then we use Queue. Enqueue() and Dequeue() methods are used to add and remove the values from the Queue.

C# Non Generic Queue is defined under System.Collections namespace.

Let's have a look at an example:

using System;
using System.Collections;
class QueueEx {
    public void QueueExample() {
        //Creating Queue
        Queue queue = new Queue();
        //Adding Element to Queue
        queue.Enqueue("Element to be Delete");
        queue.Enqueue(1);
        queue.Enqueue("Second");
        queue.Enqueue(3.0);
        queue.Enqueue(null);
        queue.Enqueue(true);
        queue.Enqueue(DateTime.Now);
        //Removing First Element
        queue.Dequeue();
        //Printing Elements from the Queue
        Console.WriteLine("Elements in the Queue are");
        foreach(object values in queue) {
            Console.WriteLine(values);
        }
    }
}

Above program results in the following output:

Elements in the Queue are
1
Second
3
True
04/04/2022 13:30:15

So, from the above example we can conclude that in Queue during retrieving we gets the output in an order in which it was inserted.

C# Non-Generic Hashtable

Hashtable is a Collection of the Key Value Pairs which are arranged on the basis of the hash code of the key. During accessing the value hashcode of the key is mapped to the specific key and then value is returned.

C# Non Generic Hashtable is defined under System.Collections namespace.

Let's have a look at an example:

using System;
using System.Collections;
class HashtableEx {
    public void HashtableExample() {
        //Creating Hashtable
        Hashtable hashtable = new Hashtable();
        //Adding Key Value Pair in Hashtable
        hashtable.Add(1, "This is First");
        hashtable.Add("2", "This is Second");
        hashtable.Add(true, "This is true");
        //Retrieving data DictionaryEntry is Used to retrieve values in Key/Value Form
        foreach(DictionaryEntry data in hashtable) {
            Console.WriteLine("Key: " + data.Key + " Value: " + data.Value);
        }
    }
}

Above program results in the following output:

Key: True Value: This is true
Key: 1 Value: This is First
Key: 2 Value: This is Second

So, from the above example we can conclude that the Key and the Value that are retrieved are in order of the HashCode of their Specific Key.

Here, also note that Key and value can be stored in any type of Data.

These were all the Non Generic way to store the Data in the Collections So from above all the Non Generic Collections we can Conclude some Advantages and Disadvantages of Non Generic type Collection.

Advantages

1. As there is no restriction on its size, it grows and shrinks dynamically.
2. We get lots of Method to Add and Remove the elements from the middle of the Collections.
3. We can store value of any data type in the similar Non Generic Collections.

Disadvantages

1. Non-generic collections are not type-safe as they operate on object data type so they can store any type of value.
2. Loosley typed collections can also cause performance overhead, because Boxing and Unboxing happens.

So far, we have seen that the traditional way to store and manage elements i.e an array, but it has a limited size.

In addition, there are non-generic collections that can be used to store and manage elements. However, these collections have limitations as to type safety.

C# Generic Collections solve both of these problems. Since they are type safe and don't have size limitations.

Generic Collections

The Generic Collections are Strongly Typed Collections. These Collections’s Classes only allows one type of value to use. They Eliminate the Type-Mismatch runtime error as well as operations on this type of collections are faster because they don’t require to perform boxing and unboxing while manipulating. So, It is always a preferable and a good choice to use the Generics Collections in C# rather than using the Non-Generic Collections.

The Generic Collection classes are implemented under the System.Collections.Generic namespace.

It Includes:

1. Stack<T>: Performs Operations similar to Non Generic Stack but it only works on one type of data.
2. Queue<T>: Similar to Non Generic Queue but queue also works on one type of data.
3. LinkedList<T>: In LinkedList Both the Previous and Next Node are linked with each other.
4. SortedList<TKey,TValue>: It works similar to the Non Generic SortedList But it works on one type of data.
5. List<T>: It works similiar to Non Generic ArrayList but this is only for one type of data.
6. Dictionary<TKey,TValue>: It Stores the key value pairs of one same type of data.

Note: Here 'T' is a type of elements that we need to store into them.

Let's take a look at each of them one by one:

C# Generic Stack<T>

Generic stacks contain only the types of values that will be specified during stack creation. It is a dynamic Collection that Grows on adding Elements into it. We can Perform Push() and Pop() For Adding and Removing the elements from the Stack.

C# Generic Stack is defined under System.Collections.Generic namespace.

Let's have a look at an example:

using System;
using System.Collections.Generic
class StackGN {
    public void StackGeneric() {
        //Creating Generic Stack
        Stack < int > stackInt = new Stack < int > ();
        //Pushing Values into Stack
        stackInt.Push(15);
        stackInt.Push(58);
        stackInt.Push(45);
        stackInt.Push(78);
        //Popping value from stack
        stackInt.Pop();
        //Printing Values of stack
        Console.WriteLine("Values inside Stack are:");
        foreach(int values in stackInt) {
            Console.WriteLine(values);
        }
    }
}

Above Program Results in the Following Output:

Values inside Stack are:
45
58
15

So, from the above program we can conclude that the Values that are Retrieved from the Stack are in LIFO Manner. However, the stack<int> will only store integer values, so type safety is maintained.

C# Generic Queue<T>

Queue stores elements in FIFO style (First In First Out), exactly opposite of the Stack<T> collection. Elements in Queue can be added using Enqueue() method and removed using Dequeue() method.

C# Generic Queue is defined under System.Collections.Generic namespace.

Let's have a look at an example:

using System;
using System.Collections.Generic;
class QueueGN {
    public void QueueGeneric() {
        //Creating Queue
        Queue < string > queue = new Queue < string > ();
        //Adding Elements
        queue.Enqueue("This is to be deleted");
        queue.Enqueue("This is First Value");
        queue.Enqueue("This is Second Value");
        queue.Enqueue("This is Third Value");
        //queue.Enqueue(4);   Error
        //Deleting Element
        queue.Dequeue();
        //Printing Elements
        Console.WriteLine("Elements Persent Inside Queue are:");
        foreach(string values in queue) {
            Console.WriteLine(values);
        }
    }
}

Above program results in the following output,

Elements Persent Inside Queue are:
This is First Value
This is Second Value
This is Third Value

From the above example we can conclude that when in Queue having type string if we try to add integer value then it gives Compile time error.

C# Generic LinkedList<T>

A Generic LinkedList Stores element in non Contigous manner. The elements in a linked list are linked with each other. There are various method used to add the element at various positions such as AddAfter(), AddBefore(), AddFirst(), AddLast() and many more.

C# Generic LinkedList is defined under System.Collections.Generic namespace.

Let's have a look at an example:

using System;
using System.Collections.Generic;
class LinkedListGN {
    public void LinkedListGeneric() {
        //Creating linked List
        LinkedList < string > linkedList = new LinkedList < string > ();
        //Adding Elements
        linkedList.AddLast("Nita");
        linkedList.AddFirst("Karishma");
        linkedList.AddLast("Shilpa");
        linkedList.AddLast(“Nita”);
        //Printing the Values
        Console.WriteLine("Elements in the LinkedList are:");
        foreach(string values in linkedList) {
            Console.WriteLine(values);
        }
    }
}

Above program results in the following output:

Elements in the LinkedList are:
Karishma
Nita
Shilpa
Nita

So, from the above example we can conclude that we can have duplicate value as well in Generic LinkedList but it should be of same data type.

C# Generic SortedList<TKey,TValue>

SortedList Stores the data in key and Value Pairs. We can access the element by using key or using index of the element. As it is Generic type so it will Contains only one type of key and one type of values.

C# Generic LinkedList is defined under System.Collections.Generic namespace.

Let's have a look at an example:

using System;
using System.Collections.Generic;
class SortedListGN {
    public void SortedListGeneric() {
        //creating Generic Sorted List
        SortedList < int, string > valuePairs = new SortedList < int, string > ();
        //Adding Values
        valuePairs.Add(2, "Komal");
        valuePairs.Add(1, "Lalit");
        valuePairs.Add(3, "Mohit");
        //valuePairs.Add(3, "Mohit"); Error Duplicate Key
        //Printing Values
        Console.WriteLine("Values in Generic Sorted List are:");
        foreach(KeyValuePair < int, string > entry in valuePairs) {
            Console.WriteLine(entry.Key + ":" + entry.Value);
        }
    }
}

Above program results in the following output:

Values in Generic Sorted List are:
1:Lalit
2:Komal
3:Mohit

From the above example we can conclude that Generic SortedList can contain Same type of key and their values will also contains the same type of elements but we can’t add the duplicate key.

C# Generic List<T>

Generic List is Pretty much similar to ArrayList in Non Generic Collections. Elements will be of one defined type and can be accessed through index. Elements can be Added using Add() method. Doesn’t need to perform boxing and unboxing due to generic type.

C# Generic List is defined under System.Collections.Generic namespace.

Let's have a look at an example:

using System;
using System.Collections.Generic;
class ListGN {
    public void ListGeneric() {
        //Creating a List
        List < string > Names = new List < string > ();
        //Adding Values to List
        Names.Add("Mark");
        Names.Add("Olie");
        Names.Add("Berik");
        //Displaying Names
        Console.WriteLine("Elements in List are: ");
        foreach(string names in Names) {
            Console.WriteLine(names);
        }
    }
}

Above program results in the following output:

Elements in List are:
Mark
Olie
Berik

From above example we can conclude that Generic List works in Similiar way as Array and ArrayList works but its Generic type so, type Safety and Size Limitation will not be an issue while working with Lists.

C# Generic Dictionary<TKey,TValue>

Generic Dictionary Stores the data in key and Value Pairs. Key should not be null when storing values, and it should be unique. There will be no order of storing the values in Dictionary.

C# Generic Dictionary is defined under System.Collections.Generic namespace.

Let's have a look at an example:

using System;
using System.Collection.Generic;
class DictionaryGN {
    public void DictionaryGeneric() {
        //Creating Dictionary
        Dictionary < int, string > valuePairs = new Dictionary < int, string > ();
        //Adding Values
        valuePairs.Add(1, "This is First Record");
        valuePairs.Add(2, "This is Second Record");
        valuePairs.Add(3, "This is Third Record");
        //Printing Values
        Console.WriteLine("Keys and their values in Dictionary are:");
        foreach(KeyValuePair < int, string > pair in valuePairs) {
            Console.WriteLine("Key: " + pair.Key + " Value: " + pair.Value);
        }
    }
}

Above Program Results in the Following Output:

Keys and their values in Dictionary are:
Key: 1 Value: This is First Record
Key: 2 Value: This is Second Record
Key: 3 Value: This is Third Record

So, this is how we can add and retrieve the elements from Generic Dictionary, Where we have mentioned key as an integer and value as a string and retrieved their value using keyValuePair<Tkey,Tvalue>, Which is used to store keyValuePair.

Thus we have used Generic collections for storing and manipulating data, therefore, based on that, we have concluded that Generic way is type-safe, i.e. we will get a compile time error if we use a different type of data rather than the one specified. It also makes the application run faster.

Conclusion

In this article, we first examined arrays and their implementation and then discussed their advantages and disadvantages. Then, in order to solve the problem of Arrays, i.e. size limitation, we looked into Non Generic Collections, which is efficient in solving the size limitation issue, but they have serious issues with type-safety. Then, we looked into Generic Collections that solve both the problems and are extremely efficient and flexible at the same time.

So, if you find this article helpful kindly share it with your friends