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

Есть ли общий способ передачи одного элемента типа Tв метод, который ожидает IEnumerable<T>параметр? Язык - C #, версия фреймворка 2.0.

В настоящее время я использую вспомогательный метод (это .Net 2.0, поэтому у меня есть целая куча вспомогательных методов приведения / проектирования, похожих на LINQ), но это просто кажется глупым:

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

Другой способ, конечно, состоит в том, чтобы создать и заполнить List<T>или Arrayпередать и передать его вместо IEnumerable<T>.

[Edit] В качестве метода расширения его можно назвать:

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

Я что-то здесь упускаю?

[Edit2] Мы нашли someObject.Yield()(как предложил @Peter в комментариях ниже) лучшее имя для этого метода расширения, в основном для краткости, поэтому здесь, наряду с комментарием XML, если кто-то захочет его взять:

public static class IEnumerableExt
{
    /// <summary>
    /// Wraps this object instance into an IEnumerable&lt;T&gt;
    /// consisting of a single item.
    /// </summary>
    /// <typeparam name="T"> Type of the object. </typeparam>
    /// <param name="item"> The instance that will be wrapped. </param>
    /// <returns> An IEnumerable&lt;T&gt; consisting of a single item. </returns>
    public static IEnumerable<T> Yield<T>(this T item)
    {
        yield return item;
    }
}

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

Хорошо, если метод ожидает, что 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 });

или

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, и является прямым результатом создания Reactive Extensions (Rx).

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

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

Это 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 . F # Seqзвонит операторуsingleton<'T> .

Заманчиво, если вы готовы быть C # -центричным, это назвать это Yield[намекая на yield returnвовлеченных в реализацию этого].

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

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

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

Я согласен с комментариями @ EarthEngine к исходному сообщению о том, что AsSingleton - лучшее название. Смотрите эту запись в Википедии . Тогда из определения синглтона следует, что если в качестве аргумента передается нулевое значение, то AsSingleton должен возвращать IEnumerable с единственным нулевым значением вместо пустого 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, который кажется правильным.

Самый простой способ, которым я бы сказал, был бы 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();

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

Я немного опоздал на вечеринку, но все равно поделюсь своим путем. Моя проблема заключалась в том, что я хотел связать 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();
}

И создайте свой собственный перечислитель соответственно:

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()методом.

Чтобы быть поданным под "Не обязательно хорошим решением, но все же ... решением" или "Тупыми хитростями LINQ", вы могли бы объединиться Enumerable.Empty<>()с Enumerable.Append<>()...

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<>(), но трудно утверждать, что делает ситуацию ... лучше.

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

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

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