{"id":78387,"date":"2022-12-22T08:00:06","date_gmt":"2022-12-22T07:00:06","guid":{"rendered":"https:\/\/code-maze.com\/?p=78387"},"modified":"2022-12-22T09:07:16","modified_gmt":"2022-12-22T08:07:16","slug":"csharp-ienumerable","status":"publish","type":"post","link":"https:\/\/code-maze.com\/csharp-ienumerable\/","title":{"rendered":"IEnumerable in C#"},"content":{"rendered":"

In this article, we are going to learn about IEnumerable in C#. IEnumerable acts as an abstraction over a collection and allows us to iterate over it without knowing the actual type of the collection.<\/p>\n

To download the source code for this article, you can visit our GitHub repository<\/a>.<\/div>\n

Let’s begin.<\/p>\n

<\/a>What is the IEnumerable Interface in C#?<\/h2>\n

The<\/strong> IEnumerable<\/code> interface is the base for all the non-generic collections that can be enumerated. <\/strong><\/p>\n

It exposes a single method GetEnumerator()<\/code>. This method returns a reference to yet another interface System.Collections.IEnumerator<\/code>.<\/p>\n

The IEnumerator<\/code> interface in turn provides the ability to iterate through a collection by using the methods MoveNext()<\/code> and Reset()<\/code>, and the property Current<\/code>.<\/p>\n

If you’d like to learn about the different collection types available in .NET, check out our .NET Collections series<\/a>.<\/div>\n

Hence, in order for us to be able to use ForEach<\/code> over a collection, it must implement IEnumerable<\/code>.<\/strong><\/p>\n

<\/a>Extension Methods in IEnumerable<\/h2>\n

The IEnumerable<\/code> interface includes some extension methods<\/a> along with the GetEnumerator()<\/code> method.\u00a0<\/p>\n

We use deferred execution to implement these methods, so the actual value of the return object is realized only when the object is enumerated<\/strong> either using a ForEach<\/code> loop or by calling its GetEnumerator()<\/code> method.<\/p>\n

<\/a>Cast<TResult><\/h3>\n

This method takes a sequence of type IEnumerable<\/code> and converts all the objects of the given sequence to the type TResult<\/code>, thus resulting in a return type IEnumerable<TResult><\/code>.<\/p>\n

The Cast<TResult>()<\/code> method is a generic method<\/a> where TResult<\/code> acts as a placeholder for the actual type we want to work with at compile time. It allows the use of standard LINQ query operators<\/a> like filtering, sorting, etc. on a non-generic type such as Arraylist<\/code>:<\/p>\n

var primes = new ArrayList\r\n{\r\n    5,\r\n    3,\r\n    2,\r\n    7\r\n};\r\n\r\nvar primeQuery = primes.Cast<int>().OrderBy(prime => prime).Select(prime => prime);\r\n\r\nvar expected = new List<int> { 2, 3, 5, 7 };\r\n\r\nAssert.Equal(expected, primeQuery);<\/pre>\n
We are able to convert a non-generic collection of type Arraylist<\/code> into IEnumerable<int><\/code>and thus have all its functionalities available.<\/p>\n
<\/a>OfType<TResult><\/h3>\n
This method takes a sequence of type IEnumerable<\/code> and filters it based on the specified type. It returns only those elements from the input source that can be cast to the type TResult<\/code><\/strong>:<\/p>\n
var cities = new ArrayList\r\n{\r\n    \"London\",\r\n    \"Paris\",\r\n    \"Madrid\",\r\n    \"Berlin\",\r\n    7,\r\n    \"Lisbon\"\r\n};\r\n\r\nvar cityQuery = cities.OfType<string>();\r\n\r\nvar expected = new List<string> { \"London\", \"Paris\", \"Madrid\", \"Berlin\", \"Lisbon\" };\r\n\r\nAssert.Equal(expected, cityQuery);<\/pre>\n
This is where it differs from Cast<TResult>()<\/code> which instead throws an exception if an element can’t be cast to TResult<\/code>. We can also use standard query operators such as Where()<\/code> after filtering the source:<\/p>\n
var cities = new ArrayList\r\n{\r\n    \"London\",\r\n    \"Paris\",\r\n    \"Madrid\",\r\n    \"Berlin\",\r\n    7,\r\n    \"Lisbon\",\r\n    8,\r\n    12\r\n};\r\n\r\nvar evens = cities.OfType<int>().Where(x => x % 2 == 0);\r\n\r\nvar expected = new List<int> { 8, 12 };\r\n\r\nAssert.Equal(expected, evens);<\/pre>\n
<\/a>AsParallel Method<\/h3>\n
This method enables the parallelization of a query. It takes a sequence of type IEnumerable<\/code> and converts it to the type ParallelQuery<\/a>:<\/p>\n
var numbers = Enumerable.Range(0, 100);\r\n\r\nvar oddsCount = numbers.AsParallel().Count(x => x % 2 != 0);\r\n\r\nvar expected = 50;\r\n\r\nAssert.Equal(expected, oddsCount);<\/pre>\n
The AsParallel()<\/code>method binds the query to PLINQ<\/a> or Parallel LINQ<\/strong>. The PLINQ queries work in a similar way to the sequential LINQ queries where they operate on in-memory data sources and allow deferred execution.<\/p>\n
However, they attempt to make use of all available processors by partitioning the data source into segments and then executing the query on each segment on separate worker threads in parallel on multiple processors.\u00a0<\/p>\n
<\/a>AsQueryable Method<\/h3>\n
This method takes a sequence of type IEnumerable<\/code> and converts it into IQueryable<\/a>:<\/p>\n
var numbers = new List<int>\r\n{\r\n    1, 2, 3, 4, 5, 6, 7, 8, 9, 10\r\n};\r\n\r\nvar query = numbers.AsQueryable();\r\n\r\nvar multiplesOf3 = query.Where(x => x % 3 == 0);\r\n\r\nvar expected = new List<int> { 3, 6, 9 };\r\n\r\nAssert.Equal(expected, multiplesOf3);\r\n\r\nAssert.Equal(\"Constant\", query.Expression.NodeType.ToString());<\/pre>\n
The IQueryable<\/code> interface extends the IEnumerable<\/code> interface and hence is similar in functionality.<\/p>\n
The main difference between both is that while IEnumerable<\/code> is more suited to collections loaded using LINQ where filtering is required on the client side where IEnumerable<\/code> is, IQueryable<\/code> creates a SQL Query on the server side and only filtered data is sent to the client side.<\/p>\n
This concludes the extension methods of IEnumerable in C#. Let’s now take a look at implementing a custom IEnumerable interface in code.<\/p>\n
<\/a>Code Implementation of IEnumerable Interface<\/h2>\n
Let’s start by creating a Book<\/code>class:<\/p>\n
public class Book\r\n{\r\n    public Book(string name, string author)\r\n    {\r\n        Name = name;\r\n        Author = author;\r\n    }\r\n\r\n    public string Name { get; set; }\r\n    public string Author { get; set; }\r\n}<\/pre>\n
Now, that we have our business object, let’s create a collection of this object:<\/p>\n
public class Library : IEnumerable\r\n{\r\n    private readonly Book[] _books;\r\n\r\n    public Library(Book[] books)\r\n    {\r\n        _books = new Book[books.Length];\r\n\r\n        for (int i = 0; i < books.Length; i++)\r\n        {\r\n            _books[i] = books[i];\r\n        }\r\n    }\r\n}<\/pre>\n
The class Library<\/code> implements IEnumerable<\/code> so that we may use the ForEach<\/code> loop on the class objects. However, the code does not compile until we implement the GetEnumerator()<\/code> method of the interface.<\/p>\n
As we need to implement IEnumerator<\/code> when implementing IEnumerable<\/code>, let’s first implement the IEnumerator<\/code> interface:<\/p>\n
public class BookEnumerator : IEnumerator\r\n{\r\n    private readonly Book[] _books;\r\n    private int _index;\r\n\r\n    public BookEnumerator(Book[] books)\r\n    {\r\n        _books = books;\r\n    }\r\n\r\n    public Book Current\r\n    {\r\n        get\r\n        {\r\n            return _books[_index];\r\n        }\r\n    }\r\n\r\n    object IEnumerator.Current => Current;\r\n\r\n    public bool MoveNext()\r\n    {\r\n        _index++;\r\n        return _index < _books.Length;\r\n    }\r\n\r\n    public void Reset()\r\n    {\r\n        _index = -1;\r\n    }\r\n}<\/pre>\n
We start by implementing the required members of IEnumerator<\/code> in the class BookEnumerator<\/code> i.e. the property Current<\/code>, and the methods Reset()<\/code> and MoveNext()<\/code>.<\/p>\n
When the class is instantiated, the enumerator _index<\/code> is placed before the first element of the collection. When iterating over the collection, we send a call to MoveNext()<\/code> that advances the enumerator to the first position.\u00a0<\/p>\n
The Current<\/code> property indicates the position of the enumerator at any point. It returns the same value until MoveNext()<\/code> or Reset()<\/code> are called. It is undefined under these conditions:<\/p>\n