IEnumerable'ın olası çoklu numaralandırması için kullanım uyarısı

Benim kod IEnumerable<>birkaç kez kullanmak gerekir böylece "Olası çoklu numaralandırma" Resharper hata olsun IEnumerable.

Basit kod:

public List<object> Foo(IEnumerable<object> objects)
{
    if (objects == null || !objects.Any())
        throw new ArgumentException();

    var firstObject = objects.First();
    var list = DoSomeThing(firstObject);        
    var secondList = DoSomeThingElse(objects);
    list.AddRange(secondList);

    return list;
}

• objectsParametreyi değiştirebilir Listve sonra olası çoklu numaralandırmadan kaçınabilirim, ancak işleyebileceğim en yüksek nesneyi alamıyorum.
• Bunu yapabilirim başka bir şey dönüştürmek olduğunu IEnumerableiçin Listyöntemin başında:

 public List<object> Foo(IEnumerable<object> objects)
 {
    var objectList = objects.ToList();
    // ...
 }

Ama bu sadece garip .

Bu senaryoda ne yapardınız?

IEnumerableParametre olarak alma problemi , arayanlara "Bunu numaralandırmak istiyorum" demesidir. Kaç kez numaralandırmak istediğinizi söylemez.

Nesneler parametresini Liste olarak değiştirebilir ve sonra olası çoklu numaralandırmadan kaçınabilirim, ancak işleyebileceğim en yüksek nesneyi alamıyorum .

En yüksek nesneyi almanın hedefi asildir, ancak çok fazla varsayım için yer bırakır. Birisinin bu metoda LINQ'dan SQL sorgusuna geçmesini gerçekten istiyor musunuz, sadece iki kez numaralandırmanız için (her seferinde potansiyel olarak farklı sonuçlar elde etmek için?)

Burada semantik eksik, belki de yöntemin ayrıntılarını okumak için zaman almayan bir arayanın sadece bir kez yinelediğini varsayabilir - böylece size pahalı bir nesne iletirler. Yöntem imzanız her iki şekilde de gösterilmez.

Yöntem imzasını IList/ olarak değiştirerek, ICollectionen azından arayan kişiye beklentilerinizin ne olduğunu daha net hale getireceksiniz ve masraflı hatalardan kaçınabilirler.

Aksi takdirde, yönteme bakan çoğu geliştirici yalnızca bir kez yinelediğinizi varsayabilir. A almak IEnumerableçok önemliyse, .ToList()yöntemin başlangıcında yapmayı düşünmelisiniz .

Bu utanç verici. NET IEnumerable + Count + Indexer, Ekle / Kaldır vb. Yöntemleri olmadan bir arabirim yok, hangi ben bu sorunu çözmek şüpheli.

Verileriniz her zaman tekrarlanabilir olacaksa, belki de endişelenmeyin. Bununla birlikte, bunu da açabilirsiniz - bu, özellikle gelen veriler büyükse (örneğin, disk / ağdan okuma) faydalıdır:

if(objects == null) throw new ArgumentException();
using(var iter = objects.GetEnumerator()) {
    if(!iter.MoveNext()) throw new ArgumentException();

    var firstObject = iter.Current;
    var list = DoSomeThing(firstObject);  

    while(iter.MoveNext()) {
        list.Add(DoSomeThingElse(iter.Current));
    }
    return list;
}

Not DoSomethingElse'in semantiğini biraz değiştirdim, ancak bu esas olarak kaydedilmemiş kullanımı göstermek için. Örneğin yineleyiciyi yeniden sarabilirsiniz. Siz de güzel bir yineleyici blok yapabilirsiniz; o zaman hayır list- ve yield returniade edilecek bir listeye eklemek yerine, öğeleri aldığınız gibi yaparsınız.

Kullanılması IReadOnlyCollection<T>veya IReadOnlyList<T>yerine yöntem imzası IEnumerable<T>, sen iterating önce sayımı kontrol etmek gerekebilir veya başka bir nedenden dolayı birden çok kez yinelemek için bu açık hale avantajına sahiptir.

Bununla birlikte, kodlarınızı arabirimleri kullanmak için yeniden düzenlemeye çalışırsanız, örneğin daha dinamik ve dinamik proxy'ye daha kolay hale getirmek için sorunlara neden olacak büyük bir dezavantajı vardır. Kilit nokta, diğer koleksiyonlardan ve bunların ilgili salt okunur arabirimlerinden IList<T>miras kalmamasıIReadOnlyList<T> ve benzer şekilde olmasıdır. (Kısacası, bunun nedeni .NET 4.5'in önceki sürümlerle ABI uyumluluğunu korumak istemesidir. Ancak .NET çekirdeğinde bunu değiştirme fırsatını bile almadılar. )

Bu IList<T>, programın bir bölümünden alırsanız ve programın bir programın beklediği başka bir bölüme iletilmesini IReadOnlyList<T>istiyorsanız, bunu yapamazsınız demektir! Ancak IList<T>birIEnumerable<T> .

Sonunda, IEnumerable<T>tüm toplama arabirimleri de dahil olmak üzere tüm .NET koleksiyonları tarafından desteklenen tek salt okunur arabirimdir. Kendinizi bazı mimari seçimlerden kilitlediğinizi fark ettiğinizde, başka herhangi bir alternatif sizi ısırmaya geri dönecektir. Bu nedenle, salt okunur bir koleksiyon istediğinizi ifade etmek için işlev imzalarında kullanmak için uygun tür olduğunu düşünüyorum.

( IReadOnlyList<T> ToReadOnly<T>(this IList<T> list)Altta yatan tür her iki arabirimi de destekliyorsa , her zaman basit olan bir uzantı yöntemi yazabileceğinizi , ancak yeniden düzenleme yaparken IEnumerable<T>her zaman uyumlu olduğu her yerde manuel olarak eklemeniz gerektiğini unutmayın .)

Her zaman olduğu gibi, bu mutlak değildir, yanlışlıkla çoklu numaralandırmanın felaket olacağı veritabanı ağır kod yazıyorsanız, farklı bir takas tercih edebilirsiniz.

Eğer amaç Marc Gravell'in cevabı okuyacak olandan daha fazla numaralandırmayı önlemekse, aynı semantiği koruyarak artıklığı Anyve Firstçağrıları basitçe kaldırabilir ve devam edebilirsiniz:

public List<object> Foo(IEnumerable<object> objects)
{
    if (objects == null)
        throw new ArgumentNullException("objects");

    var first = objects.FirstOrDefault();

    if (first == null)
        throw new ArgumentException(
            "Empty enumerable not supported.", 
            "objects");

    var list = DoSomeThing(first);  

    var secondList = DoSomeThingElse(objects);

    list.AddRange(secondList);

    return list;
}

Bunun IEnumerablegenel olmadığınızı veya en azından bir referans türü olarak kısıtlandığını varsaydığını unutmayın .

Bu durumda genellikle yöntemimi IEnumerable ve IList ile aşırı yüklerim.

public static IEnumerable<T> Method<T>( this IList<T> source ){... }

public static IEnumerable<T> Method<T>( this IEnumerable<T> source )
{
    /*input checks on source parameter here*/
    return Method( source.ToList() );
}

IEnumerable'ı çağırmanın bir .ToList () gerçekleştireceği yöntemlerin özet yorumlarında açıklamaya dikkat ediyorum.

Birden fazla işlem birleştiriliyorsa, programcı daha yüksek bir seviyede .ToList () yöntemini seçebilir ve ardından IList aşırı yüklenmesini çağırabilir veya IEnumerable aşırı yükümün bununla ilgilenmesine izin verebilir.

Sadece ilk öğeyi kontrol etmeniz gerekiyorsa, tüm koleksiyonu tekrarlamadan göz atabilirsiniz:

public List<object> Foo(IEnumerable<object> objects)
{
    object firstObject;
    if (objects == null || !TryPeek(ref objects, out firstObject))
        throw new ArgumentException();

    var list = DoSomeThing(firstObject);
    var secondList = DoSomeThingElse(objects);
    list.AddRange(secondList);

    return list;
}

public static bool TryPeek<T>(ref IEnumerable<T> source, out T first)
{
    if (source == null)
        throw new ArgumentNullException(nameof(source));

    IEnumerator<T> enumerator = source.GetEnumerator();
    if (!enumerator.MoveNext())
    {
        first = default(T);
        source = Enumerable.Empty<T>();
        return false;
    }

    first = enumerator.Current;
    T firstElement = first;
    source = Iterate();
    return true;

    IEnumerable<T> Iterate()
    {
        yield return firstElement;
        using (enumerator)
        {
            while (enumerator.MoveNext())
            {
                yield return enumerator.Current;
            }
        }
    }
}

Öncelikle, bu uyarı her zaman çok fazla bir şey ifade etmez. Genellikle performans şişe boynu olmadığından emin olduktan sonra devre dışı bıraktım. Bu sadece IEnumerableiki kez değerlendirildiği anlamına gelir, evaluationkendisi uzun sürmediği sürece genellikle sorun değildir . Uzun zaman alsa bile, bu durumda ilk kez tek bir eleman kullanıyorsunuz.

Bu senaryoda güçlü linq genişletme yöntemlerinden daha fazla yararlanabilirsiniz.

var firstObject = objects.First();
return DoSomeThing(firstObject).Concat(DoSomeThingElse(objects).ToList();

Bu durumda sadece bir IEnumerablekez biraz güçlükle değerlendirmek, ancak önce profili değerlendirmek ve gerçekten bir sorun olup olmadığını görmek mümkündür.