ควรใช้ IList เมื่อใดและเมื่อใดควรใช้รายการ

ฉันรู้ว่า IList เป็นอินเทอร์เฟซและรายการเป็นประเภทที่เป็นรูปธรรม แต่ฉันก็ยังไม่รู้ว่าจะใช้เมื่อใด สิ่งที่ฉันทำตอนนี้คือถ้าฉันไม่ต้องการวิธีเรียงลำดับหรือ FindAll ที่ฉันใช้อินเทอร์เฟซ ฉันถูกไหม? มีวิธีที่ดีกว่าในการตัดสินใจว่าจะใช้อินเตอร์เฟสหรือชนิดคอนกรีตเมื่อใด?

มีกฎสองข้อที่ฉันปฏิบัติตาม:

• ยอมรับประเภทพื้นฐานที่สุดที่จะใช้งานได้
• ส่งคืนประเภทที่รวยที่สุดที่ผู้ใช้ของคุณต้องการ

ดังนั้นเมื่อเขียนฟังก์ชั่นหรือวิธีการที่ใช้คอลเลกชันเขียนมันจะไม่ใช้รายการ แต่ IList <T>, ICollection <T> หรือ IEnumerable <T> อินเทอร์เฟซทั่วไปจะยังคงทำงานได้แม้สำหรับรายการที่ต่างกันเนื่องจาก System.Object สามารถเป็น T ได้เช่นกัน การทำเช่นนี้จะช่วยให้คุณปวดหัวถ้าคุณตัดสินใจใช้ Stack หรือโครงสร้างข้อมูลอื่น ๆ หากทุกสิ่งที่คุณต้องทำในฟังก์ชั่นนั้นอยู่ข้างหน้า IEnumerable <T> นั้นเป็นสิ่งที่คุณควรจะถาม

ในทางกลับกันเมื่อส่งคืนวัตถุออกจากฟังก์ชั่นคุณต้องการมอบชุดการทำงานที่สมบูรณ์ที่สุดเท่าที่จะเป็นไปได้ให้แก่ผู้ใช้ ดังนั้นในกรณีนั้นถ้าเป็นรายการ <T> ภายในให้ส่งคืนสำเนาเป็นรายการ <T>

แนวทางของ Microsoft ที่ตรวจสอบโดย FxCop ไม่สนับสนุนการใช้ List <T> ใน API สาธารณะ - ชอบ IList <T>

บังเอิญตอนนี้ฉันเกือบจะประกาศอาร์เรย์หนึ่งมิติเป็น IList <T> ซึ่งหมายความว่าฉันสามารถใช้คุณสมบัติ IList <T> .Count มากกว่า Array.Length ตัวอย่างเช่น:

public interface IMyApi
{
    IList<int> GetReadOnlyValues();
}

public class MyApiImplementation : IMyApi
{
    public IList<int> GetReadOnlyValues()
    {
        List<int> myList = new List<int>();
        ... populate list
        return myList.AsReadOnly();
    }
}
public class MyMockApiImplementationForUnitTests : IMyApi
{
    public IList<int> GetReadOnlyValues()
    {
        IList<int> testValues = new int[] { 1, 2, 3 };
        return testValues;
    }
}

มีสิ่งสำคัญที่ผู้คนมักจะมองข้ามคือ:

คุณสามารถส่งอาเรย์ธรรมดาไปยังสิ่งที่ยอมรับIList<T>พารามิเตอร์จากนั้นคุณสามารถโทรIList.Add()และจะได้รับข้อยกเว้นรันไทม์:

Unhandled Exception: System.NotSupportedException: Collection was of a fixed size.

ตัวอย่างเช่นพิจารณารหัสต่อไปนี้:

private void test(IList<int> list)
{
    list.Add(1);
}

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

int[] array = new int[0];
test(array);

สิ่งนี้เกิดขึ้นเนื่องจากการใช้อาร์เรย์ธรรมดาที่IList<T>ละเมิดหลักการทดแทน Liskov

ด้วยเหตุนี้ถ้าคุณกำลังเรียกIList<T>.Add()คุณอาจต้องการที่จะต้องพิจารณาต้องแทนList<T>IList<T>

ฉันเห็นด้วยกับคำแนะนำของ Lee ในการรับพารามิเตอร์ แต่ไม่กลับมา

หากคุณระบุวิธีการของคุณเพื่อส่งคืนอินเทอร์เฟซซึ่งหมายความว่าคุณมีอิสระที่จะเปลี่ยนการใช้งานที่แน่นอนในภายหลังโดยไม่ต้องใช้วิธีการที่เคยรู้จัก ฉันคิดว่าฉันไม่จำเป็นต้องเปลี่ยนจากรายการ <T> แต่ต้องเปลี่ยนในภายหลังเพื่อใช้ไลบรารีรายการที่กำหนดเองสำหรับฟังก์ชั่นพิเศษที่มีให้ เพราะฉันจะส่ง IList <T> กลับคืนมาเท่านั้นไม่มีใครที่ใช้ห้องสมุดต้องเปลี่ยนรหัส

แน่นอนว่าต้องใช้กับวิธีการที่มองเห็นจากภายนอกเท่านั้น (เช่นวิธีสาธารณะ) ฉันเองใช้อินเทอร์เฟซแม้ในรหัสภายใน แต่เมื่อคุณสามารถเปลี่ยนรหัสทั้งหมดด้วยตัวคุณเองหากคุณทำการเปลี่ยนแปลงที่ไม่จำเป็น

IEnumerable
คุณควรลองใช้ชนิดที่เจาะจงน้อยที่สุดที่เหมาะกับวัตถุประสงค์ของคุณ เป็นเฉพาะน้อยกว่า
IEnumerable คุณใช้เมื่อคุณต้องการวนรอบรายการในคอลเลกชัน IList
IEnumerable

IListการดำเนินการ
IList คุณควรใช้เมื่อคุณต้องการเข้าถึงดัชนีโดยการรวบรวมเพิ่มและลบองค์ประกอบ ฯลฯ ...IEnumerable
IList

รายการการดำเนินการ
ListIList

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

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

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

ฉันไม่คิดว่ามีกฎที่ยากและรวดเร็วสำหรับสิ่งประเภทนี้ แต่ฉันมักจะไปตามแนวทางการใช้วิธีที่เบาที่สุดเท่าที่จะเป็นไปได้จนกว่าจะมีความจำเป็นอย่างยิ่ง

ตัวอย่างเช่นสมมติว่าคุณมีPersonคลาสและGroupคลาส Groupเช่นมีคนจำนวนมากดังนั้นรายการที่นี่จะทำให้ความรู้สึก เมื่อฉันประกาศเป็นวัตถุรายการในGroupผมจะใช้และยกตัวอย่างว่ามันเป็นIList<Person>List

public class Group {
  private IList<Person> people;

  public Group() {
    this.people = new List<Person>();
  }
}

และถ้าคุณไม่ต้องการทุกสิ่งในตัวIListคุณก็สามารถใช้ได้IEnumerableเช่นกัน ด้วยคอมไพเลอร์และโปรเซสเซอร์ที่ทันสมัยฉันไม่คิดว่าจะมีความแตกต่างด้านความเร็วดังนั้นนี่เป็นเรื่องของสไตล์

คุณมักจะใช้ประเภทที่ใช้งานทั่วไปได้ดีที่สุดในกรณีนี้ IList หรืออินเทอร์เฟซ IEnumerable ที่ดีกว่าเพื่อให้คุณสามารถสลับการใช้งานได้อย่างสะดวกในเวลาต่อมา

อย่างไรก็ตามใน NET 2.0 จะมีสิ่งที่น่ารำคาญ - IList ไม่ได้เรียง ()วิธีการ คุณสามารถใช้อะแดปเตอร์ที่ให้มาแทน:

ArrayList.Adapter(list).Sort()

คุณควรใช้อินเทอร์เฟซเฉพาะในกรณีที่คุณต้องการเช่นหากรายการของคุณถูกนำไปใช้ในการใช้งาน IList นอกเหนือจากรายการ สิ่งนี้เป็นจริงเมื่อคุณใช้ NHibernate ซึ่งจะทำให้ IList กลายเป็นวัตถุถุงของ NHibernate เมื่อทำการดึงข้อมูล

หากรายการเป็นการนำไปปฏิบัติเพียงอย่างเดียวที่คุณจะใช้ในการรวบรวมบางรายการโปรดประกาศว่าเป็นการใช้งานรายการที่เป็นรูปธรรม

ในสถานการณ์ที่ฉันมักจะเจอฉันไม่ค่อยได้ใช้ IList โดยตรง

ฉันมักจะใช้มันเป็นอาร์กิวเมนต์ของวิธีการ

void ProcessArrayData(IList almostAnyTypeOfArray)
{
    // Do some stuff with the IList array
}

สิ่งนี้จะอนุญาตให้ฉันทำการประมวลผลทั่วไปบนอาเรย์ใด ๆ ในกรอบงาน. NET ยกเว้นว่าจะใช้ IEnumerable และไม่ใช่ IList ซึ่งบางครั้งก็เกิดขึ้น

มันมาพร้อมกับฟังก์ชั่นที่คุณต้องการ ฉันขอแนะนำให้ใช้คลาส List ในกรณีส่วนใหญ่ IList นั้นดีที่สุดเมื่อคุณต้องการสร้างอาร์เรย์แบบกำหนดเองที่อาจมีกฎเฉพาะเจาะจงที่คุณต้องการแค็ปซูลภายในคอลเล็กชันเพื่อให้คุณไม่ต้องทำซ้ำตัวเอง แต่ยังคงต้องการให้. NET จดจำเป็นรายการ

วัตถุ AList ช่วยให้คุณสร้างรายการเพิ่มสิ่งต่าง ๆ ออกลบอัปเดตสร้างดัชนีและอื่น ๆ รายการจะถูกใช้ทุกครั้งที่คุณต้องการรายการทั่วไปที่คุณระบุประเภทวัตถุในนั้น

ในทางตรงกันข้าม IList เป็นอินเทอร์เฟซ โดยทั่วไปถ้าคุณต้องการสร้างประเภทรายการของคุณเองให้พูดรายการลิสต์ที่ชื่อว่า BookList จากนั้นคุณสามารถใช้อินเทอร์เฟซเพื่อมอบวิธีการและโครงสร้างพื้นฐานให้กับคลาสใหม่ของคุณ IList ใช้สำหรับเมื่อคุณต้องการสร้างคลาสย่อยพิเศษของคุณเองที่ใช้ List

ข้อแตกต่างคือ: IList เป็นส่วนต่อประสานและไม่สามารถสร้างอินสแตนซ์ได้ รายการเป็นคลาสและสามารถสร้างอินสแตนซ์ได้ มันหมายถึง:

IList<string> MyList = new IList<string>();

List<string> MyList = new List<string>