Passing a Single Item as Ienumerable<T>

Passing a single item as IEnumerableT

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.

How do I convert a single value of type T into an IEnumerableT?

One simple way:

var singleElementSequence = Enumerable.Repeat(value, 1);

Or you could write your own extension method on an unconstrained generic type (usually a bad idea, admittedly... use with care):

public static IEnumerable<T> ToSingleElementSequence<T>(this T item)
{
    yield return item;
}

Use as:

IEnumerable<String> sequence = "foo".ToSingleElementSequence();

I think I'd use Enumerable.Repeat in preference though :)

How to return IEnumerableT for a single item

IEnumerable<T> getItems()
{
    if ( someCondition.Which.Yields.One.Item )
    {
        yield return MyRC;
    }
    else
    {
        foreach(var i in myList)
            yield return i;
    }
}

return single instance object as IEnumerable

Options:

• Create an instance of a collection class, like an array or a list. This would be mutable by default, which would be slightly unhelpful if this is a sequence you want to be able to hand out in your API. You could create a ReadOnlyCollection<T> wrapper around such a collection though.
• Write your own iterator block as per Botz3000's answer
• Use Enumerable.Repeat(item, 1) from LINQ, if you're using .NET 3.5.

The best answer here depends on the usage. If you only need this to call another method which uses a sequence, and you know it won't be modified, I'd probably use an array. For example, in order to call Concat on some other sequence, you might want:

var wholeList = regularList.Concat(new[] { finalValue });

I have confidence that Concat isn't going to mutate the array, and nothing else will ever see the reference to the array itself.

If you need to return the sequence to some other code, and you don't know what it might do with it, I'd probably use Enumerable.Repeat.

What's the Best Way to Add One Item to an IEnumerableT?

Nope, that's about as concise as you'll get using built-in language/framework features.

You could always create an extension method if you prefer:

arr = arr.Append("JKL");
// or
arr = arr.Append("123", "456");
// or
arr = arr.Append("MNO", "PQR", "STU", "VWY", "etc", "...");

// ...

public static class EnumerableExtensions
{
    public static IEnumerable<T> Append<T>(
        this IEnumerable<T> source, params T[] tail)
    {
        return source.Concat(tail);
    }
}

IEnumerable.Select() for a single item

By "innate", I guess you mean you don't want to any new methods yourself?

Well, you can do something like this:

value = ((Func<InputType, OutputType>)(o => o.First + o.Second + o.Property.Value))(collection[calc(param)]);

Basically, casting the lambda to a delegate type and then calling the delegate.

Or maybe I have overcomplicated this. What you actually want might toto just not write collection[calc(param)] that many times. If that's the case, you can just:

var o = collection[calc(param)];
value = o.First + o.Second + o.Property.Value;

I don't see why you can't do it like that.

I really suggest you write a separate a method for this kind of transformation. It will be much more readable.

// name this properly so that it describes what you actually want.
public OutputType TransformCollectionItem(TInput o) {
    return o.First + o.Second + o.Property.Value;
} 

Favorite way to create an new IEnumerableT sequence from a single value?

Your example is not an empty sequence, it's a sequence with one element. To create an empty sequence of strings you can do

var sequence = Enumerable.Empty<string>();

EDIT OP clarified they were looking to create a single value. In that case

var sequence = Enumerable.Repeat("abc",1);

How can I add an item to a IEnumerable(T item, int? number)?

The point of the interface is that you don't need to know anything about the source of the list, only that you can enumerate it. It could be that the method returns a list, computes the elements on the fly or reads them from the internet one at a time.

To add a value, you'll need to make sure that you work with a List<T>:

var enumResult = new List<(T item, int? number)>();
enumResult.Add(...);

Note that a List is also an IEnumerable so you can still use enumResult wherever the IEnumerable is expected.

Is there a Linq method to add a single item to an IEnumerableT?

One way would be to create a singleton-sequence out of the item (such as an array), and then Concat it onto the original:

image.Layers.Concat(new[] { image.ParentLayer } )

If you're doing this really often, consider writing an Append (or similar) extension-method, such as the one listed here, which would let you do:

image.Layers.Append(image.ParentLayer)

.NET Core Update (per the "best" answer below):

Append and Prepend have now been added to the .NET Standard framework, so you no longer need to write your own. Simply do this:

image.Layers.Append(image.ParentLayer)

---

Related Topics