Bir List <T> belirli bir boyuta (kapasitenin tersine) nasıl başlatılır?

.NET, performansı neredeyse aynı olan genel bir liste kapsayıcısı sunar (bkz. Dizilerin Performansı ve Listeler Sorusu). Ancak, başlatmada oldukça farklıdırlar.

Dizilerin varsayılan bir değerle başlatılması çok kolaydır ve tanım gereği zaten belirli bir boyuta sahiptirler:

string[] Ar = new string[10];

Bu, rastgele öğeleri güvenli bir şekilde atamanıza izin verir, örneğin:

Ar[5]="hello";

liste ile işler daha karmaşıktır. Aynı başlatmayı yapmanın iki yolunu görebiliyorum, ikisi de zarif diyeceğiniz şey değil:

List<string> L = new List<string>(10);
for (int i=0;i<10;i++) L.Add(null);

veya

string[] Ar = new string[10];
List<string> L = new List<string>(Ar);

Daha temiz bir yol ne olabilir?

DÜZENLEME: Şimdiye kadar verilen cevaplar, bir listeyi önceden doldurmaktan başka bir şey olan kapasiteye atıfta bulunuyor. Örneğin, 10 kişi kapasiteli yeni oluşturulmuş bir listedeL[2]="somevalue"

DÜZENLEME 2: İnsanlar listeleri neden bu şekilde kullanmak istediğimi merak ediyorlar, çünkü amaçlanan şekilde kullanılmıyorlar. İki neden görebiliyorum:

1. Listelerin "yeni nesil" diziler olduğu ve neredeyse hiçbir ceza olmaksızın esneklik kattığı oldukça ikna edici bir şekilde tartışılabilir. Bu nedenle varsayılan olarak kullanılmalıdır. Başlamak kadar kolay olmayabileceklerine işaret ediyorum.

2. Şu anda yazdığım şey, daha büyük bir çerçevenin parçası olarak varsayılan işlevsellik sunan temel bir sınıf. Sunduğum varsayılan işlevde, Listenin boyutu gelişmiş olarak biliniyor ve bu nedenle bir dizi kullanabilirdim. Bununla birlikte, herhangi bir temel sınıfa onu dinamik olarak genişletme şansı sunmak istiyorum ve bu nedenle bir listeyi tercih ediyorum.

Buna çok sık ihtiyacım olduğunu söyleyemem - bunu neden istediğine dair daha fazla ayrıntı verebilir misin? Muhtemelen bunu yardımcı bir sınıfa statik bir yöntem olarak koyardım:

public static class Lists
{
    public static List<T> RepeatedDefault<T>(int count)
    {
        return Repeated(default(T), count);
    }

    public static List<T> Repeated<T>(T value, int count)
    {
        List<T> ret = new List<T>(count);
        ret.AddRange(Enumerable.Repeat(value, count));
        return ret;
    }
}

Sen olabilir kullanmak Enumerable.Repeat(default(T), count).ToList()ama bu boyutlandırma tampon verimsiz nedeniyle olurdu.

Unutmayın ki T referans türüdür, bu depolayacak countiçin geçilen referans kopyalarını valuehepsi aynı nesneyi ifade edeceğinden öylesine - parametresi. Kullanım durumunuza bağlı olarak istediğiniz şey bu olabilir veya olmayabilir.

DÜZENLEME: Yorumlarda belirtildiği gibi, isterseniz Repeatedlisteyi doldurmak için bir döngü kullanabilirsiniz. Bu da biraz daha hızlı olur. Şahsen ben kodu Repeatdaha açıklayıcı buluyorum ve gerçek dünyada performans farkının alakasız olacağından şüpheleniyorum, ancak kilometreniz değişebilir.

List<string> L = new List<string> ( new string[10] );

Bağımsız değişken olarak bir int ("kapasite") alan yapıcıyı kullanın:

List<string> = new List<string>(10);

DÜZENLEME: Frederik'e katıldığımı eklemeliyim. Listeyi ilk etapta onu kullanmanın ardındaki tüm mantığa aykırı bir şekilde kullanıyorsunuz.

DÜZENLEME2:

DÜZENLEME 2: Şu anda yazdığım şey, daha büyük bir çerçevenin parçası olarak varsayılan işlevsellik sunan temel bir sınıf. Sunduğum varsayılan işlevde, Listenin boyutu gelişmiş olarak biliniyor ve bu nedenle bir dizi kullanabilirdim. Bununla birlikte, herhangi bir temel sınıfa onu dinamik olarak genişletme şansı sunmak istiyorum ve bu nedenle bir listeyi tercih ediyorum.

Neden tüm boş değerlere sahip bir Listenin boyutunu bilmesi gerekir ki? Listede gerçek değerler yoksa uzunluğun 0 olmasını beklerdim. Her neyse, bunun cludgy olması sınıfın amaçlanan kullanımına aykırı olduğunu gösteriyor.

Önce istediğiniz öğe sayısıyla bir dizi oluşturun ve ardından diziyi Listeye dönüştürün.

int[] fakeArray = new int[10];

List<int> list = fakeArray.ToList();

Sabit bir değerle başlatmak istiyorsanız neden bir Liste kullanıyorsunuz? Performans uğruna ona bir başlangıç ​​kapasitesi vermek istediğinizi anlayabiliyorum, ancak bir listenin düzenli bir diziye göre avantajlarından biri, gerektiğinde büyüyebilir mi?

Bunu yaptığınızda:

List<int> = new List<int>(100);

Kapasitesi 100 tam sayı olan bir liste oluşturursunuz. Bu, siz 101. öğeyi ekleyene kadar Listenizin 'büyümesine' gerek olmayacağı anlamına gelir. Listenin temelindeki dizi 100 uzunluğuyla başlatılacaktır.

Listelerin içeriğini bu şekilde başlatmak aslında listelerin amacı değildir. Listeler nesneleri tutmak için tasarlanmıştır. Belirli sayıları belirli nesnelere eşlemek istiyorsanız, liste yerine karma tablo veya sözlük gibi bir anahtar-değer çifti yapısı kullanmayı düşünün.

Verilerinizle konumsal bir ilişkilendirme ihtiyacını vurguluyor gibi görünüyorsunuz, bu nedenle ilişkisel bir dizi daha uygun olmaz mıydı?

Dictionary<int, string> foo = new Dictionary<int, string>();
foo[2] = "string";

Listeyi sabit bir değere sahip N elemanla başlatmak istiyorsanız:

public List<T> InitList<T>(int count, T initValue)
{
  return Enumerable.Repeat(initValue, count).ToList();
}

Listenizi varsayılan bir değerle akıllıca başlatmak için Linq'i kullanabilirsiniz. ( David B'nin cevabına benzer .)

var defaultStrings = (new int[10]).Select(x => "my value").ToList();

Bir adım daha ileri gidin ve her dizeyi "dize 1", "dize 2", "dize 3" vb. Farklı değerlerle başlatın:

int x = 1;
var numberedStrings = (new int[10]).Select(x => "string " + x++).ToList();

string [] temp = new string[] {"1","2","3"};
List<string> temp2 = temp.ToList();

Kabul edilen cevapta (yeşil onay işaretli cevap) bir sorun var.

Sorun:

var result = Lists.Repeated(new MyType(), sizeOfList);
// each item in the list references the same MyType() object
// if you edit item 1 in the list, you are also editing item 2 in the list

Nesnenin bir kopyasını gerçekleştirmek için yukarıdaki satırı değiştirmenizi tavsiye ederim. Bununla ilgili birçok farklı makale var:

• Yansıma yoluyla çağrılan String.MemberwiseClone () yöntemi çalışmıyor, neden?
• https://code.msdn.microsoft.com/windowsdesktop/CSDeepCloneObject-8a53311e

Listenizdeki her öğeyi NULL yerine varsayılan kurucu ile başlatmak istiyorsanız, aşağıdaki yöntemi ekleyin:

public static List<T> RepeatedDefaultInstance<T>(int count)
    {
        List<T> ret = new List<T>(count);
        for (var i = 0; i < count; i++)
        {
            ret.Add((T)Activator.CreateInstance(typeof(T)));
        }
        return ret;
    }

IList hakkında bir bildirim: MSDN IList Açıklamalar : "IList uygulamaları üç kategoriye ayrılır: salt okunur, sabit boyutlu ve değişken boyutlu. (...). Bu arabirimin genel sürümü için bkz System.Collections.Generic.IList<T>."

IList<T>dan DEĞİL devralır yapar IList(ama List<T>her ikisi uygulamak yapar IList<T>ve IList), ancak her zaman değişken boyutlu . NET IReadOnlyList<T>4.5'ten bu yana, AFAIK dışında, aradığınız şey olabilecek sabit boyutlu bir genel Liste yoktur.

Bu, birim testim için kullandığım bir örnek. Bir sınıf nesnesi listesi oluşturdum. Daha sonra servisten beklediğim 'X' sayıda nesneyi eklemek için forloop kullandım. Bu şekilde, herhangi bir boyut için bir Liste ekleyebilir / başlatabilirsiniz.

public void TestMethod1()
    {
        var expected = new List<DotaViewer.Interface.DotaHero>();
        for (int i = 0; i < 22; i++)//You add empty initialization here
        {
            var temp = new DotaViewer.Interface.DotaHero();
            expected.Add(temp);
        }
        var nw = new DotaHeroCsvService();
        var items = nw.GetHero();

        CollectionAssert.AreEqual(expected,items);


    }

Umarım size yardımcı olmuşumdur.

Biraz geç ama önerdiğiniz ilk çözüm bana çok daha temiz görünüyor: belleği iki kez ayırmıyorsunuz. List kurucusunun bile kopyalamak için dizide döngü yapması gerekir; içinde sadece boş elemanların olduğunu önceden bile bilmiyor.

1. - N - döngü N Maliyetini tahsis et: 1 * tahsis (N) + N * döngü_iterasyonu

2. - N tahsis et - N + döngüyü tahsis et () Maliyet: 2 * tahsis (N) + N * loop_iteration

Bununla birlikte, List yerleşik bir sınıf olduğundan, List'in bir döngü ataması daha hızlı olabilir, ancak C # jit-compiled sooo ...