The document discusses differences between various interfaces and concepts in .NET: 1. The differences between for and foreach loops include that for loops use integers while foreach can use any type, foreach does not require specifying loop bounds, and foreach iterates over collections. 2. Covariance allows converting from a broader type to a more specific type, while contravariance allows the opposite; covariance preserves type safety while contravariance requires an explicit cast. 3. IList allows accessing by index and modifying elements while IEnumerable only allows forward iteration; IList supports operations like count while IEnumerable requires iteration. 4. IQueryable is for querying remote data while IEnumerable is for in-memory data;

1. 1.Difference between for and foreach loop
S.No For loop Foreach loop
1 In case of for the variable of the loop is In case of Foreach the variable of the loop
always be int only. while be same as the type of values under the
array.
2 The For loop executes the statement or The Foreach statement repeats a group of
block of statements repeatedly until embedded statements for each element in an
specified expression evaluates to false. array or an object collection.
3 There is need to specify the loop We do not need to specify the loop bounds
bounds(Minimum, Maximum). minimum or maximum.
4 example: example:
using sytem; using sytem;
class class1 class class1
{ {
static void Main() static void Main()
{ {
int j=0; int j=0;
for(int i=0; i<=10;i++) int[] arr=new int[]
{ {0,3,5,2,55,34,643,42,23};
j=j+1; foreach(int i in arr)
} {
Console.ReadLine(); j=j+1;
} }
} Console.ReadLine();
}
}
2. Difference between Covariance and Contravariance
S.No Covariance Contravariance
1 Converting from a broader type to a Converting from a more specific type to a
specific type is called co-variance.If B broader type is called contra-variance. If B is
is derived from A and B relates to A, derived from A and B relates to A, then we
then we can assign A to B. Like A=B. can assign B to A. Like B= A. This is
This is Covariance. Contravariance.
2 Co-variance is guaranteed to work Contra-variance on the other hand is not
without any loss of information during guaranteed to work without loss of data. As
conversion. So, most languages also such an explicit cast is required.
provide facility for implicit conversion.
e.g. Converting from cat or dog to animal is
e.g. Assuming dog and cat inherits from called contra-variance, because not all
animal, when you convert from animal features (properties/methods) of cat or dog is
type to dog or cat, it is called co- present in animal.
variance.
3 Example:

2. class Fruit { }
class Mango : Fruit { }
class Program
{
delegate T Func<out T>();
delegate void Action<in T>(T a);
static void Main(string[] args)
{
// Covariance
Func<Mango> mango = () => new Mango();
Func<Fruit> fruit = mango;
// Contravariance
Action<Fruit> fr = (frt) =>
{ Console.WriteLine(frt); };
Action<Mango> man = fr;
}
}
4 Note:
1. Co-variance and contra-variance is possible only with reference types; value types
are invariant.
2. In .NET 4.0, the support for co-variance and contra-variance has been extended to
generic types. No now we can apply co-variance and contra-variance to Lists etc. (e.g.
IEnumerable etc.) that implement a common interface. This was not possible with
.NET versions 3.5 and earlier.

3. 3.Difference between IList and IEnumerable
S.No IList IEnumerable
1 IList is used to access an element in a IEnumerable is a forward only collection, it
specific position/index in a list. can not move backward and between the
items.
2 IList is useful when we want to Add or IEnumerable does not support add or remove
remove items from the list. items from the list.
3 IList can find out the no of elements in Using IEnumerable we can find out the no of
the collection without iterating the elements in the collection after iterating the
collection. collection.
4 IList does not support filtering. IEnumerable supports filtering.
4.Difference between IEnumerable and IQueryable
S.No IEnumerable IQueryable
1 IEnumerable exists in IQueryable exists in System.Linq
System.Collections Namespace. Namespace.
2 IEnumerable is best to query data from IQueryable is best to query data from out-
in-memory collections like List, Array memory (like remote database, service)
etc. collections.
3 While query data from database, While query data from database,
IEnumerable execute select query on IEnumerable execute select query on server
server side, load data in-memory on side with all filters.
client side and then filter data.
4 IEnumerable is suitable for LINQ to IQueryable is suitable for LINQ to SQL
Object and LINQ to XML queries. queries.
5 IEnumerable does not supports custom IQueryable supports custom query using
query. CreateQuery and Execute methods.
6 IEnumerable does not support lazy IQueryable support lazy loading. Hence it is
loading. Hence not suitable for paging suitable for paging like scenarios.
like scenarios.
7 Extension methods supports by Extension methods supports by IEnumerable
IEnumerable takes functional objects. takes expression objects means expression
tree.
8 IEnumerable Example
MyDataContext dc = new MyDataContext ();
IEnumerable list = dc.loyees.Where(p => p.Name.StartsWith("S"));
list = list.Take(10);
Generated SQL statements of above query will be :
SELECT [t0].[EmpID], [t0].[EmpName], [t0].[Salary] FROM [Employee] AS [t0]
WHERE [t0].[EmpName] LIKE @p0

4. Note: In this query "top 10" is missing since IEnumerable filters records on client side
IQueryable Example
MyDataContext dc = new MyDataContext ();
IEnumerable list = dc.loyees.Where(p => p.Name.StartsWith("S"));
list = list.Take(10);
Generated SQL statements of above query will be :
SELECT TOP 10 [t0].[EmpID], [t0].[EmpName], [t0].[Salary] FROM [Employee]
AS [t0]
WHERE [t0].[EmpName] LIKE @p0
Note: In this query "top 10" is exist since IQueryable executes query in SQL server
with all filters.
5.Difference between IEnumerable and IEnumerator
S.No IEnumerable IEnumerator
1 The IEnumerable interface is a generic IEnumerator provides two abstract methods
interface that provides an abstraction and a property to pull a particular element in
for looping over elements. a collection. And they are Reset(),
In addition to providing foreach MoveNext() and Current The signature of
support, it allows us to tap into the IEnumerator members is as follows:
useful extension methods in the void Reset() : Sets the enumerator to its
System.Linq namespace, opening up a initial position, which is before the first
lot of advanced functionality element in the collection.
The IEnumerable interface contains an bool MoveNext() : Advances the enumerator
abstract member function called to the next element of the collection.
GetEnumerator() and return an interface object Current : Gets the current element in
IEnumerator on any success call. the collection
2 IEnumerable does not remember the IEnumerator does remember the cursor state
cursor state i.e currently row which is
iterating through
3 IEnumerable is useful when we have IEnumerator is useful when we have to pass
only iterate the value the iterator as parameter and has to remember
the value