List vs IEnumerable vs IQueryable vs ICollection vs IDictionary
15:17
Introduction
In this post I explain about Collection, Array, ArrayList, HashTable, Stack, Queue, List, IList, IEnumerable, IQueryable, ICollection, IDictionary, Stack Generic, Queue GenericCollection
Collection is set of related records. It includes a meaningful unit: We should select appropriate container to store data temporarily for fetch and modification process. Appropriate container depends on: 1. Our aim which we want to do on data ( just reading, doing modification such as insert, delete, update ) 2. Number of records which should be transferred
Array
1. Fixed Length: Its size is not flexible. It is determined at instantiation time.2. Strongly Typed: Developers determine its type at the instantiation time instead of runtime. This feature makes to run fast at runtime, since it does not need to wait for type definition.
3. Developers use "foreach" keyword to fill and iterate through array.
Fixed Length and Strongly Typed consume less memory, therefore it has good performance.
//It is obvious that strArray is
//1. string --> Strongly Type
//2. Sized=10 --> Fixed Size
string[] strArray = new string[10];
for (int i = 0; i < 10; i++)
{
if (strArray[i]==null)
{
strArray[i] = (i+1).ToString();
}
}
var result = strArray;
ArrayList
1. Arraylist is NOT Fixed Length -> It is possible that data grows. On the one hand it is a good feature whenever developers are not sure about size of arraylist and on the other hand it might take long time for size definition.2. Arraylist is NOT Strongly Typed -> Whenever developers are not sure about what is exactly type definition for input or output data and they should wait until runtime to appear its type. Its disadvantage is time consuming at the runtime for memory to determine type definition.
3. Developers use "foreach" keyword to fill and iterate through arraylist.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ArrayList
{
class Program
{
static void Main(string[] args)
{
//It is NOT obvious that strArrayList is 1. string? int? object? decimal? --> NOT Strongly Type
// 2. Sized=10? 20? 100? --> NOT Fixed Size
// Namespace: System.Collections
System.Collections.ArrayList strArrayList = new System.Collections.ArrayList();
//System.Linq.IQueryable type of data is not specific runtime defered support
strArrayList.Add("Surajit"); // "Surajit": is string
strArrayList.Add(1); // 1 : is integer
strArrayList.Add(0.89); // 0.89: is decimal
this.ListBoxArrayList.DataSource = null;
this.ListBoxArrayList.Items.Clear();
this.ListBoxArrayList.DataSource = strArrayList;
this.ListBoxArrayList.DataBind();
System.Text.StringBuilder str = new System.Text.StringBuilder();
foreach (var item in strArrayList)
{
str.Append(" , " + item);
}
this.lblArrayList.Text = str.ToString();
// Below is old way to fill obj from product , in Arraylist you need to create more than one instance
// Product objProduct = new Product();
// objProduct.Code = "1001";
// objProduct.Name = "Chair";
// It is NOT obvious that strArrayList is
// 1. string? int? object? decimal? OR OBJECT?? --> NOT Strongly Type
// 2. Sized=10? 20? 100? -->NOT Fixed Size
// Namespace: System.Collections
System.Collections.ArrayList objArrayList = new System.Collections.ArrayList();
objArrayList.Add(new Product("1001", "Chair"));
objArrayList.Add(new Product("1002", "Sofa"));
objArrayList.Add(new Product("1003", "Carpet"));
this.DropDownListArrayListObject.DataSource = null;
this.DropDownListArrayListObject.Items.Clear();
this.DropDownListArrayListObject.DataSource = objArrayList;
// Finding among Object of Array List is difficult , you have to find your specific item by index
Product objTemp = (Product)objArrayList[0];
objArrayList.Remove(objTemp);
this.DropDownListArrayListObject.DataTextField = "_Name";
this.DropDownListArrayListObject.DataValueField = "_Code";
this.DropDownListArrayListObject.DataBind();
this.GridViewArrayListObject.DataSource = objArrayList;
this.GridViewArrayListObject.DataBind();
}
}
public class Product
{
public Product()
{
}
public Product(string Code, string Name)
{
_Code = Code;
_Name = Name;
}
public string _Code { get; set; }
public string _Name { get; set; }
}
}
HashTable
HashTable is another kind of data structure that defines key value for each data section. Therefore finding data is easy just by point out to its key. It is NOT strongly typed and NOT fixed size.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace HashTable
{
class Program
{
static void Main(string[] args)
{
// It is NOT obvious that strArrayList is
// 1. string? int? object? decimal? OR OBJECT?? --> NOT Strongly Type
// 2. Sized=10? 20? 100? -->NOT Fixed Size
// Namespace: System.Collections
// Hashtable solve the problem in Arraylist when we are looking for specific item
// Hashtable dedicate a key for each item, then finding item is easier and faster
System.Collections.Hashtable objHashTable = new System.Collections.Hashtable();
objHashTable.Add("1001", "Chair");
objHashTable.Add("1002", "Sofa");
objHashTable.Add("1003", "Carpet");
this.DropDownListHashTable.DataSource = null;
this.DropDownListHashTable.Items.Clear();
this.DropDownListHashTable.DataSource = objHashTable;
// finding item is easier you just need to point to it by call its key
objHashTable.Remove("1002");
this.DropDownListHashTable.DataTextField = "Value";
this.DropDownListHashTable.DataValueField = "Key";
this.DropDownListHashTable.DataBind();
}
}
}
Stack
It stands for "Last in First out" == "LIFO". It is NOT strongly typed and NOT fixed size.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Stack
{
class Program
{
static void Main(string[] args)
{
// Stack is LIFO: Last in First Out
System.Collections.Stack objStackPush = new System.Collections.Stack();
// By Push method you can insert item at the top of the stack
objStackPush.Push("A");
objStackPush.Push("B");
objStackPush.Push("C");
objStackPush.Push("D");
objStackPush.Push("E");
// By POP you can remove array from the top
objStackPush.Pop();
foreach (var a in objStackPush.ToArray())
{
Console.WriteLine(a.ToString());
}
Console.ReadLine();
}
}
}
Queue
It stands for "First in First out" == "FIFO". It is NOT strongly typed and NOT fixed size.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Queue
{
class Program
{
static void Main(string[] args)
{
// Queue is FIFO: First in First Out
System.Collections.Queue objQueue = new System.Collections.Queue();
//By Enqueue method you can insert item at the END of the Queue
objQueue.Enqueue("A");
objQueue.Enqueue("B");
objQueue.Enqueue("C");
objQueue.Enqueue("D");
objQueue.Enqueue("E");
// By Dequeue method you can remove item from the BEGINING of the Queue --> First in First out FIFO
objQueue.Dequeue();
foreach (var a in objQueue.ToArray())
{
Console.WriteLine(a.ToString());
}
Console.ReadLine();
}
}
}
List
Why List?
1. List is NOT Fixed Length -> It is possible that data grows. On the one hand it is a good feature whenever developers are not sure about size of arraylist and on the other hand it might take long time for size definition.
2. List is Strongly Typed when it is defined "Generic" -> Whenever developers are sure about what is exactly type definition for input or output data and they do not wait until runtime to appear its type. This feature makes to run fast at runtime, since it does not need to wait for type definition.
3. Developers use "foreach" keyword to fill and iterate through array.
Since List is not Fixed Length makes developers feel flexible to use it, and because of it is Strongly Typed when it is defined "Generic" so our code runs fast at runtime because it does not need to wait for type definition.
// Like Array is Strong Type // Like ArrayList with No Dimension System.Collections.Generic.ListstrList = new List (); strList.Add("Mahsa"); strList.Add("Hassankashi"); strList.Add("Cosmic"); strList.Add("Verse"); this.ListBoxListGeneric.DataSource = strList; this.ListBoxListGeneric.DataBind(); System.Text.StringBuilder str = new System.Text.StringBuilder(); foreach (var item in strList) { str.Append(" , " + item); } this.lblList.Text = str.ToString();
IList
Why IList?
IList is implemented by List, Ilist is an interface and implements methods. Whenever you estimate probability that your code would be changed in future you have to use IList because interface reduces dependency and with the little modification your code runs. Therefore you should observe polymorphism in order to decouple your app and control on adding or removing method that might be changed. Everything else is similar. Whenever we want to change on some operation, so “IList” allow us to do that easily with at least changing in the whole of codes.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace List
{
class Program
{
static void Main(string[] args)
{
// Like Array is Strong Type
// Like ArrayList with No Dimension
System.Collections.Generic.IList strList = new List();
IList sss = new List();
sss.Add(new abc { a = "a", b = "b", c = "c" });
sss.Add(new abc { a = "a", b = "b", c = "c" });
sss.Add(new abc { a = "a", b = "b", c = "c" });
sss.Add(new abc { a = "a", b = "b", c = "c" });
var ssss = sss.ToList();
strList.Add("Mahsa");
strList.Add("Hassankashi");
strList.Add("Cosmic");
strList.Add("Verse");
this.ListBoxListGeneric.DataSource = strList;
this.ListBoxListGeneric.DataBind();
System.Text.StringBuilder str = new System.Text.StringBuilder();
int i = 1;
foreach (var item in strList)
{
if (i == strList.Count)
str.Append(item);
else
str.Append(item + ", ");
i++;
}
this.lblList.Text = str.ToString();
Console.WriteLine(str);
Console.ReadLine();
}
}
class abc
{
public string a { get; set; }
public string b { get; set; }
public string c { get; set; }
}
}
IEnumerable
IEnumerable is suitable just for iterate through collection and you can not modify (Add or Remove) data IEnumerable bring ALL data from server to client then filter them, assume that you have a lot of records so IEnumerable puts overhead on your memory.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace IEnumerable
{
class Program
{
internal string abcd = "";
static void Main(string[] args)
{
// IEnumerable can not be instantiate from Enumerable , so it should be instantiate from List
System.Collections.Generic.IEnumerable empIEnumerable = new List
{ new Employee { ID = 1001, Name="Mahsa"},
new Employee { ID = 1002, Name = "Hassankashi" },
new Employee { ID = 1003, Name = "CosmicVerse" },
new Employee { ID = 1004, Name = "Technical" }
};
this.GridViewIEnumerable.DataSource = empIEnumerable;
this.GridViewIEnumerable.DataBind();
System.Text.StringBuilder str = new System.Text.StringBuilder();
foreach (Employee item in empIEnumerable)
{
str.Append(" , " + item.ID + "-" + item.Name);
}
this.lblIEnumerable.Text = str.ToString();
}
}
public class Employee
{
public int ID { get; set; }
public string Name { get; set; }
}
}
IQueryable
Whenever we encounter to huge data with so many records so we have to reduce overhead from application. IQueryable prepares high performance in such situations (huge data) by filtering data firstly and then sending filtered data to client.
using(DataAccessEntities db = new DataAccessEntities())
{
// You can not instantiate IQueryable
IQueryable queryIQueryable=null;
// Bring just ONE record from server --> to client
var queryIQueryable = (from m in db.Employees
where m.ID == 1
select m);
// Whenever you call IQueryable so ==> It will be executed
this.GridViewIQueryable.DataSource = queryIQueryable.ToList();
this.GridViewIQueryable.DataBind();
}
Difference Between IEnumerable and IQueryable
//--------------------------------IEnumerable------------------------------//
// You can instantiate IEnumerable from List
IEnumerable queryIEnumerable = new List() ;
// Bring ALL records from server --> to client then filter collection
// To bring all data from server you should omit where cluse from linq to sql
var queryIEnumerable = from m in db.Employees select m;
// If you use where as extension method with IEnumerable then All records will be loaded
queryIEnumerable = queryIEnumerable.Where(x => x.ID == 1).ToList();
//--------------------------------IQueryable------------------------------//
// You can not instantiate IQueryable
IQueryable queryIQueryable=null;
// Bring just ONE record from server --> to client
var queryIQueryable = (from m in db.Employees
where m.ID == 1
select m);
// Whenever you call IQueryable so ==> It will be executed
this.GridViewIQueryable.DataSource = queryIQueryable.ToList();
this.GridViewIQueryable.DataBind();
ICollection
ICollection inherits from IEnumerable. There is one difference:You can find IEnumerable[ i ] --> Index Based
You can NOT find ICollection[ i ] --> Not Index Based
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ICollection
{
class Program
{
static void Main(string[] args)
{
// IList {indexer and Modify} vs ICollection {randomly and Modify}
// Collection can not be instantiate from ICollection , so it should be instantiate from List
System.Collections.Generic.ICollection strICollection = new List();
strICollection.Add("Sankar");
strICollection.Add("Sourav");
//--------------------------------Countable------------------------------//
int ICollectionCount = strICollection.Count;
this.ListBoxICollection.DataSource = strICollection;
this.ListBoxICollection.DataBind();
System.Text.StringBuilder str = new System.Text.StringBuilder();
foreach (var item in strICollection)
{
str.Append(" , " + item);
}
this.lblICollection.Text = str.ToString();
//--------------------------------IList------------------------------//
System.Collections.Generic.IList objIList = new List();
var objIList = (from m in ctx.Employees
select m).ToList();
Employee obj = objIList.Where(i => i.Name == "Sara").FirstOrDefault();
int indexofSara = objIList.IndexOf(obj);
int cIList = objIList.Count;
//--------------------------------ICollection------------------------------//
System.Collections.Generic.ICollection objICollection = new List();
var objICollection = (from m in ctx.Employees
select m).ToList();
Employee objIC = objICollection.Where(i => i.Name == "Sara").FirstOrDefault();
// You can not get index of object , if you clear comment from below code appears error
// int indexofSaraICollection = objIC.IndexOf(objIC);
int cICollection = objICollection.Count;
}
public class Employee
{
public int ID { get; set; }
public string Name { get; set; }
}
}
}
Stack Generic
//--------------------------------Push------------------------------//
// Stack is LIFO: Last in First Out
// Here is for Push Stack in Generic
// System.Collections.Stack objStackPush = new System.Collections.Stack();
// Stack can be instantiated from Stack
System.Collections.Generic.Stack objStackPush = new System.Collections.Generic.Stack();
objStackPush.Push(1);
objStackPush.Push(2);
this.lblPopGeneric.Text = "";
this.ListBoxStackGeneric.DataSource = objStackPush.ToArray();
this.ListBoxStackGeneric.DataBind();
//--------------------------------Pop------------------------------//
// Stack is LIFO: Last in First Out
// Here is for Pop Stack in Generic
// System.Collections.Stack objStackPop = new System.Collections.Stack();
// Stack can be instantiated from Stack
System.Collections.Generic.Stack objStackPop = new System.Collections.Generic.Stack();
objStackPop.Push(1);
objStackPop.Push(2);
this.lblPop.Text = objStackPop.Pop().ToString();
this.ListBoxStack.DataSource = objStackPop.ToArray();
this.ListBoxStack.DataBind();
Queue Generic
//--------------------------------Enqueue------------------------------//
// Queue is FIFO: First in First Out
// Here is for Enqueue Queue in Generic
// System.Collections.Queue objQueue = new System.Collections.Queue();
// Queue can be instantiated from Queue
System.Collections.Generic.Queue objQueue = new System.Collections.Generic.Queue();
objQueue.Enqueue(1);
objQueue.Enqueue(2);
this.lblQueue.Text = "";
this.ListBoxQueue.DataSource = objQueue.ToArray();
this.ListBoxQueue.DataBind();
//--------------------------------Dequeue------------------------------//
// Queue is FIFO: First in First Out
// Here is for Dequeue Queue in Generic
// System.Collections.Queue objQueue = new System.Collections.Queue();
// Queue can be instantiated from Queue
System.Collections.Generic.Queue objQueue = new System.Collections.Generic.Queue();
objQueue.Enqueue(1);
objQueue.Enqueue(2);
this.lblQueue.Text = objQueue.Dequeue().ToString();
this.ListBoxQueue.DataSource = objQueue.ToArray();
this.ListBoxQueue.DataBind();
Dictionary and IDictionary
Dictionary is GENERIC while HashTable is not generic : DictionaryIDictionary is interface and if you estimate big changes in future use IDictionary instead of Dictionary.
// Dictionary can instantiate from Dictionary , Dictionary is similar to Hashtable // Dictionary is GENERIC but Hashtable is NON GENERIC // Such Hashtable you can find object by its key System.Collections.Generic.DictionaryobjDictionary = new Dictionary (); objDictionary.Add(1001, "Amit"); objDictionary.Add(1002, "Abhijit"); objDictionary.Add(1003, "Asis"); string str = objDictionary[1002]; this.ListBoxDictionary.DataSource = objDictionary; this.ListBoxDictionary.DataBind();
0 comments