Listeler kullanılabilir olduğunda diziyi kullanmak için bir neden var mı? [kapalı]

Görünüşe göre List<T>C #, bir dizinin yapabileceği her şeyi yapabilir ve daha fazlasını yapar ve aynı zamanda bellek ve performansta bir dizi kadar verimli görünebilir.

Peki neden bir dizi kullanmak isteyeyim ki?

Açıkçası bir API veya başka bir harici kısıtlamanın (yani Ana işlev) bir dizi kullanmamı gerektirdiği durumlar hakkında soru sormuyorum ... Sadece kendi kodumda yeni veri yapıları oluşturma hakkında soruyorum.

Aynı sebepten işe giderken kamyon kullanmam. Özelliklerini kullanmayacağım bir şey kullanmıyorum.

Her şeyden önce bir dizi ilkel bir yapıdır, bu yüzden bir dizi kesin bir List <> den daha hızlı ve daha verimlidir, yani argümanınız doğru değildir. Dizi ayrıca her yerde bulunur ve farklı diller ve platformlar kullanan geliştiriciler tarafından bilinir.

Liste <> yerine bir dizi kullanmamın en önemli nedeni, verilerin sabit uzunluklu olduğunu ima etmektir . Bu veri koleksiyonundan hiçbir öğe eklemez veya çıkarmazsam, türün bunu yansıttığından emin olmak istiyorum.

Başka bir şey, yeni bir veri yapısı uyguladığınızı ve bununla ilgili bazı makaleler okuduğunuzu varsayalım. Şimdi belirli algoritmaları uygularken, her zaman başkasının genel amaçlı bir tür uygulamasına güvenemezsiniz. .NET'ten Mono'ya ve hatta çerçevenin farklı sürümleri arasında bile değişiyor.

Ve bazen bir çerçeveye bağımlı tür yerine bir diziyi kullanan bir kod parçasını taşımak daha kolaydır.

Elbette değişken yapılar koleksiyonunuzu yönetmek için dizilere ihtiyacınız var ve bunlar olmadan ne yapardık?

struct EvilMutableStruct { public double X; } // don't do this

EvilMutableStruct[] myArray = new EvilMutableStruct[1];
myArray[0] = new EvilMutableStruct()
myArray[0].X = 1; // works, this modifies the original struct

List<EvilMutableStruct> myList = new List<EvilMutableStruct>();
myList.Add(new EvilMutableStruct());
myList[0].X = 1; // does not work, the List will return a *copy* of the struct

(Bir dizi değişken yapının arzu edilebildiği bazı durumlar olabileceğine dikkat edin, ancak genellikle dizilerdeki diğer değişkenlere karşı değişken yapıların bu farklı davranışı kaçınılması gereken bir hata kaynağıdır.

Daha ciddi olarak, bir öğeyi referans olarak iletmek istiyorsanız bir diziye ihtiyacınız vardır . yani

Interlocked.Increment(ref myArray[i]);  // works
Interlocked.Increment(ref myList[i]);   // does not work, you can't pass a property by reference

Kilitli olmayan güvenli güvenlik kodu için faydalı olabilir.

Sabit boyutlu koleksiyonunuzu varsayılan değerle hızlı ve verimli bir şekilde başlatmak istiyorsanız, bir diziye ihtiyacınız vardır .

double[] myArray = new double[1000]; // contains 1000 '0' values
                                     // without further initialisation

List<double> myList = new List<double>(1000) // internally contains 1000 '0' values, 
                                             // since List uses an array as backing storage, 
                                             // but you cannot access those
for (int i =0; i<1000; i++) myList.Add(0);   // slow and inelegant

(Liste için aynı şeyi yapan bir kurucu uygulamanın mümkün olacağına dikkat edin, c # bu özelliği sunmaz)

Koleksiyonun bölümlerini etkin bir şekilde kopyalamak istiyorsanız bir diziye ihtiyacınız var.

Array.Copy(array1, index1, array2, index2, length) // can't get any faster than this

double[,] array2d = new double[10,100];
double[] arraySerialized = new double[10*100];
Array.Copy(array2d, 0, arraySerialized, 0, arraySerialized.Length);
// even works for different dimensions

(yine, bu Liste için de uygulanabilecek bir şeydir, ancak bu özellik c # da mevcut değildir)

Peki neden bir dizi kullanmak isteyeyim ki?

Nadiren , belirli sayıda elemana ihtiyaç duyduğunuzu bildiğiniz bir senaryoya sahip olacaksınız. Tasarım açısından, bundan kaçınılmalıdır. Eğer 3 şeye ihtiyacınız varsa, işin doğası bir sonraki sürümde çok sık 4'e ihtiyacınız olacak demektir.

Yine de, bu nadir senaryo gerçekten gerçekleştiğinde, sabit büyüklüğün değişmezliğini zorlamak için bir dizi kullanmak yararlıdır. Diğer programcılara sabit bir boyut olduğuna dair bir sinyal verir ve birinin kod ekleyen başka bir yerde beklentileri eklemesi veya kaldırması durumunda kötüye kullanımı önlemeye yardımcı olur.

Sorunuz aslında daha önce cevaplanmış .

ve aynı zamanda bir dizi kadar hafıza ve performansta da etkili görünüyor.

Değil. Bağladığım sorudan:

List/foreach:  3054ms (589725196)
Array/foreach: 1860ms (589725196)

Bazı önemli durumlarda diziler iki kat daha hızlı. Bellek kullanımının önemsiz olmayan bir şekilde farklılık gösterdiğinden de eminim.

Sorunuzun ana önceliği bu nedenle mağlup edildiğinden, bunun sorunuzu yanıtladığını varsayıyorum. Buna ek olarak, bazen diziler sizi Win32 API veya GPU'nuzun gölgelendiricisi veya diğer bazı DotNet olmayan kütüphaneler tarafından zorlarlar.

DotNet içinde bile, bazı yöntemler dizileri tüketir ve / veya döndürür (örneğin String.Split). Hangi araçlar artık çağrı maliyeti yemelidir ya ToListve ToArrayher zaman ya da belki zayıf alt kullanıcılara bu çoğaltım yoluyla döngüsü devam uyum ve kullanım dizisi gerekir senin kod.

Bu konu hakkında Stack Overflow hakkında daha fazla soru ve cevaplar:

• Dizi - karşı List<T>: Ne zaman kullanmalı?
• Diğer veri yapıları yerine neden dizileri kullanıyoruz?
• Dizi kullanmak daha iyidir veya List<>?

Diğer cevaplarda listelenen nedenlere ek olarak, dizi değişmezinin bildirilmesi daha az karakter alır:

var array = new [] { "A", "B", "C" };
var list = new List<string>() { "A", "B", "C" };

Yerine diziyi kullanmak List, kodu biraz kısaltır ve sadece biraz daha okunabilir kılar (1) bir IEnumerable<T>hazır bilgiyi geçirmeniz gerektiğinde veya (2) başka işlevselliklerin Listönemli olmadığı ve bazı liste benzeri şeyler kullanmanız gerektiğinde değişmezi.

Bunu bazen birim testlerinde yaptım.

Bu kesinlikle bir OO perspektifinden.

Etrafında sadece bir dizi iletmek için bir neden düşünemesem de, kesinlikle sınıfın içindeki bir dizi gösteriminin muhtemelen en iyi seçenek olduğu durumları görebiliyorum.

Benzer özellikler veren başka seçenekler olsa da, hiçbiri işleme izinleriyle ilgilenen, döngüler için iç içe geçmiş, matris gösterimi, bitmapler ve veri araya sokma algoritmalarıyla ilgili sorunlar için bir dizi olarak sezgisel görünmemektedir.

Çok geniş bir matris matematiğine dayanan çok sayıda bilimsel alan vardır. (örneğin görüntü işleme, veri hatası düzeltme, dijital sinyal işleme, uygulamalı matematik problemlerinin bir parçası). Bu alanlardaki algoritmaların çoğu, çok boyutlu diziler / matrisler kullanılarak yazılmıştır. Bu yüzden algoritmaları tanımladıkları gibi uygulamak, algoritmaların dayandığı kağıtlara doğrudan bağları kaybetmek pahasına, onları daha "yazılım" dostu yapmaktan daha doğal olacaktır.

Dediğim gibi, bu durumlarda muhtemelen listeleri kullanmaktan kurtulabilirsiniz ama bu zaten karmaşık algoritmaların üstüne başka bir karmaşıklık katmanı ekler.

Bu aslında listeleri de içeren diğer diller için de geçerlidir (Java veya Visual Basic gibi). Bir yöntem Liste yerine bir dizi döndürdüğü için dizi kullanmanız gereken durumlar vardır.

Gerçek bir programda, bir dizinin çok sık kullanılacağını sanmıyorum, ancak bazen verilerin sabit bir boyut olacağını biliyorsunuz ve dizi kullanmaktan aldığınız küçük performans kazancını seviyorsunuz. Mikro-optimizasyon, bir listeyi döndüren bir yöntem veya çok boyutlu bir veri yapısına duyulan ihtiyaç olarak geçerli bir sebep olabilir.

Yazdığım bir oyunda diziler için bir kullanım buldum. Sabit sayıda slotu olan bir envanter sistemi oluşturmak için kullandım. Bunun birkaç faydası vardı:

1. Oyun alanının ne kadar açık envanter yuvası olduğunu ve hangi yuvaların boş olduğunu görerek ve görerek olduğunu biliyordum.
2. Her öğenin tam olarak hangi endekste olduğunu biliyordum.
3. Hala bir "yazılı" dizisiydi (Öğe [] Envanter), bu yüzden "Öğe" türündeki nesneleri ekleyebilir / kaldırabilirim.

Envanterin boyutunu "artırmam" gerekirse, eski öğeleri yeni diziye aktararak yapabilirim, ancak envanter ekran alanıyla sabitlendiğinden ve dinamik olarak daha büyük hale getirme gereği duymadığımı düşündüm. / daha küçük, kullandığım amaç için işe yaradı.

Bir listenin tüm öğelerini geçiyorsanız, hayır, bir dizi gerekli değildir, 'sonraki' veya isteğe bağlı 'değiştirme olmadan seçim' iyi sonuç verir.

Ancak, algoritmanızın koleksiyondaki öğelere rasgele erişime ihtiyacı varsa, o zaman, evet, bir dizi gereklidir.

Bu, "Gitmek gerekli midir?" E benzer. Makul bir modern dilde hiç gerekli değildir. Ancak, soyutlamaları kaldırırsanız, bir noktada, aslında sizin için mevcut olan tek şey budur, yani, bu soyutlamaları uygulamanın tek yolu 'gereksiz' özelliktir. (Elbette, analoji mükemmel değildir, kimsenin dizilerin zayıf programlama uygulaması olduğunu söylemediğini sanmıyorum; anlaşılması ve düşünülmesi kolaydır).

Eski uyumluluk.

Tüm form kişisel deneyim:

Eski programcılar - meslektaşım her yerde dizileri kullanıyor, 30 yıldan uzun bir süredir devam ediyor, yeni meraklı fikirlerinizle fikrini değiştirmekte iyi şanslar.

Eski kod - foo (dizi çubuğu []) bir liste / vektör / toplama toarray işlevini kullanabildiğinizden emin olun, ancak orada herhangi bir ek özellik kullanmazsanız, başlangıçta tür değiştirme olmadan genellikle daha okunaklı olan bir diziyi kullanmak daha kolaydır.

Eski patron - Patronum yıllar önce yönetime girmeden önce iyi bir programcıydı ve hala bir koleksiyonun herkesin öğle yemeğine ne kadar pahalıya mal olabileceğini açıklayan, "dizileri kullanıyor" bir toplantıyı sonlandırabileceğini düşünüyor.

1) Listenin çok boyutlu bir versiyonu yoktur. Verileriniz birden fazla boyuta sahipse listeleri kullanmak çok verimsiz olacaktır.

2) Çok sayıda küçük veri türü ile uğraşırken (örneğin, sahip olduğunuz alanın tümü için bir bayt olan bir harita) önbellekleme nedeniyle önemli performans farklılıkları olabilir. Dizi sürümü, okuma başına birkaç öğe yüklüyor, liste sürümü yalnızca birini yüklüyor. Ayrıca, dizi sürümü, önbellekteki liste sürümünden birkaç kez daha fazla hücreye sahiptir - verileri tekrar tekrar işliyorsanız, dizi sürümü önbelleğe sığıyorsa ancak liste sürümü uymuyorsa, bu büyük bir fark yaratabilir.

Aşırı bir durum için Minecraft'ı düşünün. (Evet, C # ile yazılmış değildir. Aynı sebep geçerlidir.)

Bazı T tipindeki 100 elementli bir dizi, T tipindeki 100 bağımsız değişkeni kapsar. Eğer T, Q tipinde değişken bir ortak alana ve R tipinden birine sahip olan bir değer tipi olursa, dizinin her elemanı bağımsız değişkenleri içerecektir. Q ve R tiplerinin tümü, bir bütün olarak dizi, Q tipindeki 100 bağımsız değişkeni ve R tipindeki 100 bağımsız değişkeni içerecektir; Bu değişkenlerden herhangi birine, başkalarını etkilemeden tek tek erişilebilir. Dizilerden başka hiçbir toplama türü yapı alanlarının bağımsız değişken olarak kullanılmasına izin veremez.

Bunun yerine T, Q ve R türünde ortak değişken alanlara sahip bir sınıf türü olduysa, dizinin her öğesi tek bir referansı, evrenin herhangi bir yerinde, bir örneğine Tve dizinin öğelerinin hiçbiri hiç alamazsa Herhangi bir dış referansın var olduğu bir nesneyi tanımlamak için değiştirildikten sonra, dizi etkin bir şekilde Q tipi 100 bağımsız değişkeni ve 100 tipi R bağımsız değişkeni içerecektir. Diğer toplama türleri böyle bir dizinin davranışını taklit edebilir, ancak tek amaç bu ise dizi, Q değişkeninin 100 değişkenini ve R tipindeki 100 değişkenini kapsüllemek içindir, her bir değişken çiftini kendi sınıf nesnesine kapsüllemek bunu yapmak için pahalı bir yoldur. Daha ileri,Bir dizi veya değişken sınıf tipinde bir koleksiyon kullanmak, dizi elemanları tarafından tanımlanan değişkenlerin bağımsız olmaması ihtimalini yaratır .

Bir türün bir tür nesne gibi davranması gerekiyorsa, o zaman sınıf türü veya değiştirme dışında hiçbir mutasyon yolu sağlamayan özel alan yapısı olmalıdır. Ancak bir tür bağımsız ilişkili ama-değişkenlerin bir demet gibi koli bandı ile birbirine yapışmış davranmaya gerekiyordu, o zaman bir türü kullanması gereken edilir açıktaki alan yapı - değişkenlerin bir demet koli bandı ile birbirine yapışmış . Bu türden diziler, çalışmak için çok verimli ve çok temiz bir semantikaya sahip. Başka bir türün kullanılması, karışık anlambilim, düşük performans veya her ikisine de yol açacaktır.

Önemli olan önemli bir tanesi hafıza dağılımıdır. Örneğin, bağlı bir listeyi gezinmek, çok fazla önbellek eksikliğine ve daha yavaş performansa yol açabilir; oysa bir dizi, belirli bir veri türünün birden fazla örneğini tutan bitişik bir bellek yığınını temsil eder ve sırayla CPU'yu vurmak için daha muhtemeldir. önbelleği.

Tabii ki, bir nesne referansları dizisi önbellek vuruşlarından o kadar fazla yararlanamayabilir, çünkü kayıttan çıkarma işlemi sizi bellekte herhangi bir yere götürebilir.

Sonra bir dizi kullanarak bir liste uygulayan ArrayList gibi liste uygulamaları vardır. Onlar sahip olması gereken ilkel.

İşte ne zaman Arrayve ne zaman seçeceğiniz konusunda kullanabileceğiniz bazı rehberler List.

• ArrayBir yöntemden dönerken kullanın .
• ListDönüş değerini oluştururken değişken olarak kullanın (yöntemin içinde). Sonra .ToArray()yöntemden dönerken kullanın .

Genel olarak, Arraytüketiciyi, koleksiyona öğe eklemek niyetinde olmadığınız zamanlarda kullanın . ListTüketiciyi koleksiyona öğeler eklemek istediğinizde kullanın .

Arrayise "statik" koleksiyonları ile uğraşan içindir List"dinamik" koleksiyonları ile uğraşan içindir.