Menangani peringatan untuk kemungkinan penghitungan berulang IEnumerable

Dalam kode saya perlu menggunakan IEnumerable<>beberapa kali sehingga mendapatkan kesalahan Resharper dari "Kemungkinan beberapa enumerasi IEnumerable".

Kode sampel:

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

• Saya dapat mengubah objectsparameter menjadi Listdan kemudian menghindari kemungkinan beberapa enumerasi tetapi kemudian saya tidak mendapatkan objek tertinggi yang bisa saya tangani.
• Hal lain yang dapat saya lakukan adalah mengonversikan IEnumerableke Listdi awal metode:

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

Tapi ini hanya canggung .

Apa yang akan Anda lakukan dalam skenario ini?

Masalah dengan mengambil IEnumerablesebagai parameter adalah bahwa ia memberi tahu penelepon "Saya ingin menyebutkan ini". Itu tidak memberitahu mereka berapa kali Anda ingin menghitung.

Saya bisa mengubah parameter objek menjadi Daftar dan kemudian menghindari kemungkinan beberapa enumerasi tapi kemudian saya tidak mendapatkan objek tertinggi yang bisa saya tangani .

Tujuan mengambil objek tertinggi adalah mulia, tetapi meninggalkan ruang untuk terlalu banyak asumsi. Apakah Anda benar-benar ingin seseorang untuk meneruskan permintaan LINQ ke SQL ke metode ini, hanya untuk Anda menghitungnya dua kali (mendapatkan hasil yang berpotensi berbeda setiap kali?)

Semantik yang hilang di sini adalah bahwa seorang penelepon, yang mungkin tidak meluangkan waktu untuk membaca rincian metode ini, mungkin menganggap Anda hanya mengulangi sekali - sehingga mereka memberi Anda objek mahal. Tanda tangan metode Anda tidak menunjukkan apa pun.

Dengan mengubah tanda tangan metode ke IList/ ICollection, Anda setidaknya akan membuatnya lebih jelas kepada penelepon apa harapan Anda, dan mereka dapat menghindari kesalahan mahal.

Jika tidak, sebagian besar pengembang yang melihat metode ini mungkin menganggap Anda hanya mengulanginya sekali saja. Jika meminum IEnumerablesangat penting, Anda harus mempertimbangkan untuk melakukan .ToList()di awal metode.

Sayang sekali. NET tidak memiliki antarmuka IEnumerable + Count + Indexer, tanpa metode Add / Remove etc., yang saya duga akan menyelesaikan masalah ini.

Jika data Anda selalu dapat diulang, mungkin jangan khawatir tentang hal itu. Namun, Anda juga dapat membuka gulungannya - ini sangat berguna jika data yang masuk bisa besar (misalnya, membaca dari disk / jaringan):

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

Catatan Saya mengubah semantik DoSomethingElse sedikit, tetapi ini terutama untuk menunjukkan penggunaan yang belum dibuka. Anda bisa membungkus kembali iterator, misalnya. Anda bisa membuatnya menjadi blok iterator juga, yang bisa jadi bagus; maka tidak ada list- dan Anda akan yield returnitem yang Anda dapatkan, daripada menambah daftar untuk dikembalikan.

Menggunakan IReadOnlyCollection<T>atau IReadOnlyList<T>dalam metode tanda tangan alih-alih IEnumerable<T>, memiliki keuntungan membuat eksplisit bahwa Anda mungkin perlu memeriksa penghitungan sebelum mengulangi, atau mengulangi beberapa kali karena alasan lain.

Namun mereka memiliki kelemahan besar yang akan menyebabkan masalah jika Anda mencoba untuk memperbaiki kode Anda untuk menggunakan antarmuka, misalnya untuk membuatnya lebih dapat diuji dan ramah terhadap proxy dinamis. Poin kuncinya adalah yang IList<T>tidak diwariskan dariIReadOnlyList<T> , dan juga untuk koleksi lain dan masing-masing antarmuka read-only. (Singkatnya, ini karena .NET 4.5 ingin menjaga kompatibilitas ABI dengan versi sebelumnya. Tetapi mereka bahkan tidak mengambil kesempatan untuk mengubahnya di .NET core. )

Ini berarti bahwa jika Anda mendapatkan IList<T>dari beberapa bagian dari program dan ingin meneruskannya ke bagian lain yang mengharapkan IReadOnlyList<T>, Anda tidak bisa! Namun Anda dapat lulus IList<T>sebagaiIEnumerable<T> .

Pada akhirnya, IEnumerable<T>adalah satu-satunya antarmuka read-only yang didukung oleh semua koleksi .NET termasuk semua antarmuka koleksi. Alternatif lain akan kembali menggigit Anda ketika Anda menyadari bahwa Anda mengunci diri dari beberapa pilihan arsitektur. Jadi saya pikir ini adalah tipe yang tepat untuk digunakan dalam tanda tangan fungsi untuk menyatakan bahwa Anda hanya ingin koleksi read-only.

(Perhatikan bahwa Anda selalu dapat menulis IReadOnlyList<T> ToReadOnly<T>(this IList<T> list)metode ekstensi yang dicetak sederhana jika tipe yang mendasarinya mendukung kedua antarmuka, tetapi Anda harus menambahkannya secara manual di mana-mana ketika melakukan refactoring, di mana seperti IEnumerable<T>yang selalu kompatibel.)

Seperti biasa ini tidak mutlak, jika Anda menulis kode database-berat di mana penghitungan berulang secara tidak disengaja akan menjadi bencana, Anda mungkin lebih suka trade-off yang berbeda.

Jika tujuannya adalah benar-benar untuk mencegah beberapa enumerasi daripada jawaban oleh Marc Gravell adalah yang dibaca, tetapi mempertahankan semantik yang sama Anda dapat dengan mudah menghapus redundan Anydan Firstpanggilan dan pergi dengan:

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

Perhatikan, bahwa ini mengasumsikan bahwa Anda IEnumerabletidak generik atau setidaknya dibatasi menjadi tipe referensi.

Saya biasanya membebani metode saya dengan IEnumerable dan IList dalam situasi ini.

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

Saya berhati-hati untuk menjelaskan dalam ringkasan komentar tentang metode yang memanggil IEnumerable akan melakukan .ToList ().

Pemrogram dapat memilih untuk .ToList () pada tingkat yang lebih tinggi jika beberapa operasi sedang digabungkan dan kemudian memanggil kelebihan IList atau membiarkan kelebihan IEnumerable saya yang mengurusnya.

Jika Anda hanya perlu memeriksa elemen pertama, Anda dapat mengintipnya tanpa mengulangi seluruh koleksi:

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

Pertama, peringatan itu tidak selalu berarti banyak. Saya biasanya menonaktifkannya setelah memastikan itu bukan leher botol kinerja. Itu hanya berarti IEnumerabledievaluasi dua kali, yang biasanya tidak menjadi masalah kecuali jika evaluationitu sendiri membutuhkan waktu lama. Bahkan jika itu memakan waktu lama, dalam hal ini Anda hanya menggunakan satu elemen pertama kali.

Dalam skenario ini Anda juga dapat mengeksploitasi metode ekstensi LINQ yang kuat bahkan lebih.

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

Dimungkinkan untuk hanya mengevaluasi IEnumerablesekali dalam kasus ini dengan beberapa kerumitan, tetapi profil terlebih dahulu dan lihat apakah itu benar-benar masalah.