เป็นวิธีปฏิบัติที่ดีในการสร้าง ClassCollection ของคลาสอื่นหรือไม่?

ให้บอกว่าฉันมีCarคลาส:

public class Car
{
    public string Engine { get; set; }
    public string Seat { get; set; }
    public string Tires { get; set; }
}

ให้บอกว่าเรากำลังสร้างระบบเกี่ยวกับที่จอดรถฉันจะใช้Carคลาสจำนวนมากดังนั้นเราจึงสร้างCarCollectionคลาสมันอาจมีวิธีการโฆษณาสองสามอย่างเช่นFindCarByModel:

public class CarCollection
{
    public List<Car> Cars { get; set; }

    public Car FindCarByModel(string model)
    {
        // code here
        return new Car();
    }
}

ถ้าฉันกำลังเรียนParkingLotการฝึกที่ดีที่สุดคืออะไร?

ตัวเลือกที่ 1:

public class ParkingLot
{
    public List<Car> Cars { get; set; }
    //some other properties
}

ตัวเลือก # 2:

public class ParkingLot
{
    public CarCollection Cars { get; set; }
    //some other properties
}

มันเป็นแนวปฏิบัติที่ดีในการสร้างสิ่งClassCollectionอื่นClassหรือไม่?

ก่อนหน้า generics ใน. NET มันเป็นเรื่องธรรมดาที่จะสร้างคอลเลกชัน 'พิมพ์' ดังนั้นคุณจะมีclass CarCollectionฯลฯ สำหรับทุกประเภทที่คุณต้องการจัดกลุ่ม ใน. NET 2.0 ด้วยการแนะนำ Generics คลาสใหม่List<T>ได้รับการแนะนำซึ่งช่วยให้คุณไม่ต้องสร้างCarCollectionฯลฯ ตามที่คุณสามารถสร้างList<Car>ได้

ส่วนใหญ่คุณจะพบว่าList<T>เพียงพอสำหรับวัตถุประสงค์ของคุณอย่างไรก็ตามอาจมีบางครั้งที่คุณต้องการมีพฤติกรรมเฉพาะในคอลเลกชันของคุณหากคุณเชื่อว่าเป็นกรณีนี้คุณมีตัวเลือกสองทาง:

• สร้างชั้นที่ห่อหุ้มList<T>เช่นpublic class CarCollection { private List<Car> cars = new List<Car>(); public void Add(Car car) { this.cars.Add(car); }}
• สร้างคอลเลกชันที่กำหนดเอง public class CarCollection : CollectionBase<Car> {}

หากคุณใช้วิธี encapsulation คุณควรเปิดเผยตัวระบุอย่างน้อยดังนั้นคุณจะประกาศดังต่อไปนี้:

public class CarCollection : IEnumerable<Car>
{
    private List<Car> cars = new List<Car>();

    public IEnumerator<Car> GetEnumerator() { return this.cars.GetEnumerator(); }
}

หากไม่ทำเช่นนั้นคุณจะไม่สามารถทำforeachคอลเล็กชันได้

เหตุผลบางอย่างที่คุณอาจต้องการสร้างคอลเลกชันที่กำหนดเองคือ:

• คุณไม่ต้องการเปิดเผยวิธีการทั้งหมดในIList<T>หรือICollection<T>
• คุณต้องการดำเนินการเพิ่มเติมเมื่อเพิ่มหรือลบรายการออกจากคอลเลกชัน

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

Microsoft ทำค่อนข้างบ่อยนี่เป็นตัวอย่างล่าสุด:

• System.Web.Http.Filters.HttpFilterCollection
• System.Web.Mvc.ModelBinderProviderCollection

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

public static class CarLookupQueries
{
    public static Car FindByLicencePlate(this IEnumerable<Car> source, string licencePlate)
    {
        return source.SingleOrDefault(c => c.LicencePlate == licencePlate);
    }

    ...
}

สิ่งนี้แยกความกังวลของการสอบถามคอลเลกชันจากคลาสที่เก็บรถยนต์

ไม่การสร้างXXXCollectionชั้นเรียนค่อนข้างล้าสมัยไปพร้อมกับการกำเนิดของ generics ใน. NET 2.0 อันที่จริงมีCast<T>()ส่วนขยาย LINQ ที่ดีที่ผู้คนใช้เวลาเหล่านี้เพื่อดึงข้อมูลจากรูปแบบที่กำหนดเองเหล่านั้น

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

public static class CarExtensions
{
    public static IEnumerable<Car> ByModel(this IEnumerable<Car> cars, string model)
    {
        return cars.Where(car => car.Model == model);
    }
}

คุณสามารถเพิ่มเป็นตัวกรองหรือยูทิลิตี้หลายวิธีการที่จะเรียนเท่าที่คุณต้องการและคุณสามารถใช้พวกเขาทุกที่ที่มีIEnumerable<Car>ซึ่งรวมถึงอะไรICollection<Car>อาร์เรย์ของCar, IList<Car>ฯลฯ

เนื่องจากโซลูชันการคงอยู่ของเรามีผู้ให้บริการ LINQ ฉันจึงมักจะสร้างวิธีการตัวกรองที่คล้ายกันซึ่งใช้งานและส่งคืนIQueryable<T>ดังนั้นเราจึงสามารถใช้การดำเนินการเหล่านี้กับที่เก็บได้เช่นกัน

สำนวนของ. NET (ดี C #) มีการเปลี่ยนแปลงมากตั้งแต่ 1.1 การรักษาคลาสคอลเลกชันที่กำหนดเองเป็นสิ่งที่เจ็บปวดและคุณจะได้รับเล็กน้อยจากการสืบทอดจากCollectionBase<T>สิ่งที่คุณไม่ได้รับด้วยวิธีการส่วนขยายหากทั้งหมดที่คุณต้องการคือตัวกรองเฉพาะโดเมนและวิธีการเลือก

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

ตัวอย่างเช่นในกรณีของคุณการเพิ่มฟังก์ชั่นที่จะส่งคืนรายการย่อยของรถยนต์ที่จอดอยู่บนพื้นที่จำนวนมาก / ไม่เท่ากัน ... และแม้กระทั่ง ... อาจจะถ้ามันถูกนำมาใช้บ่อยเพราะถ้าใช้เพียงบรรทัดเดียวด้วย LinQ ฟังก์ชั่นและใช้เพียงครั้งเดียวสิ่งที่เป็นประเด็น? จูบ !

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

ฉันชอบที่จะใช้ตัวเลือกต่อไปนี้เพื่อให้คุณสามารถเพิ่มวิธีการในการรวบรวมและใช้ประโยชน์จากรายการ

public class CarCollection:List<Car>
{
    public Car FindCarByModel(string model)
    {
        // code here
        return new Car();
    }
}

และจากนั้นคุณสามารถใช้มันเช่น C # 7.0

public class ParkingLot
{
    public CarCollection Cars { get; set; }=new CarCollection();
    //some other properties
}

หรือคุณสามารถใช้มันเหมือน

public class ParkingLot
{
   public ParkingLot()
   {
      //initial set
      Cars =new CarCollection();
   }
    public CarCollection Cars { get; set; }
    //some other properties
}

- รุ่นทั่วไปขอบคุณที่แสดงความคิดเห็น @Bryan

   public class MyCollection<T>:List<T> where T:class,new()
    {
        public T FindOrNew(Predicate<T> predicate)
        {
            // code here
            return Find(predicate)?? new T();
        }
       //Other Common methods
     }

และจากนั้นคุณสามารถใช้มัน

public class ParkingLot
{
    public MyCollection<Car> Cars { get; set; }=new MyCollection<Car>();
    public MyCollection<Motor> Motors{ get; set; }=new MyCollection<Motor>();
    public MyCollection<Bike> Bikes{ get; set; }=new MyCollection<Bike>();
    //some other properties
}