Home > DeveloperSection > Beginner > Collections in C#

Collections in C#


.NET C#  Collection 
Ratings:
0 Comment(s)
 1320  View(s)
Rate this:

Collections in C#

In this article, I’m explaining about collections in C#

What is collection?

Collection classes are specialized classes for data storage and retrieval. These classes provide support for stacks, queues, lists and hash tables.

Types of collections:

1.       System.Collections.Generic Classes

2.       System.Collections.Concurrent Classes

3.       System.Collections Classes

 

System.Collections collection:

The classes in System.collection namespace allows storing elements of any data type in a single collection. Every element is stored as an object of type object. So these collection classes are typically referred as non-generic classes. The following tabular lists some of the frequently used classes in System.Collections namespace.

 

ArrayList: Represents an array of objects whose size is dynamically increased as required.

Example of Arraylist:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Collections;

namespace ArraylistDemo

{

    class Program

    {

        static void Main(string[] args)

        {

            int[] arr = new int[4] { 1, 2, 3, 4 };

            string[] str = { "Pawan", "Priyanka", "Kamlakar" };

            string name = "Pawan";

//New ArrayList

            ArrayList arrlist = new ArrayList();

            arrlist.Add(str);

            arrlist.Add(arr);

            arrlist.Add(name);

            foreach (object obj in arrlist)

            {

                Type objtype = obj.GetType();

                if (objtype.IsArray)

                {

                    if (objtype == typeof(System.Int32[]))

                    {

                        int[] strlist = (int[])obj;

                        for (int i = 0; i < strlist.Length; i++)

                            Console.WriteLine(strlist[i]);

                    }

                    else

                    {

                        String[] stringArray = (String[])obj;

                        for (int i = 0; i < stringArray.Length; i++)

                            Console.WriteLine(stringArray[i]);

                    }

                }

                 else

                {

                    Console.Write(obj.ToString());

                }

            }

            Console.ReadKey();

        }

    }

}

 

 

Output:

Pawan

Priyanka

Kamlakar

1

2

3

4

Pawan

               

Hashtable: Represents a collect of key & value pair that are organized based on the hash code of the key.

Example of HastTable:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Collections;

namespace HashDemo

{

    class Program

    {

        static Hashtable getHashData()

        {

            Hashtable hsttbl = new Hashtable();

            string str;

            for(int i=0;i<3;i++)

            {

                str=Console.ReadLine();

                hsttbl.Add(i, str);

            }

            return hsttbl;

        }

        static void Main(string[] args)

        {

            Hashtable hasttable = getHashData();

            foreach (DictionaryEntry entry in hasttable)

            {

                Console.WriteLine("{0}{1}",entry.Key,entry.Value);

            }

            Console.ReadKey();

        }

    }

}

 

Output:

1 priyanka

2 Sita

3 Ram

 

Queue: Represents a first in first out collection of objects.

 

Stack: Represents a last in first out collection of object.

 

System.Collections.Generic classes                 

A generic collection is typically used to store the items in of the same data type. It enforces strong typing by allowing only the desired data type to be added. Datatype has to be specified at the time of instantiation of generic classes.

The following tabular lists some of the frequently used classes of this namespace:

Dictionary<TKey,TValue>: Represents a collection of key & value pairs that are organized based on the key.

Example:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

 

 

namespace DictionaryExample

{

    class Program

    {

        static void Main(string[] args)

        {

            Dictionary<string, string>DictValues = new Dictionary<string, string>();

            DictValues.Add("cat","feline");

            DictValues.Add("dog", "Canine");

            string test;

            Console.Write("Enter the key");

            test=Console.ReadLine();

           

            if (DictValues.ContainsKey(test))

            {

                string value=DictValues[test];

                Console.Write("Value:"+value);

            }

            Console.ReadKey();

        }

    }

}

 

Output:

Enter key: dog

Value: Cania

List<T>: Represents a list of objects that can be accessed by index. Provides methods to search, sort and modified lists.

Example:

 

using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

 

namespace IListExample

{

    class Program

    {

        static void Main(string[] args)

        {

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

            ilst.Add("Sita");

            ilst.Add("Geeta");

            foreach (string num in ilst)

                Console.WriteLine(num);

            Console.ReadKey();

        }

    }

}

Output:

Sita

Geeta

 

Queue<T>: Represent a first in first out (FIFO) collection of objects.

Example:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Collections;

namespace QueueListDemo

{

    class Program

    {

        static void Main(string[] args)

        {

            ArrayList list = new ArrayList();

            String[] str=new String[5];

           

            for (int i = 0; i< str.Length; i++)

            {

           Console.WriteLine("enter  string");

            str[i]=Console.ReadLine();

            }

//New Queue

            Queue<string>que = new Queue<string>(str);

            Console.WriteLine("queue representation");

            foreach (var item in que)

              Console.WriteLine(item);

        

 

            Console.WriteLine("Enqueue Example");

            string stren;

            Console.WriteLine("Enter a string");

          stren= Console.ReadLine();

//Add an item in Queue

            que.Enqueue(stren);

            Console.WriteLine("Enqueue Representation");

            foreach (var en in que)

                Console.WriteLine(en);

//Remove the oldest item from Queue

            que.Dequeue();//Remove first element;

            Console.WriteLine("After removal the element in the  queue are:");

            foreach (var en in que)

                Console.WriteLine(en);

            Console.ReadKey();

        }

    }

}

Output:

1

2

3

4

5

 

SortedList<T>: Represents a collection of key &value pairs that are sorted by key based on the associated IComparer<T> implement.

Example:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Collections;

namespace SortListExample

{

    class Program

    {

        static void Main(string[] args)

        {

            SortedList s1 = new SortedList();

            s1.Add("1","B");

            s1.Add("2", "T");

            s1.Add("3", "W");

            foreach (string st in s1.Values)

                Console.WriteLine(st);

            Console.ReadKey();

        }

    }

}

 

Stack<T>: Represent a last in first out collection of objects.

Example of Stack:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Collections;

namespace QueueListDemo

{

    class Program

    {

        static void Main(string[] args)

        {

            ArrayList list = new ArrayList();

            String[] str = new String[5];

 

            for (int i = 0; i < str.Length; i++)

            {

                Console.WriteLine("enter  string");

                str[i] = Console.ReadLine();

            }

 

            Stack<string>stk = new Stack<string>(str);

            Console.WriteLine("Stack representation");

            foreach (var item in stk)

                Console.WriteLine(item);

 

            Console.ReadKey();

        }

    }

}

Output:

5

4

3

2

1

 System.Collections.Concurrent Classes

The System.Collections.Concurrent namespace provide efficient thread-safe operations for accessing collection items concurrently from multiple threads.

Some classes included in the System.Collections.Concurrent namespace are

BlockingCollection<T>: Provides blocking and bounding capabilities for thread-safe collections that implement IProducerConsumerCollection<T>.

Example:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Collections;

using System.Collections.Concurrent;

using System.Threading;

 

namespace BlockingCollectionExample

{

 

    class Program

    {

        private static BlockingCollection<string> que = new BlockingCollection<string>();

        private static void RunProducer()

        {

            int itemCount = 100;

            while (itemCount-- > 0)

            {

                que.Add(itemCount + "-" + Guid.NewGuid().ToString()+"Producer");

                Thread.Sleep(500);

            }

        }

        private static void RunConsumer()

        {

            foreach (var item in que.GetConsumingEnumerable())

                Console.WriteLine(DateTime.Now.ToString("HH:mm:ss.ffff")+"|"+item);

        }

        public static void start()

        {

            var producerWorker = Task.Factory.StartNew(()=>RunProducer());

            var ConsumerWorker = Task.Factory.StartNew(() => RunConsumer());

        }

        static void Main(string[] args)

        {

            start();

            Console.ReadKey();

         

        }

    }

}

 

Output:

 

ConcurrentBag<T>: Represent a thread-safe, unordered collection of objects.

Example:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Collections.Concurrent;

using System.Threading;

using System.Collections;

namespace ConcurrentBagExample

{

    class Program

    {

 

         static ConcurrentBag<int> conbag = new ConcurrentBag<int>();

       

     

        static void Main(string[] args)

        {

        

            conbag.Add(1);

            conbag.Add(2);

            conbag.Add(3);

            int result;

            if (conbag.TryPeek(out result))

            { Console.WriteLine("TryPeek:{0}", result);

            }

            if (conbag.TryTake(out result))

                Console.WriteLine("TryTake:{0}", result);

            if (conbag.TryPeek(out result))

                Console.WriteLine("TryPeek:{0}", result);

            Console.ReadKey();

        }

    }

}

 

Output:

TryPeek: 3

TryTake: 3

TryPeek: 2

ConcurrentDictionary<TKey,TValue>: Represents thread-safe collection of key/value pairs that can be accessed by multiple threads concurrently.

Example:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Collections.Concurrent;

namespace ConcurrentDictionaryExample

{

    class Program

    {

        static void Main(string[] args)

        {

            var con = new ConcurrentDictionary<string, int>();

            con.TryAdd("String1",1);

            con.TryAdd("String2",2);

            Console.WriteLine(con["String1"]);

            //Try to update if value is 3(this fails)

            con.TryUpdate("String1", 10, 3);

            Console.WriteLine(con["String1"]);

          //Try to update if value is 1(this works)

           con.TryUpdate("String1",10,1);

           Console.WriteLine(con["String1"]);

            Console.ReadKey();

        }

    }

}

 

Output:

1

1

10

ConcurrentQueue<T>: Represent a thread-safe first in first out collection

Example:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Collections.Concurrent;

using System.Threading;

namespace ConcurrentQueue

{

    class Program

    {

        static long _total;

        static ConcurrentQueue<int> _queued;

     

   

        static void ProcessQueue()

        {

            int value;

 

            while (_queued.TryDequeue(out value))

            {

                Interlocked.Add(ref _total, value);

            }

        }

        static void Main(string[] args)

        {

            IEnumerable<int> numbers = Enumerable.Range(1, 1000000);

            _queued = new ConcurrentQueue<int>(numbers);

            _total = 0;

 

            Task task1 = Task.Run(() => ProcessQueue());

            Task task2 = Task.Run(() => ProcessQueue());

 

            Task.WaitAll(task1, task2);

 

            Console.WriteLine("Total: {0}", _total);

            Console.ReadKey();

        }

    }

}

Output:

Total: 500000500000

ConcurrentStack<T>: Represent a thread-safe last in first out collection.

Example:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Collections;

using System.Threading;

using System.Collections.Concurrent;

 

namespace ConcurrentStackExample

{

    class Program

    {

     static ConcurrentStack<string> constack = new ConcurrentStack<string>();

      static  void pushMethod()

        {

            string str;

            for (int i = 0; i < 5; i++)

            {

              

                Console.WriteLine("Enter the element");

                str = Console.ReadLine();

                constack.Push(str);

            }

        }

        static void Main(string[] args)

        {

            pushMethod();

            int counter = 0;

            Task[] stkTask = new Task[10];

 

            Console.WriteLine("Stack Representation");

            for (int i = 0; i < stkTask.Length; i++)

            {

                stkTask[i] = Task.Factory.StartNew(() =>

                {

                    while (constack.Count > 0)

                    {

                        string currelement;

                        bool success = constack.TryPop(out currelement);

                        if (success)

                        {

                            Interlocked.Increment(ref counter);

                        }

                        Console.WriteLine(currelement);

                    }

                }

               );

            }

            Task.WaitAll(stkTask);

            Console.WriteLine("Counter: {0}", counter);

          

            Console.ReadKey();

        }

    }

}

 

Output:

Enter the element

4

Enter the element

3

Enter the element

2

Enter the element

1

Enter the element

5

Stack Representation

5

1

2

3

4

Counter: 5

 

 

 


Don't want to miss updates? Please click the below button!

Follow MindStick