Передача одного элемента как IEnumerable ‹T›

Ваш вспомогательный метод - самый чистый способ сделать это, ИМО. Если вы передадите список или массив, то недобросовестный фрагмент кода может преобразовать его и изменить содержимое, что в некоторых ситуациях приведет к странному поведению. Вы можете использовать коллекцию только для чтения, но это, вероятно, потребует еще большего количества упаковок. Я думаю, что ваше решение настолько изящно, насколько возможно.

Что ж, если метод ожидает IEnumerable, вам нужно передать что-то, что является списком, даже если он содержит только один элемент.

прохождение

new[] { item }

поскольку аргумента должно быть достаточно, я думаю

В C # 3.0 вы можете использовать класс System.Linq.Enumerable:

// using System.Linq

Enumerable.Repeat(item, 1);

Это создаст новый IEnumerable, содержащий только ваш элемент.

В C # 3 (я знаю, что вы сказали 2) вы можете написать общий метод расширения, который может сделать синтаксис более приемлемым:

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

клиентский код тогда item.ToEnumerable().

Этот вспомогательный метод работает для элемента или многих.

public static IEnumerable<T> ToEnumerable<T>(params T[] items)
{
    return items;
}    

Я немного удивлен, что никто не предложил новую перегрузку метода с аргументом типа T для упрощения клиентского API.

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

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

Теперь ваш клиентский код может просто сделать это:

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

или со списком:

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

Либо (как было сказано ранее)

MyMethodThatExpectsAnIEnumerable(new[] { myObject });

or

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

В качестве примечания, последняя версия также может быть хорошей, если вам нужен пустой список анонимного объекта, например

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

Как я только что обнаружил и увидел, что пользователь LukeH тоже предложил, хороший простой способ сделать это выглядит следующим образом:

public static void PerformAction(params YourType[] items)
{
    // Forward call to IEnumerable overload
    PerformAction(items.AsEnumerable());
}

public static void PerformAction(IEnumerable<YourType> items)
{
    foreach (YourType item in items)
    {
        // Do stuff
    }
}

Этот шаблон позволит вам вызывать одну и ту же функцию множеством способов: один элемент; несколько элементов (через запятую); массив; список; перечисление и т. д.

Я не уверен на 100% в эффективности использования метода AsEnumerable, но он действительно работает.

Обновление: функция AsEnumerable выглядит довольно эффективной! (ссылка)

Хотя для одного метода это излишне, я считаю, что некоторые люди могут найти интерактивные расширения полезными.

Интерактивные расширения (Ix) от Microsoft включают следующий метод.

public static IEnumerable<TResult> Return<TResult>(TResult value)
{
    yield return value;
}

Что можно использовать так:

var result = EnumerableEx.Return(0);

Ix добавляет новую функциональность, отсутствующую в исходных методах расширения Linq, и является прямым результатом создания реактивных расширений (Rx).

Подумайте, Linq Extension Methods + Ix = Rx для IEnumerable.

Вы можете найти как Rx, так и Ix на CodePlex.

Я согласен с комментариями @ EarthEngine к исходному сообщению, которые заключаются в том, что «AsSingleton» - лучшее имя. См. эту статью в википедии. Затем из определения синглтона следует, что если в качестве аргумента передается значение NULL, AsSingleton должен возвращать IEnumerable с одним значением NULL вместо пустого IEnumerable, который уладил бы дебаты if (item == null) yield break;. Я думаю, что лучшим решением будет иметь два метода: AsSingleton и AsSingletonOrEmpty; где в случае, если в качестве аргумента передается значение NULL, AsSingleton вернет одно значение NULL, а AsSingletonOrEmpty вернет пустой IEnumerable. Нравится:

public static IEnumerable<T> AsSingletonOrEmpty<T>(this T source)
{
    if (source == null)
    {
        yield break;
    }
    else
    {
        yield return source;
    }
}

public static IEnumerable<T> AsSingleton<T>(this T source)
{
    yield return source;
}

Тогда они будут более или менее аналогичны методам расширения First и FirstOrDefault в IEnumerable, что кажется правильным.

Это на 30% быстрее, чем yield или Enumerable.Repeat при использовании в foreach, благодаря этой оптимизации компилятора C # и такой же производительности в другие случаи.

public struct SingleSequence<T> : IEnumerable<T> {
    public struct SingleEnumerator : IEnumerator<T> {
        private readonly SingleSequence<T> _parent;
        private bool _couldMove;
        public SingleEnumerator(ref SingleSequence<T> parent) {
            _parent = parent;
            _couldMove = true;
        }
        public T Current => _parent._value;
        object IEnumerator.Current => Current;
        public void Dispose() { }

        public bool MoveNext() {
            if (!_couldMove) return false;
            _couldMove = false;
            return true;
        }
        public void Reset() {
            _couldMove = true;
        }
    }
    private readonly T _value;
    public SingleSequence(T value) {
        _value = value;
    }
    public IEnumerator<T> GetEnumerator() {
        return new SingleEnumerator(ref this);
    }
    IEnumerator IEnumerable.GetEnumerator() {
        return new SingleEnumerator(ref this);
    }
}

в этом тесте:

    // Fastest among seqs, but still 30x times slower than direct sum
    // 49 mops vs 37 mops for yield, or c.30% faster
    [Test]
    public void SingleSequenceStructForEach() {
        var sw = new Stopwatch();
        sw.Start();
        long sum = 0;
        for (var i = 0; i < 100000000; i++) {
            foreach (var single in new SingleSequence<int>(i)) {
                sum += single;
            }
        }
        sw.Stop();
        Console.WriteLine($"Elapsed {sw.ElapsedMilliseconds}");
        Console.WriteLine($"Mops {100000.0 / sw.ElapsedMilliseconds * 1.0}");
    }

IanG имеет хороший пост по теме, предлагающий EnumerableFrom() в качестве имени (и упоминается, что Haskell и Rx называют это Return ). IIRC F # тоже называет это Return. Seq вызывает оператора singleton<'T>.

Если вы готовы сосредоточиться на C #, то соблазнительно назвать это Yield [имея в виду yield return, участвовавший в его реализации].

Если вас интересуют его аспекты производительности, у Джеймса Майкла Хейра есть тоже возвращает ноль или один пост элементов, который стоит просканировать.

Это может быть не лучше, но это круто:

Enumerable.Range(0, 1).Select(i => item);

Я бы сказал, что самый простой способ - new T[]{item};; для этого нет синтаксиса. Ближайший эквивалент, который я могу придумать, - это ключевое слово params, но, конечно, для него требуется доступ к определению метода, и его можно использовать только с массивами.

Enumerable.Range(1,1).Select(_ => {
    //Do some stuff... side effects...
    return item;
});

Приведенный выше код полезен при использовании подобного

var existingOrNewObject = MyData.Where(myCondition)
       .Concat(Enumerable.Range(1,1).Select(_ => {
           //Create my object...
           return item;
       })).Take(1).First();

В приведенном выше фрагменте кода нет проверки на пустой / пустой, и гарантируется, что будет возвращен только один объект, не опасаясь исключений. Кроме того, из-за ленивости закрытие не будет выполнено, пока не будет доказано, что существующие данные не соответствуют критериям.

Я недавно спросил то же самое в другом сообщении (Есть ли способ вызвать метод C #, требующий IEnumerable ‹T› с одним значением? ... с тестированием).

Я хотел, чтобы люди заходили сюда, чтобы увидеть краткое сравнение тестов, показанное в этом новом посте, для 4 подходов, представленных в этих ответах.

Кажется, что простое написание new[] { x } в аргументах метода - самое короткое и быстрое решение.

Чтобы попасть в раздел «Не обязательно хорошее решение, но все же ... решение» или «Глупые трюки с LINQ», вы можете объединить _ 1_ с _ 2_ ...

IEnumerable<string> singleElementEnumerable = Enumerable.Empty<string>().Append("Hello, World!");

... или Enumerable.Prepend<>() ...

IEnumerable<string> singleElementEnumerable = Enumerable.Empty<string>().Prepend("Hello, World!");

Последние два метода доступны, начиная с .NET Framework 4.7.1 и .NET Core 1.0.

Это работоспособное решение, если бы кто-то действительно намеревался использовать существующие методы вместо написания собственных, хотя я не уверен, более или менее понятно, чем Enumerable.Repeat<>() решение. Это определенно более длинный код (отчасти из-за невозможности вывода параметров типа для Empty<>()), однако он создает вдвое больше объектов перечислителя.

Завершая это "Вы знали, что эти методы существуют?" ответ, Array.Empty<>() можно заменить на Enumerable.Empty<>(), но с этим трудно спорить это делает ситуацию ... лучше.

Иногда я поступаю так, когда чувствую себя озлобленным:

"_".Select(_ => 3.14)  // or whatever; any type is fine

То же самое и с меньшим количеством нажатий клавиш shift, хех:

from _ in "_" select 3.14

Для служебной функции я считаю, что это наименее подробный или, по крайней мере, более самодокументированный, чем массив, хотя он позволяет скользить нескольким значениям; в качестве плюса ее можно определить как локальную функцию:

static IEnumerable<T> Enumerate (params T[] v) => v;
// usage:
IEnumerable<double> example = Enumerate(1.234);

Вот все другие способы, которые мне удалось придумать (здесь можно запустить):

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

public class Program {
    
    public static IEnumerable<T> ToEnumerable1 <T> (T v) {
        yield return v;
    }
    
    public static T[] ToEnumerable2 <T> (params T[] vs) => vs;
    
    public static void Main () {
        static IEnumerable<T> ToEnumerable3 <T> (params T[] v) => v;
        p( new string[] { "three" } );
        p( new List<string> { "three" } );
        p( ToEnumerable1("three") ); // our utility function (yield return)
        p( ToEnumerable2("three") ); // our utility function (params)
        p( ToEnumerable3("three") ); // our local utility function (params)
        p( Enumerable.Empty<string>().Append("three") );
        p( Enumerable.Empty<string>().DefaultIfEmpty("three") );
        p( Enumerable.Empty<string>().Prepend("three") );
        p( Enumerable.Range(3, 1) ); // only for int
        p( Enumerable.Range(0, 1).Select(_ => "three") );
        p( Enumerable.Repeat("three", 1) );
        p( "_".Select(_ => "three") ); // doesn't have to be "_"; just any one character
        p( "_".Select(_ => 3.3333) );
        p( from _ in "_" select 3.0f );
        p( "a" ); // only for char
        // these weren't available for me to test (might not even be valid):
        //   new Microsoft.Extensions.Primitives.StringValues("three")
        
    }

    static void p <T> (IEnumerable<T> e) =>
        Console.WriteLine(string.Join(' ', e.Select((v, k) => $"[{k}]={v,-8}:{v.GetType()}").DefaultIfEmpty("<empty>")));

}

Я немного опаздываю на вечеринку, но все равно поделюсь своим путем. Моя проблема заключалась в том, что я хотел привязать ItemSource или WPF TreeView к одному объекту. Иерархия выглядит так:

Проект> Участки> Комнаты

Всегда должен был быть только один проект, но я все еще хотел показать проект в дереве, без необходимости передавать коллекцию только с одним объектом в нем, как некоторые предлагают.
Поскольку вы можете передавать только объекты IEnumerable как ItemSource Я решил сделать свой класс IEnumerable:

public class ProjectClass : IEnumerable<ProjectClass>
{
    private readonly SingleItemEnumerator<AufmassProjekt> enumerator;

    ... 

    public IEnumerator<ProjectClass > GetEnumerator() => this.enumerator;

    IEnumerator IEnumerable.GetEnumerator() => this.GetEnumerator();
}

И соответственно создайте свой собственный Enumerator:

public class SingleItemEnumerator : IEnumerator
{
    private bool hasMovedOnce;

    public SingleItemEnumerator(object current)
    {
        this.Current = current;
    }

    public bool MoveNext()
    {
        if (this.hasMovedOnce) return false;
        this.hasMovedOnce = true;
        return true;
    }

    public void Reset()
    { }

    public object Current { get; }
}

public class SingleItemEnumerator<T> : IEnumerator<T>
{
    private bool hasMovedOnce;

    public SingleItemEnumerator(T current)
    {
        this.Current = current;
    }

    public void Dispose() => (this.Current as IDisposable).Dispose();

    public bool MoveNext()
    {
        if (this.hasMovedOnce) return false;
        this.hasMovedOnce = true;
        return true;
    }

    public void Reset()
    { }

    public T Current { get; }

    object IEnumerator.Current => this.Current;
}

Это, вероятно, не самое «чистое» решение, но оно сработало для меня.

РЕДАКТИРОВАТЬ
Для соблюдения принципа единой ответственности как @Groo указал, что я создал новый класс-оболочку:

public class SingleItemWrapper : IEnumerable
{
    private readonly SingleItemEnumerator enumerator;

    public SingleItemWrapper(object item)
    {
        this.enumerator = new SingleItemEnumerator(item);
    }

    public object Item => this.enumerator.Current;

    public IEnumerator GetEnumerator() => this.enumerator;
}

public class SingleItemWrapper<T> : IEnumerable<T>
{
    private readonly SingleItemEnumerator<T> enumerator;

    public SingleItemWrapper(T item)
    {
        this.enumerator = new SingleItemEnumerator<T>(item);
    }

    public T Item => this.enumerator.Current;

    public IEnumerator<T> GetEnumerator() => this.enumerator;

    IEnumerator IEnumerable.GetEnumerator() => this.GetEnumerator();
}

Который я использовал вот так

TreeView.ItemSource = new SingleItemWrapper(itemToWrap);

ИЗМЕНИТЬ 2
Я исправил ошибку с помощью метода MoveNext().

я предпочитаю

public static IEnumerable<T> Collect<T>(this T item, params T[] otherItems)
{
    yield return item;
    foreach (var otherItem in otherItems)
    {
        yield return otherItem;
    }
}

Это позволяет вам вызывать item.Collect(), если вам нужен синглтон, но также позволяет вызывать item.Collect(item2, item3), если вы хотите