LINQ sorgularında ToList () veya ToArray () öğesini çağırmak daha iyi mi?

Sıklıkla bir sorguyu beyan etmek istediğim yerde değerlendirmek istediğim durumla karşılaşıyorum. Bunun nedeni genellikle birkaç kez yinelemem gerektiğidir ve hesaplanması pahalıdır. Örneğin:

string raw = "...";
var lines = (from l in raw.Split('\n')
             let ll = l.Trim()
             where !string.IsNullOrEmpty(ll)
             select ll).ToList();

Bu iyi çalışıyor. Ama eğer sonucu değiştirmeyeceksem, ToArray()bunun yerine arayabilirim ToList().

Bununla birlikte ToArray(), ilk çağrı ile uygulanıp uygulanmadığını ToList()ve bu nedenle sadece çağrı yapmaktan daha az bellek verimli olup olmadığını merak ediyorum ToList().

Ben deli miyim? ToArray()Hafızanın iki kez tahsis edilmeyeceği bilgisini kullanarak sadece güvenli ve emniyetli mi aramalıyım ?

Kullanmanız gereken diğer kısıtlamaları karşılamak için bir diziye ihtiyacınız olmadığı sürece ToList. Senaryoların çoğunda ToArraydaha fazla bellek ayıracaktır ToList.

Her ikisi de depolama için diziler kullanır, ancak ToListdaha esnek bir kısıtlamaya sahiptir. Dizinin, koleksiyondaki öğe sayısı kadar en az olması gerekir. Dizi daha büyükse, bu bir sorun değildir. Ancak ToArray, dizinin tam olarak öğe sayısına göre boyutlandırılması gerekir.

Bu kısıtlamayı karşılamak ToArraygenellikle daha fazla bir tahsisat yaparToList . Yeterince büyük bir dizi olduğunda, tam olarak doğru boyutta olan bir dizi ayırır ve öğeleri o diziye geri kopyalar. Bundan kaçınabileceği tek zaman, dizi için büyüme algoritmasının depolanması gereken elemanların sayısıyla (kesinlikle azınlıkta) çakışmasıdır.

DÜZENLE

Birkaç kişi bana fazladan kullanılmayan hafızanın List<T>değerinin sonucunu sordu .

Bu geçerli bir endişe. Oluşturulan koleksiyon uzun ömürlüdür, oluşturulduktan sonra asla değiştirilmez ve Gen2 yığınına iniş şansı yüksekse, ön tarafın ekstra tahsisini alarak daha iyi olabilirsiniz ToArray.

Genel olarak bunun daha nadir görülen bir durum olduğunu düşünüyorum. ToArrayHafızanın diğer kısa ömürlü kullanımlarına hemen aktarılan çok sayıda çağrı görmek çok daha yaygındır , bu durumdaToList açıkça daha iyidir.

Buradaki anahtar profil, profil ve daha sonra profil oluşturmaktır.

List<T>Dinamik olarak boyutlandırılmış bir dizi olarak uygulandığından performans farkı önemsiz olacaktır . Ya çağrılması ToArray()(dahili kullanan Buffer<T>ya da dizi büyümeye sınıfı) ToList()(çağıran List<T>(IEnumerable<T>)yapıcısı) bir diziye içine koyarak ve hepsine uyacak kadar diziyi büyüyen bir mesele olmanın sona erecek.

Bu gerçeğin somut bir onayını istiyorsanız, Reflector'da söz konusu yöntemlerin uygulanmasına bakın - neredeyse aynı koda kadar kaynadıklarını göreceksiniz.

(yedi yıl sonra...)

Diğer birkaç (iyi) cevap, ortaya çıkacak mikroskobik performans farklılıklarına odaklanmıştır.

Bu yazı, bir dizi ( ) tarafından üretilen ve a tarafından döndürülenle karşılaştırıldığında var olan anlamsal farktan bahsetmek için yalnızca bir ektir .IEnumerator<T>T[]List<T>

En iyi örnekle gösterilmiştir:

IList<int> source = Enumerable.Range(1, 10).ToArray();  // try changing to .ToList()

foreach (var x in source)
{
  if (x == 5)
    source[8] *= 100;
  Console.WriteLine(x);
}

Yukarıdaki kod istisnasız olarak çalışır ve çıktıyı üretir:

1
2
3
4
5
6
7
8
900
10

Bu, bir IEnumarator<int>döndürülen tarafından int[]numaralandırıcının oluşturulmasından bu yana dizinin değiştirilip değiştirilmediğini izlemediğini gösterir.

Yerel değişkeni sourcebir IList<int>. Bu şekilde, C # derleyicisinin foreachbir for (var idx = 0; idx < source.Length; idx++) { /* ... */ }döngüye eşdeğer bir şeye ifadeyi optimize etmediğinden emin olurum . Bu, var source = ...;bunun yerine kullanırsam C # derleyicisinin yapabileceği bir şeydir . .NET çerçevesinin şu anki sürümünde, burada kullanılan gerçek numaralandırıcı herkese açık olmayan bir başvuru tipidir, System.SZArrayHelper+SZGenericArrayEnumerator`1[System.Int32]ancak elbette bu bir uygulama detayıdır.

Ben değiştirmek Şimdi, eğer .ToArray()içine .ToList(), sadece alıyorum:

1
2
3
4
5

ardından bir System.InvalidOperationExceptionpatlama:

Koleksiyon değiştirildi; numaralandırma işlemi yürütülemeyebilir.

Bu durumda altta yatan numaralandırıcı genel değişken değer tipidir System.Collections.Generic.List`1+Enumerator[System.Int32]( IEnumerator<int>kullandığım için bu durumda bir kutunun içinde kutulu IList<int>).

Sonuç olarak, numaralandırmaList<T>sırasında üretilen numaralandırıcı listenin numaralandırma sırasında değişip değişmediğini takip ederken, ürettiği numaralandırıcıT[]değişmez. Bu yüzden.ToList()vearasında seçim yaparken bu farkı göz önünde bulundurun.ToArray().

İnsanlar genelde tek eklemek ekstra .ToArray() ya .ToList()da Bir numaralandırıcının yaşam süresi boyunca değiştirildiği konusunda izler bir koleksiyon atlatmak için.

(Kimsenin bilmesini istiyorsa nasılList<> toplama değiştirildiği konusunda izler, özel alan vardır _versionher şey değiştirilir Bu sınıfta List<>güncellenir.)

@Mquander ile performans farkının önemsiz olması konusunda hemfikirim. Ancak, emin olmak için karşılaştırmak istedim, bu yüzden yaptım - ve önemsiz.

Testing with List<T> source:
ToArray time: 1934 ms (0.01934 ms/call), memory used: 4021 bytes/array
ToList  time: 1902 ms (0.01902 ms/call), memory used: 4045 bytes/List

Testing with array source:
ToArray time: 1957 ms (0.01957 ms/call), memory used: 4021 bytes/array
ToList  time: 2022 ms (0.02022 ms/call), memory used: 4045 bytes/List

Her kaynak dizinin / Listenin 1000 öğesi vardı. Böylece hem zaman hem de bellek farklılıklarının göz ardı edilebilir olduğunu görebilirsiniz.

Sonuç olarak: ToList () ' i de kullanabilirsiniz , çünkü List<T>bir dizi bayt bellek sizin için gerçekten önemli olmadıkça, bir diziden daha fazla işlevsellik sağlar.

ToList()IEnumerable<T>(örneğin ORM'den) kullanıyorsanız genellikle tercih edilir . Sekansın uzunluğu başlangıçta bilinmiyorsa, ToArray()List gibi dinamik uzunluklu bir koleksiyon oluşturur ve daha sonra ekstra zaman alan diziye dönüştürür.

Bellek her zaman iki kez tahsis edilir - veya buna yakın bir şey. Bir diziyi yeniden boyutlandıramayacağınız için, her iki yöntem de büyüyen bir koleksiyondaki verileri toplamak için bir tür mekanizma kullanır. (Eh, Liste kendi içinde büyüyen bir koleksiyon.)

Liste, dahili depolama olarak bir dizi kullanır ve gerektiğinde kapasiteyi iki katına çıkarır. Bu, öğelerin ortalama 2 / 3'ünün en az bir kez yeniden tahsis edildiği, en az iki kez yeniden tahsis edilenlerin yarısının, en az üç kez bunların yarısının vb. Bu, her bir öğenin ortalama olarak 1,3 kez yeniden tahsis edildiği anlamına gelir, bu da çok fazla yük değildir.

Ayrıca, dize topluyorsanız koleksiyonun kendisinin yalnızca dizelere referanslar içerdiğini, dizelerin kendilerinin yeniden tahsis edilmediğini unutmayın.

Dışarıda 2020 ve herkes .NET Core 3.1 kullanıyor, bu yüzden Benchmark.NET ile bazı karşılaştırmalar yapmaya karar verdim.

TL; DR: ToArray () performans açısından daha iyidir ve koleksiyonu değiştirmeyi planlamıyorsanız daha iyi bir iş iletme amacı taşır.

    [MemoryDiagnoser]
    public class Benchmarks
    {
        [Params(0, 1, 6, 10, 39, 100, 666, 1000, 1337, 10000)]
        public int Count { get; set; }

        public IEnumerable<int> Items => Enumerable.Range(0, Count);

        [Benchmark(Description = "ToArray()", Baseline = true)]
        public int[] ToArray() => Items.ToArray();

        [Benchmark(Description = "ToList()")]
        public List<int> ToList() => Items.ToList();

        public static void Main() => BenchmarkRunner.Run<Benchmarks>();
    }

Sonuçlar:

    BenchmarkDotNet=v0.12.0, OS=Windows 10.0.14393.3443 (1607/AnniversaryUpdate/Redstone1)
    Intel Core i5-4460 CPU 3.20GHz (Haswell), 1 CPU, 4 logical and 4 physical cores
    Frequency=3124994 Hz, Resolution=320.0006 ns, Timer=TSC
    .NET Core SDK=3.1.100
      [Host]     : .NET Core 3.1.0 (CoreCLR 4.700.19.56402, CoreFX 4.700.19.56404), X64 RyuJIT
      DefaultJob : .NET Core 3.1.0 (CoreCLR 4.700.19.56402, CoreFX 4.700.19.56404), X64 RyuJIT


    |    Method | Count |          Mean |       Error |      StdDev |        Median | Ratio | RatioSD |   Gen 0 | Gen 1 | Gen 2 | Allocated |
    |---------- |------ |--------------:|------------:|------------:|--------------:|------:|--------:|--------:|------:|------:|----------:|
    | ToArray() |     0 |      7.357 ns |   0.2096 ns |   0.1960 ns |      7.323 ns |  1.00 |    0.00 |       - |     - |     - |         - |
    |  ToList() |     0 |     13.174 ns |   0.2094 ns |   0.1958 ns |     13.084 ns |  1.79 |    0.05 |  0.0102 |     - |     - |      32 B |
    |           |       |               |             |             |               |       |         |         |       |       |           |
    | ToArray() |     1 |     23.917 ns |   0.4999 ns |   0.4676 ns |     23.954 ns |  1.00 |    0.00 |  0.0229 |     - |     - |      72 B |
    |  ToList() |     1 |     33.867 ns |   0.7350 ns |   0.6876 ns |     34.013 ns |  1.42 |    0.04 |  0.0331 |     - |     - |     104 B |
    |           |       |               |             |             |               |       |         |         |       |       |           |
    | ToArray() |     6 |     28.242 ns |   0.5071 ns |   0.4234 ns |     28.196 ns |  1.00 |    0.00 |  0.0280 |     - |     - |      88 B |
    |  ToList() |     6 |     43.516 ns |   0.9448 ns |   1.1949 ns |     42.896 ns |  1.56 |    0.06 |  0.0382 |     - |     - |     120 B |
    |           |       |               |             |             |               |       |         |         |       |       |           |
    | ToArray() |    10 |     31.636 ns |   0.5408 ns |   0.4516 ns |     31.657 ns |  1.00 |    0.00 |  0.0331 |     - |     - |     104 B |
    |  ToList() |    10 |     53.870 ns |   1.2988 ns |   2.2403 ns |     53.415 ns |  1.77 |    0.07 |  0.0433 |     - |     - |     136 B |
    |           |       |               |             |             |               |       |         |         |       |       |           |
    | ToArray() |    39 |     58.896 ns |   0.9441 ns |   0.8369 ns |     58.548 ns |  1.00 |    0.00 |  0.0713 |     - |     - |     224 B |
    |  ToList() |    39 |    138.054 ns |   2.8185 ns |   3.2458 ns |    138.937 ns |  2.35 |    0.08 |  0.0815 |     - |     - |     256 B |
    |           |       |               |             |             |               |       |         |         |       |       |           |
    | ToArray() |   100 |    119.167 ns |   1.6195 ns |   1.4357 ns |    119.120 ns |  1.00 |    0.00 |  0.1478 |     - |     - |     464 B |
    |  ToList() |   100 |    274.053 ns |   5.1073 ns |   4.7774 ns |    272.242 ns |  2.30 |    0.06 |  0.1578 |     - |     - |     496 B |
    |           |       |               |             |             |               |       |         |         |       |       |           |
    | ToArray() |   666 |    569.920 ns |  11.4496 ns |  11.2450 ns |    571.647 ns |  1.00 |    0.00 |  0.8688 |     - |     - |    2728 B |
    |  ToList() |   666 |  1,621.752 ns |  17.1176 ns |  16.0118 ns |  1,623.566 ns |  2.85 |    0.05 |  0.8793 |     - |     - |    2760 B |
    |           |       |               |             |             |               |       |         |         |       |       |           |
    | ToArray() |  1000 |    796.705 ns |  16.7091 ns |  19.8910 ns |    796.610 ns |  1.00 |    0.00 |  1.2951 |     - |     - |    4064 B |
    |  ToList() |  1000 |  2,453.110 ns |  48.1121 ns |  65.8563 ns |  2,460.190 ns |  3.09 |    0.10 |  1.3046 |     - |     - |    4096 B |
    |           |       |               |             |             |               |       |         |         |       |       |           |
    | ToArray() |  1337 |  1,057.983 ns |  20.9810 ns |  41.4145 ns |  1,041.028 ns |  1.00 |    0.00 |  1.7223 |     - |     - |    5416 B |
    |  ToList() |  1337 |  3,217.550 ns |  62.3777 ns |  61.2633 ns |  3,203.928 ns |  2.98 |    0.13 |  1.7357 |     - |     - |    5448 B |
    |           |       |               |             |             |               |       |         |         |       |       |           |
    | ToArray() | 10000 |  7,309.844 ns | 160.0343 ns | 141.8662 ns |  7,279.387 ns |  1.00 |    0.00 | 12.6572 |     - |     - |   40064 B |
    |  ToList() | 10000 | 23,858.032 ns | 389.6592 ns | 364.4874 ns | 23,759.001 ns |  3.26 |    0.08 | 12.6343 |     - |     - |   40096 B |

    // * Hints *
    Outliers
      Benchmarks.ToArray(): Default -> 2 outliers were removed (35.20 ns, 35.29 ns)
      Benchmarks.ToArray(): Default -> 2 outliers were removed (38.51 ns, 38.88 ns)
      Benchmarks.ToList(): Default  -> 1 outlier  was  removed (64.69 ns)
      Benchmarks.ToArray(): Default -> 1 outlier  was  removed (67.02 ns)
      Benchmarks.ToArray(): Default -> 1 outlier  was  removed (130.08 ns)
      Benchmarks.ToArray(): Default -> 1 outlier  was  detected (541.82 ns)
      Benchmarks.ToArray(): Default -> 1 outlier  was  removed (7.82 us)

    // * Legends *
      Count     : Value of the 'Count' parameter
      Mean      : Arithmetic mean of all measurements
      Error     : Half of 99.9% confidence interval
      StdDev    : Standard deviation of all measurements
      Median    : Value separating the higher half of all measurements (50th percentile)
      Ratio     : Mean of the ratio distribution ([Current]/[Baseline])
      RatioSD   : Standard deviation of the ratio distribution ([Current]/[Baseline])
      Gen 0     : GC Generation 0 collects per 1000 operations
      Gen 1     : GC Generation 1 collects per 1000 operations
      Gen 2     : GC Generation 2 collects per 1000 operations
      Allocated : Allocated memory per single operation (managed only, inclusive, 1KB = 1024B)
      1 ns      : 1 Nanosecond (0.000000001 sec)

Düzenle : Bu cevabın son kısmı geçerli değil. Ancak, geri kalanı hala yararlı bilgiler, bu yüzden bırakacağım.

Bunun eski bir yazı olduğunu biliyorum, ama aynı soruyu yaptıktan ve biraz araştırma yaptıktan sonra, paylaşmaya değer olabilecek ilginç bir şey buldum.

İlk olarak, mquander ve cevabına katılıyorum. Performans açısından, ikisinin aynı olduğunu söylerken haklı.

Ancak, yansıtıcı System.Linq.Enumerablead alanındaki yöntemlere bakmak için Reflektör kullanıyorum ve çok yaygın bir optimizasyon fark ettim.
Mümkün olduğunda, IEnumerable<T>kaynak yönteme IList<T>veya ICollection<T>yöntemi optimize etmek için kullanılır. Örneğin, şuna bakın ElementAt(int).

İlginçtir, Microsoft sadece için optimizasyon yapmayı seçti IList<T>, ancak seçmedi IList. Microsoft'un IList<T>arayüzü kullanmayı tercih ettiği anlaşılıyor .

System.Arrayyalnızca uygular IList, bu nedenle bu uzantı optimizasyonlarından hiçbirinden yararlanamaz.
Bu nedenle, en iyi uygulamanın .ToList()yöntemi kullanmak olduğunu beyan ederim .
Uzantı yöntemlerinden herhangi birini kullanırsanız veya listeyi başka bir yönteme iletirseniz, bunun için bir optimize etme olasılığı vardır IList<T>.

İnsanların burada yapmadıkları diğer ölçütleri buldum, işte benim çatlamam. Metodolojimle ilgili bir sorun bulursanız bana bildirin.

/* This is a benchmarking template I use in LINQPad when I want to do a
 * quick performance test. Just give it a couple of actions to test and
 * it will give you a pretty good idea of how long they take compared
 * to one another. It's not perfect: You can expect a 3% error margin
 * under ideal circumstances. But if you're not going to improve
 * performance by more than 3%, you probably don't care anyway.*/
void Main()
{
    // Enter setup code here
    var values = Enumerable.Range(1, 100000)
        .Select(i => i.ToString())
        .ToArray()
        .Select(i => i);
    values.GetType().Dump();
    var actions = new[]
    {
        new TimedAction("ToList", () =>
        {
            values.ToList();
        }),
        new TimedAction("ToArray", () =>
        {
            values.ToArray();
        }),
        new TimedAction("Control", () =>
        {
            foreach (var element in values)
            {
                // do nothing
            }
        }),
        // Add tests as desired
    };
    const int TimesToRun = 1000; // Tweak this as necessary
    TimeActions(TimesToRun, actions);
}


#region timer helper methods
// Define other methods and classes here
public void TimeActions(int iterations, params TimedAction[] actions)
{
    Stopwatch s = new Stopwatch();
    int length = actions.Length;
    var results = new ActionResult[actions.Length];
    // Perform the actions in their initial order.
    for (int i = 0; i < length; i++)
    {
        var action = actions[i];
        var result = results[i] = new ActionResult { Message = action.Message };
        // Do a dry run to get things ramped up/cached
        result.DryRun1 = s.Time(action.Action, 10);
        result.FullRun1 = s.Time(action.Action, iterations);
    }
    // Perform the actions in reverse order.
    for (int i = length - 1; i >= 0; i--)
    {
        var action = actions[i];
        var result = results[i];
        // Do a dry run to get things ramped up/cached
        result.DryRun2 = s.Time(action.Action, 10);
        result.FullRun2 = s.Time(action.Action, iterations);
    }
    results.Dump();
}

public class ActionResult
{
    public string Message { get; set; }
    public double DryRun1 { get; set; }
    public double DryRun2 { get; set; }
    public double FullRun1 { get; set; }
    public double FullRun2 { get; set; }
}

public class TimedAction
{
    public TimedAction(string message, Action action)
    {
        Message = message;
        Action = action;
    }
    public string Message { get; private set; }
    public Action Action { get; private set; }
}

public static class StopwatchExtensions
{
    public static double Time(this Stopwatch sw, Action action, int iterations)
    {
        sw.Restart();
        for (int i = 0; i < iterations; i++)
        {
            action();
        }
        sw.Stop();

        return sw.Elapsed.TotalMilliseconds;
    }
}
#endregion

Şunları yapabilirsiniz buraya LINQPad Komut indirmek .

Sonuçlar:

Yukarıdaki kodu değiştirerek şunları keşfedeceksiniz:

1. Daha küçük dizilerle uğraşırken fark daha az önemlidir .
2. Fark ints ile uğraşırken s yerine daha az belirgindir string.
3. structS yerine büyük s kullanmak stringgenellikle çok daha fazla zaman alır, ancak oranı gerçekten fazla değiştirmez.

Bu, en çok oy alan cevapların sonuçlarına katılıyor:

1. Kodunuz sık sık birçok büyük veri listesi üretmedikçe, bir performans farkı fark etmeniz olası değildir. (100K dizesinden 1000 liste oluştururken yalnızca 200 ms fark vardı.)
2. ToList() tutarlı bir şekilde daha hızlı çalışır ve sonuçlara uzun süre devam etmeyi planlamıyorsanız daha iyi bir seçim olacaktır.

Güncelleme

@JonHanna Select, bir ToList()veya ToArray()uygulamanın uygulanmasına bağlı olarak ortaya çıkan koleksiyonun boyutunu önceden tahmin etmesinin mümkün olduğuna dikkat çekti . .Select(i => i)Yukarıdaki kodun değiştirilmesi şu anda Where(i => true) çok benzer sonuçlar vermektedir ve .NET uygulamasından bağımsız olarak bunu yapmak daha olasıdır.

Kararınızı , tasarım seçiminin ideal olarak ne olduğuna ToListveya ona ToArraygöre belirlemelisiniz. Yalnızca dizine göre yinelenebilen ve erişilebilen bir koleksiyon istiyorsanız, seçeneğini belirleyin ToArray. Daha sonra çok fazla uğraşmadan koleksiyona ekleme ve kaldırma ek yetenekleri istiyorsanız, o zaman bir ToList(gerçekten bir diziye ekleyemezsiniz, ancak bu genellikle doğru araç değildir).

Performans önemliyse, neyin daha hızlı çalışacağını da düşünmelisiniz. Gerçekçi, aramak olmaz ToListya ToArraymilyonlarca kez, ama belki elde toplanmasıyla ilgili milyonlarca kez çalışır. Bu açıdan []bu yana, daha da List<>olan []bazı giderler ile. Bazı verimlilik karşılaştırması için bu konuya bakın: Hangisi daha verimli: List <int> veya int []

Bir süre önce kendi testlerimde ToArraydaha hızlı bulmuştum . Ve testlerin ne kadar çarpık olduğundan emin değilim. Performans farkı o kadar önemsizdir ki bu, yalnızca bu sorguları milyonlarca kez çalıştırıyorsanız fark edilebilir.

Çok geç bir cevap ama bence googlers için yararlı olacaktır.

Linq kullanarak yarattıklarında ikisi de emer. Her ikisi de gerekirse arabelleği yeniden boyutlandırmak için aynı kodu kullanır . ToArraydahili IEnumerable<>olarak 4 öğeden oluşan bir dizi ayırarak diziye dönüştürmek için bir sınıf kullanır . Bu yeterli değilse, yeni bir dizi oluşturarak boyutu iki katına çıkarır ve geçerli dizinin çiftini kopyalar. Sonunda öğelerinizin yeni bir sayım dizisini ayırır. Sorgunuz 129 öğe döndürürse, ToArray, 256 öğe dizisi oluşturmak için 6 ayırma ve bellek kopyalama işlemi gerçekleştirir ve geri döndürülecek başka bir 129 dizisi olur. bellek verimliliği için çok fazla.

ToList aynı şeyi yapar, ancak gelecekte öğe ekleyebileceğiniz için son ayırmayı atlar. Liste, bir linq sorgusundan mı yoksa manuel olarak mı oluşturulduğunu umursamaz.

Oluşturma için Liste bellekle daha iyidir, ancak cpu ile daha da kötüsü, liste genel bir çözüm olduğundan, her eylem .net'in iç aralık dizilerine ek aralık kontrolleri gerektirir.

Sonuç kümenizde çok fazla yineleme yapacaksanız, listelerden daha az aralık kontrolü anlamına geldiğinden diziler iyidir ve derleyiciler genellikle dizileri sıralı erişim için optimize eder.

Listenin başlatma tahsisi, oluştururken kapasite parametresini belirtirseniz daha iyi olabilir. Bu durumda, sonuç boyutunu bildiğinizi varsayarak diziyi yalnızca bir kez ayıracaktır. ToListof linq, onu sağlamak için bir aşırı yük belirtmez, bu nedenle verilen kapasiteye sahip bir liste oluşturan ve daha sonra kullanan uzantı yöntemimizi oluşturmamız gerekir List<>.AddRange.

Bu cevabı bitirmek için aşağıdaki cümleleri yazmam gerekiyor

1. Sonunda, bir ToArray veya ToList kullanabilirsiniz, performans o kadar farklı olmaz (@EMP'nin cevabına bakın).
2. C # kullanıyorsunuz. Performansa ihtiyacınız varsa, yüksek performanslı kod hakkında yazma konusunda endişelenmeyin, ancak kötü performans kodu yazma konusunda endişelenmeyin.
3. Yüksek performanslı kod için daima x64'ü hedefleyin. AFAIK, x64 JIT, C ++ derleyicisini temel alır ve kuyruk özyineleme optimizasyonları gibi komik şeyler yapar.
4. 4.5 ile profil yönlendirmeli optimizasyonun ve çok çekirdekli JIT'in keyfini çıkarabilirsiniz.
5. Sonunda, daha hızlı işlemek için async / await desenini kullanabilirsiniz.

Bu eski bir sorudur - ama yanılmak isteyen kullanıcıların yararı için, bir Linq ifadesinin önbelleğe alınması ve birden fazla numaralandırmasının durdurulması etkisi olan Numaralandırmanın 'Hatırlanması' da bir alternatifi vardır (ToArray () ve ToList () yöntemi, listenin veya dizinin toplama öznitelikleri hiç kullanılmamasına rağmen çok kullanılır.

Memoize RX / System.Interactive lib dosyasında mevcuttur ve burada açıklanmıştır: System.Interactive ile daha fazla LINQ

(Gönderen Bart De'Smet blogunda bir olan yüksek sen Objects Linq ile çok çalışıyorsanız okumanız önerilir)

Bir seçenek, bir salt okunur döndüren kendi uzantı yönteminizi eklemektir ICollection<T>. Bu kullanmaktan daha iyi olabilir ToListveya ToArraybir dizi / listenin indeksleme özelliklerini birini kullanın veya bir listeden / kaldırmayı eklemek istemiyorum.

public static class EnumerableExtension
{
    /// <summary>
    /// Causes immediate evaluation of the linq but only if required.
    /// As it returns a readonly ICollection, is better than using ToList or ToArray
    /// when you do not want to use the indexing properties of an IList, or add to the collection.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="enumerable"></param>
    /// <returns>Readonly collection</returns>
    public static ICollection<T> Evaluate<T>(this IEnumerable<T> enumerable)
    {
        //if it's already a readonly collection, use it
        var collection = enumerable as ICollection<T>;
        if ((collection != null) && collection.IsReadOnly)
        {
            return collection;
        }
        //or make a new collection
        return enumerable.ToList().AsReadOnly();
    }
}

Birim testleri:

[TestClass]
public sealed class EvaluateLinqTests
{
    [TestMethod]
    public void EvalTest()
    {
        var list = new List<int> {1, 2, 3};
        var linqResult = list.Select(i => i);
        var linqResultEvaluated = list.Select(i => i).Evaluate();
        list.Clear();
        Assert.AreEqual(0, linqResult.Count());
        //even though we have cleared the underlying list, the evaluated list does not change
        Assert.AreEqual(3, linqResultEvaluated.Count());
    }

    [TestMethod]
    public void DoesNotSaveCreatingListWhenHasListTest()
    {
        var list = new List<int> {1, 2, 3};
        var linqResultEvaluated = list.Evaluate();
        //list is not readonly, so we expect a new list
        Assert.AreNotSame(list, linqResultEvaluated);
    }

    [TestMethod]
    public void SavesCreatingListWhenHasReadonlyListTest()
    {
        var list = new List<int> {1, 2, 3}.AsReadOnly();
        var linqResultEvaluated = list.Evaluate();
        //list is readonly, so we don't expect a new list
        Assert.AreSame(list, linqResultEvaluated);
    }

    [TestMethod]
    public void SavesCreatingListWhenHasArrayTest()
    {
        var list = new[] {1, 2, 3};
        var linqResultEvaluated = list.Evaluate();
        //arrays are readonly (wrt ICollection<T> interface), so we don't expect a new object
        Assert.AreSame(list, linqResultEvaluated);
    }

    [TestMethod]
    [ExpectedException(typeof (NotSupportedException))]
    public void CantAddToResultTest()
    {
        var list = new List<int> {1, 2, 3};
        var linqResultEvaluated = list.Evaluate();
        Assert.AreNotSame(list, linqResultEvaluated);
        linqResultEvaluated.Add(4);
    }

    [TestMethod]
    [ExpectedException(typeof (NotSupportedException))]
    public void CantRemoveFromResultTest()
    {
        var list = new List<int> {1, 2, 3};
        var linqResultEvaluated = list.Evaluate();
        Assert.AreNotSame(list, linqResultEvaluated);
        linqResultEvaluated.Remove(1);
    }
}

ToListAsync<T>() tercih edilir.

Entity Framework 6'da her iki yöntem de sonunda aynı dahili yöntemi ToArrayAsync<T>()çağırır , ancak list.ToArray()sonunda çağrılan

T[] array = new T[_size];
Array.Copy(_items, 0, array, 0, _size);
return array;

Yani ToArrayAsync<T>()bazı ek yükleri vardır, bu ToListAsync<T>()nedenle tercih edilir.

Her zaman eski soru ama yeni soru soran kişiler.

System.Linq.Enumerable kaynağına göre , ToListsadece a new List(source), geri dönmek için ise ToArraya new Buffer<T>(source).ToArray()kullanın T[].

Bellek ayırma hakkında:

IEnumerable<T>Tek bir nesne üzerinde çalışırken, ToArraybelleği bir kez daha ayırın ToList. Ancak çoğu durumda bununla ilgilenmek zorunda değilsiniz, çünkü GC gerektiğinde çöp toplamayı yapacak.

Çalışma zamanı verimli hakkında:

Bu soruyu sorgulayanlar aşağıdaki kodu kendi makinenizde çalıştırabilir ve cevabınızı alırsınız.

class PersonC
{
    public Guid uuid;
    public string name;
    public int age;
    public bool sex;
    public DateTime BirthDay;
    public double weight;
}

struct PersonS
{
    public Guid uuid;
    public string name;
    public int age;
    public bool sex;
    public DateTime BirthDay;
    public double weight;
}

class PersonT<T> : IEnumerable<T>
{
    private List<T> items;
    public PersonT(IEnumerable<T> init)
    {
        items = new List<T>(init);
    }

    public IEnumerator<T> GetEnumerator() => items.GetEnumerator();
    IEnumerator IEnumerable.GetEnumerator() => items.GetEnumerator();
}

private IEnumerable<PersonC> C(int count)
{
    for (var i = 0; i < count; ++i)
    {
        var guid = Guid.NewGuid();
        var guidBytes = guid.ToByteArray(); //16 bytes
        yield return new PersonC
        {
            uuid = guid,
            name = guid.ToString(),
            age = guidBytes[0] ^ guidBytes[7],
            sex = guidBytes[14] % 2 == 0,
            BirthDay = DateTime.Now.AddDays(-guidBytes[11] * 18),
            weight = guidBytes[12] * 100
        };
    }
}

private IEnumerable<PersonS> S(int count)
{
    for (var i = 0; i < count; ++i)
    {
        var guid = Guid.NewGuid();
        var guidBytes = guid.ToByteArray(); //16 bytes
        yield return new PersonS
        {
            uuid = guid,
            name = guid.ToString(),
            age = guidBytes[0] ^ guidBytes[7],
            sex = guidBytes[14] % 2 == 0,
            BirthDay = DateTime.Now.AddDays(-guidBytes[11] * 18),
            weight = guidBytes[12] * 100
        };
    }
}

private void MakeLog(string test, List<long> log) =>
    Console.WriteLine("{0} {1} ms -> [{2}]",
        test,
        log.Average(),
        string.Join(", ", log)
    );

private void Test1(int times, int count)
{
    var test = Enumerable.Range(1, times).ToArray();

    MakeLog("C.ToList", test.Select(o =>
    {
        var sw = new Stopwatch();
        GC.Collect();
        sw.Start();
        var ret = C(count).ToList();
        sw.Stop();
        return sw.ElapsedMilliseconds;
    }).ToList());

    MakeLog("C.ToArray", test.Select(o =>
    {
        var sw = new Stopwatch();
        GC.Collect();
        sw.Start();
        var ret = C(count).ToArray();
        sw.Stop();
        return sw.ElapsedMilliseconds;
    }).ToList());

    MakeLog("S.ToList", test.Select(o =>
    {
        var sw = new Stopwatch();
        GC.Collect();
        sw.Start();
        var ret = S(count).ToList();
        sw.Stop();
        return sw.ElapsedMilliseconds;
    }).ToList());

    MakeLog("S.ToArray", test.Select(o =>
    {
        var sw = new Stopwatch();
        GC.Collect();
        sw.Start();
        var ret = S(count).ToArray();
        sw.Stop();
        return sw.ElapsedMilliseconds;
    }).ToList());
}

private void Test2(int times, int count)
{
    var test = Enumerable.Range(1, times).ToArray();

    var dataC1 = new PersonT<PersonC>(C(count));
    var dataS1 = new PersonT<PersonS>(S(count));

    MakeLog("C1.ToList", test.Select(o =>
    {
        var sw = new Stopwatch();
        GC.Collect();
        sw.Start();
        var ret = dataC1.ToList();
        sw.Stop();
        return sw.ElapsedMilliseconds;
    }).ToList());

    MakeLog("C1.ToArray", test.Select(o =>
    {
        var sw = new Stopwatch();
        GC.Collect();
        sw.Start();
        var ret = dataC1.ToArray();
        sw.Stop();
        return sw.ElapsedMilliseconds;
    }).ToList());

    MakeLog("S1.ToList", test.Select(o =>
    {
        var sw = new Stopwatch();
        GC.Collect();
        sw.Start();
        var ret = dataS1.ToList();
        sw.Stop();
        return sw.ElapsedMilliseconds;
    }).ToList());

    MakeLog("S1.ToArray", test.Select(o =>
    {
        var sw = new Stopwatch();
        GC.Collect();
        sw.Start();
        var ret = dataS1.ToArray();
        sw.Stop();
        return sw.ElapsedMilliseconds;
    }).ToList());
}

private void Test3(int times, int count)
{
    var test = Enumerable.Range(1, times).ToArray();

    var dataC2 = (ICollection<PersonC>) new List<PersonC>(C(count));
    var dataS2 = (ICollection<PersonS>) new List<PersonS>(S(count));

    MakeLog("C2.ToList", test.Select(o =>
    {
        var sw = new Stopwatch();
        GC.Collect();
        sw.Start();
        var ret = dataC2.ToList();
        sw.Stop();
        return sw.ElapsedMilliseconds;
    }).ToList());

    MakeLog("C2.ToArray", test.Select(o =>
    {
        var sw = new Stopwatch();
        GC.Collect();
        sw.Start();
        var ret = dataC2.ToArray();
        sw.Stop();
        return sw.ElapsedMilliseconds;
    }).ToList());

    MakeLog("S2.ToList", test.Select(o =>
    {
        var sw = new Stopwatch();
        GC.Collect();
        sw.Start();
        var ret = dataS2.ToList();
        sw.Stop();
        return sw.ElapsedMilliseconds;
    }).ToList());

    MakeLog("S2.ToArray", test.Select(o =>
    {
        var sw = new Stopwatch();
        GC.Collect();
        sw.Start();
        var ret = dataS2.ToArray();
        sw.Stop();
        return sw.ElapsedMilliseconds;
    }).ToList());
}

private void TestMain()
{
    const int times = 100;
    const int count = 1_000_000 + 1;
    Test1(times, count);
    Test2(times, count);
    Test3(times, count);
}

Bu sonuçları makinemde aldım:

Grup 1:

C.ToList 761.79 ms -> [775, 755, 759, 759, 756, 759, 765, 750, 757, 762, 759, 754, 757, 753, 763, 753, 759, 756, 768, 754, 763, 757, 757, 777, 780, 758, 754, 758, 762, 754, 758, 757, 763, 758, 760, 754, 761, 755, 764, 847, 952, 755, 747, 763, 760, 758, 754, 763, 761, 758, 750, 764, 757, 763, 762, 756, 753, 759, 759, 757, 758, 779, 765, 760, 760, 756, 760, 756, 755, 764, 759, 753, 757, 760, 752, 764, 758, 760, 758, 760, 755, 761, 751, 753, 761, 762, 761, 758, 759, 752, 765, 756, 760, 755, 757, 753, 760, 751, 755, 779]
C.ToArray 782.56 ms -> [783, 774, 771, 771, 773, 774, 775, 775, 772, 770, 771, 774, 771, 1023, 975, 772, 767, 776, 771, 779, 772, 779, 775, 771, 775, 773, 775, 771, 765, 774, 770, 781, 772, 771, 781, 762, 817, 770, 775, 779, 769, 774, 763, 775, 777, 769, 777, 772, 775, 778, 775, 771, 770, 774, 772, 769, 772, 769, 774, 775, 768, 775, 769, 774, 771, 776, 774, 773, 778, 769, 778, 767, 770, 787, 783, 779, 771, 768, 805, 780, 779, 767, 773, 771, 773, 785, 1044, 853, 775, 774, 775, 771, 770, 769, 770, 776, 770, 780, 821, 770]
S.ToList 704.2 ms -> [687, 702, 709, 691, 694, 710, 696, 698, 700, 694, 701, 719, 706, 694, 702, 699, 699, 703, 704, 701, 703, 705, 697, 707, 691, 697, 707, 692, 721, 698, 695, 700, 704, 700, 701, 710, 700, 705, 697, 711, 694, 700, 695, 698, 701, 692, 696, 702, 690, 699, 708, 700, 703, 714, 701, 697, 700, 699, 694, 701, 697, 696, 699, 694, 709, 1068, 690, 706, 699, 699, 695, 708, 695, 704, 704, 700, 695, 704, 695, 696, 702, 700, 710, 708, 693, 697, 702, 694, 700, 706, 699, 695, 706, 714, 704, 700, 695, 697, 707, 704]
S.ToArray 742.5 ms -> [742, 743, 733, 745, 741, 724, 738, 745, 728, 732, 740, 727, 739, 740, 726, 744, 758, 732, 744, 745, 730, 739, 738, 723, 745, 757, 729, 741, 736, 724, 744, 756, 739, 766, 737, 725, 741, 742, 736, 748, 742, 721, 746, 1043, 806, 747, 731, 727, 742, 742, 726, 738, 746, 727, 739, 743, 730, 744, 753, 741, 739, 746, 728, 740, 744, 734, 734, 738, 731, 747, 736, 731, 765, 735, 726, 740, 743, 730, 746, 742, 725, 731, 757, 734, 738, 741, 732, 747, 744, 721, 742, 741, 727, 745, 740, 730, 747, 760, 737, 740]

C1.ToList 32.34 ms -> [35, 31, 31, 31, 32, 31, 31, 31, 31, 31, 31, 31, 31, 31, 33, 32, 31, 31, 31, 31, 30, 32, 31, 31, 31, 31, 32, 30, 31, 31, 31, 30, 32, 31, 31, 31, 36, 31, 31, 31, 32, 30, 31, 32, 31, 31, 31, 31, 31, 32, 31, 31, 31, 31, 33, 32, 31, 32, 31, 31, 33, 31, 31, 31, 31, 31, 32, 31, 32, 31, 34, 38, 68, 42, 79, 33, 31, 31, 31, 31, 31, 30, 30, 30, 30, 31, 31, 31, 31, 32, 31, 32, 31, 31, 31, 32, 33, 33, 31, 31]
C1.ToArray 56.32 ms -> [57, 56, 59, 54, 54, 55, 56, 57, 54, 54, 55, 55, 57, 56, 59, 57, 56, 58, 56, 56, 54, 56, 57, 55, 55, 55, 57, 58, 57, 58, 55, 55, 56, 55, 57, 56, 56, 59, 56, 56, 56, 56, 58, 56, 57, 56, 56, 57, 56, 55, 56, 56, 56, 59, 56, 56, 56, 55, 55, 54, 55, 54, 57, 56, 56, 56, 55, 55, 56, 56, 56, 59, 56, 56, 57, 56, 57, 56, 56, 56, 56, 62, 55, 56, 56, 56, 69, 57, 58, 56, 57, 58, 56, 57, 56, 56, 56, 56, 56, 56]
S1.ToList 88.69 ms -> [96, 90, 90, 89, 91, 88, 89, 90, 96, 89, 89, 89, 90, 90, 90, 89, 90, 90, 89, 90, 89, 91, 89, 91, 89, 91, 89, 90, 90, 89, 87, 88, 87, 88, 87, 87, 87, 87, 88, 88, 87, 87, 89, 87, 87, 87, 91, 88, 87, 86, 89, 87, 90, 89, 89, 90, 89, 87, 87, 87, 86, 87, 88, 90, 88, 87, 87, 92, 87, 87, 88, 88, 88, 86, 86, 87, 88, 87, 87, 87, 89, 87, 89, 87, 90, 89, 89, 89, 91, 89, 90, 89, 90, 88, 90, 90, 90, 88, 89, 89]
S1.ToArray 143.26 ms -> [130, 129, 130, 131, 133, 130, 131, 130, 135, 137, 130, 136, 132, 131, 130, 131, 132, 130, 132, 136, 130, 131, 157, 153, 194, 364, 176, 189, 203, 194, 189, 192, 183, 140, 142, 147, 145, 134, 159, 158, 142, 167, 130, 143, 145, 144, 160, 154, 156, 153, 153, 164, 142, 145, 137, 134, 145, 143, 142, 135, 133, 133, 135, 134, 134, 139, 139, 133, 134, 141, 133, 132, 133, 132, 133, 131, 135, 132, 133, 132, 128, 128, 130, 132, 129, 129, 129, 129, 129, 128, 134, 129, 129, 129, 129, 128, 128, 137, 130, 131]

C2.ToList 3.25 ms -> [5, 3, 3, 3, 3, 4, 3, 4, 3, 4, 3, 3, 3, 4, 4, 3, 3, 3, 4, 3, 3, 3, 3, 4, 3, 4, 3, 4, 3, 3, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 3, 4, 3, 3, 3, 3, 3, 4, 3, 4, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 3, 4, 3, 4, 3, 3, 3, 4, 3, 3, 4, 3, 3, 3, 4, 3, 3, 3, 3, 3]
C2.ToArray 3.37 ms -> [4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 3, 4, 3, 5, 4, 9, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 3, 3, 3, 3, 3, 4, 4, 3, 3, 4, 4, 3, 3, 3, 4, 3, 3, 3, 3, 4, 3, 3, 3, 3, 3, 4, 4, 3, 4, 4, 3, 3, 4, 3, 3, 4, 3, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 3, 3, 4, 3, 3, 3, 3, 3, 4, 4, 3, 3, 3, 3, 3, 4, 3, 4, 3, 3, 3]
S2.ToList 37.72 ms -> [38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 40, 38, 38, 39, 39, 38, 38, 38, 38, 37, 37, 37, 37, 39, 37, 37, 39, 38, 37, 37, 37, 37, 39, 38, 37, 37, 38, 37, 38, 37, 37, 38, 37, 37, 37, 38, 37, 37, 36, 37, 38, 37, 39, 37, 39, 38, 37, 38, 38, 38, 38, 38, 38, 37, 38, 38, 38, 38, 38, 37, 38, 37, 37, 38, 37, 37, 39, 41, 37, 38, 38, 37, 37, 37, 37, 38, 37, 37, 37, 40, 37, 37, 37, 37, 39, 38]
S2.ToArray 38.86 ms -> [39, 37, 39, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 39, 38, 38, 38, 38, 38, 38, 38, 38, 39, 39, 38, 38, 38, 39, 37, 38, 38, 38, 38, 38, 37, 37, 38, 37, 37, 38, 38, 40, 38, 38, 38, 38, 38, 39, 38, 38, 39, 38, 38, 39, 38, 38, 40, 38, 39, 38, 38, 39, 38, 38, 38, 38, 38, 39, 38, 38, 38, 39, 39, 37, 38, 38, 39, 71, 78, 37, 37, 37, 39, 38, 38, 39, 38, 38, 38, 38, 38, 39, 38, 38, 38, 39, 38, 38, 38]