วิธีการเริ่มต้นรายการ <T> เป็นขนาดที่กำหนด (เมื่อเทียบกับความจุ)

.NET นำเสนอคอนเทนเนอร์รายการทั่วไปที่มีประสิทธิภาพเกือบเหมือนกัน (ดูคำถามประสิทธิภาพของอาร์เรย์เทียบกับรายการ) อย่างไรก็ตามมันค่อนข้างแตกต่างกันในการเริ่มต้น

อาร์เรย์เป็นเรื่องง่ายมากที่จะเริ่มต้นด้วยค่าเริ่มต้นและตามความหมายพวกเขามีขนาดที่แน่นอนแล้ว:

string[] Ar = new string[10];

ซึ่งช่วยให้สามารถกำหนดรายการแบบสุ่มได้อย่างปลอดภัยพูดว่า:

Ar[5]="hello";

ด้วยรายการสิ่งที่ยุ่งยากกว่า ฉันสามารถเห็นสองวิธีในการเริ่มต้นเดียวกันซึ่งทั้งสองวิธีนี้ไม่ใช่สิ่งที่คุณเรียกว่าสง่างาม:

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

หรือ

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

อะไรจะเป็นวิธีที่สะอาดกว่านี้?

แก้ไข: คำตอบจนถึงตอนนี้อ้างถึงความจุซึ่งเป็นอย่างอื่นที่ไม่ใช่การเติมรายการล่วงหน้า ตัวอย่างเช่นในรายการที่เพิ่งสร้างขึ้นโดยมีความจุ 10 รายการไม่สามารถทำได้L[2]="somevalue"

แก้ไข 2: ผู้คนสงสัยว่าทำไมฉันถึงต้องการใช้รายการด้วยวิธีนี้เนื่องจากไม่ใช่วิธีที่พวกเขาตั้งใจจะใช้ ฉันเห็นเหตุผลสองประการ:

1. คนหนึ่งสามารถโต้แย้งได้อย่างน่าเชื่อว่ารายการเป็นอาร์เรย์ "รุ่นต่อไป" โดยเพิ่มความยืดหยุ่นโดยแทบไม่มีการลงโทษ ดังนั้นควรใช้เป็นค่าเริ่มต้น ฉันกำลังชี้ให้เห็นว่าอาจไม่ง่ายในการเริ่มต้น

2. สิ่งที่ฉันกำลังเขียนอยู่คือคลาสพื้นฐานที่มีฟังก์ชันการทำงานเริ่มต้นซึ่งเป็นส่วนหนึ่งของเฟรมเวิร์กที่ใหญ่กว่า ในฟังก์ชันเริ่มต้นที่ฉันนำเสนอขนาดของรายการเป็นที่รู้จักในขั้นสูงดังนั้นฉันจึงสามารถใช้อาร์เรย์ได้ อย่างไรก็ตามฉันต้องการให้คลาสพื้นฐานใด ๆ มีโอกาสที่จะขยายแบบไดนามิกดังนั้นฉันจึงเลือกใช้รายชื่อ

ฉันไม่สามารถพูดได้ว่าฉันต้องการสิ่งนี้บ่อยนัก - คุณสามารถให้รายละเอียดเพิ่มเติมว่าทำไมคุณถึงต้องการสิ่งนี้? ฉันอาจกำหนดให้เป็นวิธีการคงที่ในคลาสตัวช่วย:

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

คุณสามารถใช้Enumerable.Repeat(default(T), count).ToList()แต่ที่จะไม่มีประสิทธิภาพเนื่องจากการปรับขนาดบัฟเฟอร์

โปรดทราบว่าหากTเป็นประเภทการอ้างอิงจะจัดเก็บcountสำเนาของการอ้างอิงที่ส่งผ่านสำหรับvalueพารามิเตอร์ดังนั้นทั้งหมดจะอ้างถึงวัตถุเดียวกัน นั่นอาจใช่หรือไม่ใช่สิ่งที่คุณต้องการขึ้นอยู่กับกรณีการใช้งานของคุณ

แก้ไข: ตามที่ระบุไว้ในความคิดเห็นคุณสามารถRepeatedใช้การวนซ้ำเพื่อเติมข้อมูลในรายการได้หากต้องการ นั่นจะเร็วกว่าเล็กน้อยด้วย โดยส่วนตัวแล้วฉันพบรหัสโดยใช้Repeatคำอธิบายมากกว่าและสงสัยว่าในโลกแห่งความเป็นจริงความแตกต่างของประสิทธิภาพจะไม่เกี่ยวข้อง แต่ระยะทางของคุณอาจแตกต่างกันไป

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

ใช้ตัวสร้างซึ่งรับ int ("ความจุ") เป็นอาร์กิวเมนต์:

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

แก้ไข: ฉันควรเพิ่มว่าฉันเห็นด้วยกับ Frederik คุณกำลังใช้รายการในลักษณะที่ขัดต่อเหตุผลทั้งหมดที่อยู่เบื้องหลังการใช้รายการนี้ในตอนแรก

แก้ไข 2:

แก้ไข 2: สิ่งที่ฉันกำลังเขียนคือคลาสพื้นฐานที่มีฟังก์ชันเริ่มต้นซึ่งเป็นส่วนหนึ่งของเฟรมเวิร์กที่ใหญ่กว่า ในฟังก์ชันเริ่มต้นที่ฉันนำเสนอขนาดของรายการเป็นที่รู้จักในขั้นสูงดังนั้นฉันจึงสามารถใช้อาร์เรย์ได้ อย่างไรก็ตามฉันต้องการให้คลาสพื้นฐานใด ๆ มีโอกาสที่จะขยายแบบไดนามิกดังนั้นฉันจึงเลือกใช้รายชื่อ

ทำไมทุกคนต้องรู้ขนาดของรายการที่มีค่าว่างทั้งหมด? หากไม่มีค่าจริงในรายการฉันคาดว่าความยาวจะเป็น 0 อย่างไรก็ตามความจริงที่ว่านี่เป็นเรื่องเหลวไหลแสดงให้เห็นว่ามันขัดต่อการใช้คลาสที่ตั้งใจไว้

สร้างอาร์เรย์ด้วยจำนวนรายการที่คุณต้องการก่อนจากนั้นจึงแปลงอาร์เรย์เป็นรายการ

int[] fakeArray = new int[10];

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

เหตุใดคุณจึงใช้รายการหากคุณต้องการเริ่มต้นด้วยค่าคงที่ ฉันเข้าใจได้ว่า - เพื่อประโยชน์ในการทำงาน - คุณต้องการเพิ่มขีดความสามารถเริ่มต้น แต่ก็ไม่ใช่ข้อดีอย่างหนึ่งของรายการเหนืออาร์เรย์ปกติที่สามารถเติบโตได้เมื่อจำเป็น?

เมื่อคุณทำสิ่งนี้:

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

คุณสร้างรายการที่มีความจุ 100 จำนวนเต็ม ซึ่งหมายความว่ารายการของคุณไม่จำเป็นต้อง 'เติบโต' จนกว่าคุณจะเพิ่มรายการที่ 101 อาร์เรย์พื้นฐานของรายการจะเริ่มต้นด้วยความยาว 100

การเริ่มต้นเนื้อหาของรายการเช่นนั้นไม่ใช่สิ่งที่รายการมีไว้สำหรับ รายการถูกออกแบบมาเพื่อเก็บวัตถุ หากคุณต้องการจับคู่ตัวเลขเฉพาะกับวัตถุบางอย่างให้พิจารณาใช้โครงสร้างคู่คีย์ - ค่าเช่นตารางแฮชหรือพจนานุกรมแทนรายการ

ดูเหมือนคุณจะเน้นย้ำถึงความจำเป็นในการเชื่อมโยงตำแหน่งกับข้อมูลของคุณดังนั้นอาร์เรย์ที่เชื่อมโยงจะไม่เหมาะสมกว่านี้หรือ?

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

หากคุณต้องการเริ่มต้นรายการด้วยองค์ประกอบ N ของค่าคงที่:

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

คุณสามารถใช้ Linq เพื่อเริ่มต้นรายการของคุณอย่างชาญฉลาดด้วยค่าเริ่มต้น (คล้ายกับคำตอบของ David B )

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

ไปอีกขั้นหนึ่งและเริ่มต้นแต่ละสตริงด้วยค่าที่แตกต่างกัน "string 1", "string 2", "string 3" ฯลฯ :

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

คำตอบที่ยอมรับ (คำตอบที่มีเครื่องหมายถูกสีเขียว) มีปัญหา

ปัญหา:

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

ฉันขอแนะนำให้เปลี่ยนบรรทัดด้านบนเพื่อทำการคัดลอกวัตถุ มีบทความมากมายเกี่ยวกับเรื่องนี้:

• String.MemberwiseClone () วิธีการที่เรียกว่าผ่านการสะท้อนกลับไม่ทำงานทำไม?
• https://code.msdn.microsoft.com/windowsdesktop/CSDeepCloneObject-8a53311e

หากคุณต้องการเริ่มต้นทุกรายการในรายการของคุณด้วยตัวสร้างเริ่มต้นแทนที่จะเป็น NULL ให้เพิ่มวิธีการต่อไปนี้:

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: MSDN IList หมายเหตุ : "การใช้งาน IList แบ่งออกเป็น 3 ประเภท ได้แก่ อ่านอย่างเดียวขนาดคงที่และขนาดตัวแปร (... ) สำหรับเวอร์ชันทั่วไปของอินเทอร์เฟซนี้โปรดดู System.Collections.Generic.IList<T>"

IList<T>ไม่สืบทอดจากIList(แต่List<T>ใช้ทั้งสองIList<T>และIList) แต่เป็นตัวแปรขนาดเสมอ ตั้งแต่. NET 4.5 เราก็มีIReadOnlyList<T>แต่ AFAIK ไม่มีรายการทั่วไปขนาดคงที่ซึ่งจะเป็นสิ่งที่คุณกำลังมองหา

นี่คือตัวอย่างที่ฉันใช้สำหรับการทดสอบหน่วยของฉัน ฉันสร้างรายการของคลาสออบเจ็กต์ จากนั้นฉันใช้ forloop เพื่อเพิ่มจำนวนวัตถุ 'X' ที่ฉันคาดหวังจากบริการ ด้วยวิธีนี้คุณสามารถเพิ่ม / เริ่มต้นรายการสำหรับขนาดใดก็ได้

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


    }

หวังว่าฉันจะช่วยพวกคุณได้

สายไปหน่อย แต่วิธีแก้ปัญหาแรกที่คุณเสนอดูเหมือนจะสะอาดกว่าสำหรับฉัน: คุณไม่ได้จัดสรรหน่วยความจำสองครั้ง แม้แต่ List constrcutor จำเป็นต้องวนรอบอาร์เรย์เพื่อคัดลอก มันไม่รู้ด้วยซ้ำว่ามีเพียงองค์ประกอบว่างอยู่ข้างใน

1. - จัดสรร N - loop N ต้นทุน: 1 * จัดสรร (N) + N * loop_iteration

2. - จัดสรร N - จัดสรร N + loop () ต้นทุน: 2 * ปันส่วน (N) + N * loop_iteration

อย่างไรก็ตามการจัดสรรการวนซ้ำของ List อาจเร็วกว่าเนื่องจาก List เป็นคลาสในตัว แต่ C # ถูกรวบรวมโดย jit sooo ...