IQueryable Vs Queryable X IEnumerable Vs Enumerable Vs IEnumerator X IList Vs List

This is very common for beginners to get fuzzy with these words in their head. These are all alike and seem to be used for the same purpose. Well, let us see how all these are different.

Do they have the same purpose? In some ways, they do have the same purpose, but there are some differences also and we are going through the differences and similarities here in this article below.

 

Let us start with the types that start with an "I". They represent the interface, while their implementation are the classes that do not start with "I".

 

Interface	Implementation
IList	List
IQueryable	Queryable
IEnumerator
IEnumarable	Enumerable

 

With the exception of the IQueryable / Queryable which derives from LINQ, they all derive from C# collections, along with many other types.

• Read more about LinQ
• Read more about Collections

What is an interface?

 

An interface contains the signature of methods, properties, events, and indexers that are going to have their behavior implemented in the classes that inherit from it.

 

Example of an interface and its implementation -

interface ISample
{
    void AnyMethod();
}

class Sample : ISample
{
    // Interface member implementation:
    void AnyMethod()
    {
        // The method implementation.
    }

    static void Main()
    {
        // Declare an interface instance.
        ISample obj = new Sample();

        // Call the member.
        obj.AnyMethod();
    }
}

Read more about interfaces.

 

Benefits of using Interfaces

 

You may feel that it is a waste of time to create interfaces but here is why it is important.

• Decoupling, reducing dependency from implementation classes; 
• Readability, as an interface implements the signature of your code their name must make sense with their purpose;
• Maintainability, making it possible of having different implementations based on the same interface;
• Extensibility, being easier to extend classes with a different implementation based on the same contract.

IQueryable vs IEnumarable vs IEnumerator vs IList

 

IQueryable

 

Inherits from IEnumerable and has this signature -

using System.Collections;
using System.Linq.Expressions;

namespace System.Linq
{
    //
    // Summary:
    //     Provides functionality to evaluate queries against a specific data source wherein
    //     the type of the data is not specified.
    public interface IQueryable : IEnumerable
    {
        //
        // Summary:
        //     Gets the type of the element(s) that are returned when the expression tree associated
        //     with this instance of System.Linq.IQueryable is executed.
        //
        // Returns:
        //     A System.Type that represents the type of the element(s) that are returned when
        //     the expression tree associated with this object is executed.
        Type ElementType { get; }
        //
        // Summary:
        //     Gets the expression tree that is associated with the instance of System.Linq.IQueryable.
        //
        // Returns:
        //     The System.Linq.Expressions.Expression that is associated with this instance
        //     of System.Linq.IQueryable.
        Expression Expression { get; }
        //
        // Summary:
        //     Gets the query provider that is associated with this data source.
        //
        // Returns:
        //     The System.Linq.IQueryProvider that is associated with this data source.
        IQueryProvider Provider { get; }
    }
}

Read more about IQueryable.

 

IEnumerable

 

Exposes the enumerator which supports a simple iteration over a collection of a specified type.

namespace System.Collections.Generic
{
    //
    // Summary:
    //     Exposes the enumerator, which supports a simple iteration over a collection of
    //     a specified type.
    //
    // Type parameters:
    //   T:
    //     The type of objects to enumerate.
    public interface IEnumerable<out T> : IEnumerable
    {
        //
        // Summary:
        //     Returns an enumerator that iterates through the collection.
        //
        // Returns:
        //     An enumerator that can be used to iterate through the collection.
        IEnumerator<T> GetEnumerator();
    }
}

Read more about IEnumerable.

 

IEnumerator

 

Supports a simple iteration over a generic collection and does not have an implementation like the other interfaces. It is better used for iteration over generic collections, like when using a foreach statement. 

namespace System.Collections.Generic
{
    //
    // Summary:
    //     Supports a simple iteration over a generic collection.
    //
    // Type parameters:
    //   T:
    //     The type of objects to enumerate.
    public interface IEnumerator<out T> : IEnumerator, IDisposable
    {
        //
        // Summary:
        //     Gets the element in the collection at the current position of the enumerator.
        //
        // Returns:
        //     The element in the collection at the current position of the enumerator.
        T Current { get; }
    }
}

A deeper explanation with a nice example can be found here.

• Enumerators in C#

Read more about IEnumerator.

IList

It inherits from ICollection and IEnumerable, representing a collection of objects that can be individually accessed by index.

using System.Reflection;

namespace System.Collections.Generic
{
    //
    // Summary:
    //     Represents a collection of objects that can be individually accessed by index.
    //
    // Type parameters:
    //   T:
    //     The type of elements in the list.
    [DefaultMember( "Item" )]
    public interface IList<T> : ICollection<T>, IEnumerable<T>, IEnumerable
    {
        //
        // Summary:
        //     Gets or sets the element at the specified index.
        //
        // Parameters:
        //   index:
        //     The zero-based index of the element to get or set.
        //
        // Returns:
        //     The element at the specified index.
        //
        // Exceptions:
        //   T:System.ArgumentOutOfRangeException:
        //     index is not a valid index in the System.Collections.Generic.IList`1.
        //
        //   T:System.NotSupportedException:
        //     The property is set and the System.Collections.Generic.IList`1 is read-only.
        T this[int index] { get; set; }

        //
        // Summary:
        //     Determines the index of a specific item in the System.Collections.Generic.IList`1.
        //
        // Parameters:
        //   item:
        //     The object to locate in the System.Collections.Generic.IList`1.
        //
        // Returns:
        //     The index of item if found in the list; otherwise, -1.
        int IndexOf( T item );
        //
        // Summary:
        //     Inserts an item to the System.Collections.Generic.IList`1 at the specified index.
        //
        // Parameters:
        //   index:
        //     The zero-based index at which item should be inserted.
        //
        //   item:
        //     The object to insert into the System.Collections.Generic.IList`1.
        //
        // Exceptions:
        //   T:System.ArgumentOutOfRangeException:
        //     index is not a valid index in the System.Collections.Generic.IList`1.
        //
        //   T:System.NotSupportedException:
        //     The System.Collections.Generic.IList`1 is read-only.
        void Insert( int index, T item );
        //
        // Summary:
        //     Removes the System.Collections.Generic.IList`1 item at the specified index.
        //
        // Parameters:
        //   index:
        //     The zero-based index of the item to remove.
        //
        // Exceptions:
        //   T:System.ArgumentOutOfRangeException:
        //     index is not a valid index in the System.Collections.Generic.IList`1.
        //
        //   T:System.NotSupportedException:
        //     The System.Collections.Generic.IList`1 is read-only.
        void RemoveAt( int index );
    }
}

Read more about IList. 

 

Queryable vs Enumarable vs List

Queryable 

• Namespace: System.LinQ;
• Implements and most of its methods extends IQueryable;
• Good for Query data in LinQ. Like to filter data;
• The query is deferred, being executed when those values are needed;
• Usage for LinQ to SQL 

Read more about queryable.

 

Enumerable

• Namespace: System.LinQ;
• Implements and most of its methods extends IEnumerable;
• Good for querying data from the in-memory collection, like list or array;
• The query is deferred, being executed when the object is enumerated.
• Usage for LINQ to Object and LINQ to XML;

Read more about Enumerable.

 

List

• Namespace: System.Collections.Generic;
• Inherits from: ICollection<T>, IEnumerable<T>, IEnumerable, IList<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection, IList;
• Good for interaction within in-memory objects. Like to update, remove or include items. 
• The query is executed immediately, allocating the result in memory. 

Read more about List.

 

External References

• Interface documentation;
• Queryable documentation;
• IQueryable documentation;
• List documentation;
• IList documentation;
• IEnumerator documentation;
• IEnumerable documentation;
• Enumerable documentation;
• C# Collections documentation;
• C-sharp corner: Enumerators in C#