Passing a single item as IEnumerable<T>

Question

Is there a common way to pass a single item of type T to a method which expects an IEnumerable<T> parameter? Language is C#, framework version 2.0.

Currently I am using a helper method (it's .Net 2.0, so I have a whole bunch of casting/projecting helper methods similar to LINQ), but this just seems silly:

public static class IEnumerableExt
{
    // usage: IEnumerableExt.FromSingleItem(someObject);
    public static IEnumerable<T> FromSingleItem<T>(T item)
    {
        yield return item; 
    }
}

Other way would of course be to create and populate a List<T> or an Array and pass it instead of IEnumerable<T>.

[Edit] As an extension method it would be (with a more appropriate name, as Dan said):

public static class IEnumerableExt
{
    // usage: someObject.AsEnumerable();
    public static IEnumerable<T> AsEnumerable<T>(this T item)
    {
        yield return item; 
    }
}

Am I missing something here?

Answer 1

Well, if the method expects an IEnumerable you've got to pass something that is a list, even if it contains one element only.

passing

new T[] { item }

as the argument should be enough I think

Answer 2

The easiest way I'd say would be new T[]{item};; there's no syntax to do this. The closest equivalent that I can think of is the params keyword, but of course that requires you to have access to the method definition and is only usable with arrays.

Answer 3

Your helper method is the cleanest way to do it, IMO. If you pass in a list or an array, then an unscrupulous piece of code could cast it and change the contents, leading to odd behaviour in some situations. You could use a read-only collection, but that's likely to involve even more wrapping. I think your solution is as neat as it gets.

Answer 4

No, there is no such possibility. That's because T and IEnumerable<T> simply are two different data types. So there are no other ways than either casting or method overloading, where one version accepts the IEnumerable<T> and the other the T itself...

Answer 5

In C# 3.0 (I know you said 2.0), you can write a generic extension method which might make the syntax a little more acceptable:

static class IEnumerableExtensions
{
 public static IEnumerable<T> AsEnumerable<T>(this T item)
 {
  yield return item;
 }
}

client code is then item.AsEnumerable().

Answer 6

I'm kind of surprised that no one suggested a new overload of the method with an argument of type T to simplify the client API.

public void DoSomething<T>(IEnumerable<T> list)
{
    // Do Something
}

public void DoSomething<T>(T item)
{
    DoSomething(new T[] { item });
}

Now your client code can just do this:

MyItem item = new MyItem();
Obj.DoSomething(item);

or with a list:

List<MyItem> itemList = new List<MyItem>();
Obj.DoSomething(itemList);

Answer 7

Either (as has previously been said)

MyMethodThatExpectsAnIEnumerable(new[] { myObject });

or

MyMethodThatExpectsAnIEnumerable(Enumerable.Repeat(myObject, 1));

As a side note, the last version can also be nice if you want an empty list of an anonymous object, e.g.

var x = MyMethodThatExpectsAnIEnumerable(Enumerable.Repeat(new { a = 0, b = "x" }, 0));

Answer 8

In C# 3.0 you can utilize the System.Linq.Enumerable class:

// using System.Linq

Enumerable.Repeat(item, 1);

This will create a new IEnumerable that only contains your item.