Lets says I have a Carclass: public class Car { public string Engine { get; set;

Question

Lets says I have a Carclass:

public class Car
{
    public string Engine { get; set; }
    public string Seat { get; set; }
    public string Tires { get; set; }
}
Lets say we're making a system about a parking lot, I'm going to use a lot of the Car class, so we make a CarCollection class, it may has a few aditionals methods like FindCarByModel:

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

    public Car FindCarByModel(string model)
    {
        // code here
        return new Car();
    }
}
If I'm making a class ParkingLot, what's the best practice?

Option #1:

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

public class ParkingLot
{
    public CarCollection Cars { get; set; }
    //some other properties
}
Is it even a good practice to create a ClassCollection of another Class?

Explanation / Answer

Prior to generics in .NET, it was common practice to create 'typed' collections so you would have class CarCollection etc for every type you needed to group. In .NET 2.0 with the introduction of Generics, a new class List<T> was introduced which saves you having to create CarCollection etc as you can create List<Car>.

Most of the time, you will find that List<T> is sufficient for your purposes, however there may be times that you want to have specific behaviour in your collection, if you believe this to be the case, you have a couple of options:

Create a class which encapsulates List<T> for example public class CarCollection { private List<Car> cars = new List<Car>(); public void Add(Car car) { this.cars.Add(car); }}
Create a custom collection public class CarCollection : CollectionBase<Car> {}
If you go for the encapsulation approach, you should at minimum expose the enumerator so you would declare it as follows:

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

public IEnumerator<Car> GetEnumerator() { return this.cars.GetEnumerator(); }
}
Without doing that, you can't do a foreach over the collection.

Some reasons you might want to create a custom collection are:

You don't want to fully expose all the methods in IList<T> or ICollection<T>
You want to perform additional actions upon adding or removing an item from the collection
Is it good practice? well that depends on why you are doing it, if it is for example one of the reasons I have listed above then yes.

Microsoft do it quite regularly, here are some fairly recent examples:

System.Web.Http.Filters.HttpFilterCollection
System.Web.Mvc.ModelBinderProviderCollection
As for your FindBy methods, I would be tempted to put them in extension methods so that they can be used against any collection containing cars:

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

...
}
This separates the concern of querying the collection from the class which stores the cars.

Related Questions

Navigate

• Browse (All)
• Browse L
• Subjects

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.