Передача одного елемента як 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>.

[Редагувати] Як метод розширення він може бути названий:

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.Numerable:

// 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, і є прямим результатом створення реактивних розширень (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 # називає це також Повернення . 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'; де, у випадку, якщо нуль буде передано як аргумент, "AsSingleton" поверне одне нульове значення, а "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();
}

І відповідно створіть мого власного 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;
}

Це, мабуть, не найчистіше рішення, але воно працювало для мене.

EDIT
Щоб підтримувати принцип єдиної відповідальності, як зазначив @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);

EDIT 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 }аргументів методу - найкоротше і швидке рішення.