Introduction:

This blog will guide you through various methods of achieving seamless array-to-IEnumerable conversion. By the time you finish reading, you'll be well-versed in these conversion techniques and equipped to wield them effectively in your projects.

Method 1: Harnessing the Power of IEnumerable<T> Interface

The most straightforward approach to converting an array into an IEnumerable sequence is by utilizing the inherent capabilities of the IEnumerable<T> interface. This method is both intuitive and highly efficient, making it a popular choice among C# developers.

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        int[] intArray = { 1, 2, 3, 4, 5 };
        IEnumerable<int> enumerable = intArray;

        foreach (var num in enumerable)
        {
            Console.Write(num + " ");
        }
    }
}

Output:

1 2 3 4 5

Method 2: Embracing the Convenience of Enumerable.AsEnumerable()

When your intention is to perform LINQ operations on the resulting enumerable sequence, the Enumerable.AsEnumerable() method comes to your rescue. This approach seamlessly converts your array, enabling you to leverage the power of LINQ.

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        int[] intArray = { 1, 2, 3, 4, 5 };
        IEnumerable<int> enumerable = intArray.AsEnumerable();

        var sum = enumerable.Sum();
        Console.WriteLine("Sum: " + sum);
    }
}

Output:

Sum: 15

Method 3: Crafting a Custom Array Wrapper Class

Sometimes, you might require additional functionality while preserving the benefits of IEnumerable. In such cases, creating a custom array wrapper class that implements the IEnumerable<T> interface proves to be a valuable solution.

using System;
using System.Collections;
using System.Collections.Generic;

public class ArrayWrapper<T> : IEnumerable<T>
{
    private T[] array;

    public ArrayWrapper(T[] array)
    {
        this.array = array;
    }

    public IEnumerator<T> GetEnumerator()
    {
        return ((IEnumerable<T>)array).GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return array.GetEnumerator();
    }
}

class Program
{
    static void Main()
    {
        int[] intArray = { 1, 2, 3, 4, 5 };
        IEnumerable<int> enumerable = new ArrayWrapper<int>(intArray);

        foreach (var num in enumerable)
        {
            Console.Write(num + " ");
        }
    }
}

Output:

1 2 3 4 5

Conclusion:

This blog explored various methods of achieving seamless array-to-IEnumerable conversion in C#. By leveraging the power of the IEnumerable<T> interface, embracing the versatility of Enumerable.AsEnumerable(), or crafting a custom array wrapper class, you can seamlessly transform your arrays for enhanced manipulation and efficient iteration.