Tek bir öğeyi IEnumerable <T> olarak iletme

Tek bir öğe türünü parametre Tbekleyen bir yönteme geçirmenin yaygın bir yolu var mı IEnumerable<T>? Dil C #, çerçeve sürümü 2.0.

Şu anda bir yardımcı yöntem kullanıyorum (bu. Net 2.0, bu yüzden döküm / projelendirme yardımcı yöntemleri LINQ benzer bir sürü var), ama bu sadece aptalca görünüyor:

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

Başka bir yol elbette bir List<T>veya bir oluşturmak ve doldurmak Arrayve yerine geçmek olacaktır IEnumerable<T>.

[Düzenle] Bir uzantı yöntemi olarak adlandırılabilir:

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

Burada bir şey mi eksik?

[Edit2] We found someObject.Yield()(@Peter aşağıdaki yorum önerdiği gibi) işte o kimse yakala istiyorsa XML açıklama ile birlikte olduğunu, ağırlıklı olarak kısalık için, bu uzantı yöntemi için en iyi isim olarak:

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;
    }
}

Yardımcı yönteminiz bunu yapmanın en temiz yoludur, IMO. Bir listeyi veya diziyi iletirseniz, vicdansız bir kod parçası onu oluşturabilir ve içeriği değiştirebilir, bu da bazı durumlarda garip davranışlara yol açabilir. Salt okunur bir koleksiyon kullanabilirsiniz, ancak bu daha da fazla sarma içerir. Bence çözümünüz olabildiğince temiz.

Yöntem beklerse IEnumerable, yalnızca bir öğe içeriyor olsa bile liste olan bir şeyi iletmeniz gerekir.

geçen

new[] { item }

argümanın yeterli olması gerektiğini düşünüyorum

C # 3.0 sürümünde System.Linq.Enumerable sınıfını kullanabilirsiniz:

// using System.Linq

Enumerable.Repeat(item, 1);

Bu, yalnızca öğenizi içeren yeni bir IEnumerable oluşturur.

C # 3'te (2 dediğini biliyorum), sözdizimini biraz daha kabul edilebilir hale getirebilecek genel bir uzantı yöntemi yazabilirsiniz:

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

istemci kodu o zaman item.ToEnumerable().

Bu yardımcı yöntem öğe veya daha fazlası için çalışır.

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

Hiç kimse istemci API basitleştirmek için T tipi bir argüman ile yöntemin yeni bir aşırı yük önermek şaşırdım.

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

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

Artık müşteri kodunuz bunu yapabilir:

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

veya bir listeyle:

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

Her ikisi de (daha önce söylendiği gibi)

MyMethodThatExpectsAnIEnumerable(new[] { myObject });

veya

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

Yan not olarak, anonim bir nesnenin boş bir listesini istiyorsanız, son sürüm de güzel olabilir, örn.

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

Az önce bulduğum ve LukeH kullanıcısının da önerdiği gibi, bunu yapmanın güzel ve basit bir yolu aşağıdaki gibidir:

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
    }
}

Bu desen, aynı işlevselliği çeşitli şekillerde çağırmanıza olanak tanır: tek bir öğe; birden çok öğe (virgülle ayrılmış); bir dizi; bir liste; bir numaralandırma vb.

AsEnumerable yöntemini kullanarak verimliliği konusunda% 100 emin değilim, ama bir tedavi işe yarıyor.

Güncelleme: AsEnumerable işlevi oldukça verimli görünüyor! ( başvuru )

Her ne kadar bir yöntem için aşırı doldurulmuş olsa da, bazı kişilerin Etkileşimli Uzantıları yararlı bulabileceğine inanıyorum.

Microsoft'tan Etkileşimli Uzantılar (Ix) aşağıdaki yöntemi içerir.

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

Hangi gibi kullanılabilir:

var result = EnumerableEx.Return(0);

Ix, orijinal Linq genişletme yöntemlerinde bulunmayan yeni işlevler ekler ve Reaktif Uzantılar (Rx) oluşturmanın doğrudan sonucudur.

Düşün, Linq Extension Methods+ Ix= Rxiçin IEnumerable.

CodePlex üzerinde hem Rx hem de Ix'i bulabilirsiniz .

Bu, bu C # derleyici optimizasyonu nedeniyle kullanıldığında yieldveya Enumerable.Repeatkullanıldığında % 30 daha hızlıdır ve diğer durumlarda aynı performansa sahiptir.foreach

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);
    }
}

bu testte:

    // 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 , konuyla ilgili iyi bir yazıya sahip EnumerableFrom(), isim olarak önerdi (ve Haskell ve Rx'in söylediği Return).IIRC F # geri çağırır . F # ' Seqoperatörü çağırırsingleton<'T> .

C # merkezli olmaya hazır olmanız cazip Yield[ yield returnonu gerçekleştirme konusuna dahil olmak] olarak adlandırmaktır.

Mükemmel yönleriyle ilgileniyorsanız, James Michael Hare'in sıfır veya bir öğe yayını da var, bu da taramaya değer.

Bu daha iyi olmayabilir ama biraz havalı:

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

@ EarthEngine'ın orijinal yayına yaptığı yorumlara katılıyorum, yani 'AsSingleton' daha iyi bir isim. Bu wikipedia girişine bakın . Daha sonra singleton tanımından, null değeri bir argüman olarak iletilirse, 'AsSingleton', tartışmayı çözecek boş bir IEnumerable yerine tek bir null değerine sahip bir IEnumerable döndürmelidir if (item == null) yield break;. Bence en iyi çözüm iki yönteme sahip olmaktır: 'AsSingleton' ve 'AsSingletonOrEmpty'; burada, bir null değişkeninin bağımsız değişken olarak iletilmesi durumunda, 'AsSingleton' tek bir null değer döndürür ve 'AsSingletonOrEmpty' boş bir IEnumerable döndürür. Bunun gibi:

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;
}

Daha sonra, bunlar az çok IEnumerable üzerindeki 'First' ve 'FirstOrDefault' genişletme yöntemlerine benzeyecek ve bu da doğru geliyor.

Söylememin en kolay yolu new T[]{item};; bunu yapacak bir sözdizimi yok. Aklıma gelen en yakın eşdeğer paramsanahtar kelimedir, ancak elbette yöntem tanımına erişmenizi gerektirir ve yalnızca dizilerle kullanılabilir.

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

Yukarıdaki kod, like gibi kullanıldığında yararlıdır

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

Yukarıdaki kod snippet'inde boş / boş denetim yoktur ve istisnalardan korkmadan yalnızca bir nesnenin döndürülmesi garanti edilir. Ayrıca, tembel olduğu için kapatma, kriterlere uygun veri bulunmadığı kanıtlanana kadar yürütülmeyecektir.

Partiye biraz geç kaldım ama yine de yolumu paylaşacağım. Benim sorunum ItemSource veya WPF TreeView tek bir nesneye bağlamak istedim oldu. Hiyerarşi şöyle görünür:

Proje> Arsalar> Oda (lar)

Her zaman sadece bir proje olacaktı, ama yine de projeyi Ağaçta Göstermek istedim, bazılarının önerdiği gibi içinde sadece bir nesne olan bir Koleksiyon geçirmek zorunda kalmadan.
Yalnızca IEnumerable nesnelerini ItemSource olarak iletebildiğiniz için sınıfımı IEnumerable yapmaya karar verdim:

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

    ... 

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

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

Ve buna göre kendi Numaralandırıcımı oluştur:

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;
}

Bu muhtemelen "en temiz" çözüm değil ama benim için çalıştı.

EDIT @Groo'nun işaret ettiği gibi tek sorumluluk ilkesini
desteklemek için yeni bir sarmalayıcı sınıfı oluşturdum:

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();
}

Hangi şekilde kullandım

TreeView.ItemSource = new SingleItemWrapper(itemToWrap);

DÜZENLEME 2 Yöntemle ilgili
bir hatayı düzelttim MoveNext().

"Mutlaka iyi bir çözüm değil, ama yine de ... bir çözüm" veya "Aptal LINQ hileleri" altında dosyalanabilmek Enumerable.Empty<>()için Enumerable.Append<>()...

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

... ya da Enumerable.Prepend<>()...

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

Son iki yöntem .NET Framework 4.7.1 ve .NET Core 1.0'dan beri kullanılabilir.

Bu seferki olsaydı çalışılabilir bir çözüm gerçekten var olan yöntemlerle yerine bundan daha az ya da açık olup olmadığını kararsız değilim ama kendi yazmaya niyet çözümü . Bu kesinlikle daha uzun bir koddur (kısmen tür parametre çıkarımının mümkün olmaması nedeniyleEnumerable.Repeat<>()Empty<>() ) ve iki kat daha fazla numaralandırıcı nesnesi oluşturur.

Bunu "Bu yöntemlerin var olduğunu biliyor muydunuz?" cevap, Array.Empty<>()yerine kullanılabilir Enumerable.Empty<>(), ancak durumu daha iyi hale getirdiğini iddia etmek zor ...

Geçenlerde başka bir yazı aynı şeyi sordum ( tek bir değeri olan bir IEnumerable <T> gerektiren bir C # yöntemi çağırmak için bir yolu var mı? ... Kıyaslama ile ).

Buradaki yanıtların, bu cevaplarda sunulan 4 yaklaşım için yeni yazıda gösterilen kısa kıyaslama karşılaştırmasını görmesini istedim.

Sadece new[] { x }yönteme argümanları yazmanın en kısa ve en hızlı çözüm olduğu görülmektedir.