Abstract classes and Polymorphism - how are additional methods and properties usually handled?

Question

Imagine a rental company that has cars for the company to use internally and trucks to rent. The cars use gas and the trucks use diesel. The trucks have additional things that they do that cars do not - they are rented. So I have the following code:

abstract class Vehicle
{
    public abstract FuelType Fuel();
}

class Car : Vehicle
{
    public override FuelType Fuel()
    {
        return FuelType.Gas;
    }
}

class Truck : Vehicle
{
    public override FuelType Fuel()
    {
        return FuelType.Diesel;
    }

    //Not in base class or Car class
    public List<Rental> Rentals()
    {
        return new List<Rental>();
    }
}


class Rental
{
      //...some stuff here
}


enum FuelType
{
    Gas,
    Diesel
}

What is normally done when the child classes have additional methods and properties? Example:

        List<Vehicle> vehicles = new List<Vehicle>() { };

        vehicles.Add(new Car());
        vehicles.Add(new Truck());

        foreach (var vehicle in vehicles)
        {
            Console.WriteLine(vehicle.Fuel().ToString());

            //Pseudocode here:
            if(vehicle.GetType() is Truck)
            {
                //Provide rental information
                Truck truck = (Truck)vehicle;
                truck.ProvideSomeInfo();
            }
        }

I get how polymorphism works when you have classes that have all the same methods, properties, fields, etc. What is normally done when you need to work with the base class AND you need to work with additional methods, fields, properties that all the children do not share?

All the abstract tutorials that I have found just show the simpler case when all the children have the same sets of methods, properties, fields.

Answer 1

The good practice is to use interfaces.

class Truck : IVehicle, IRentable, ITrackable    //you can also inherit from abstract VehicleBase class

Then:

foreach (var vehicle in vehicles)
    {
        Console.WriteLine(vehicle.Fuel().ToString());

        if(vehicle.GetType() is IRentable)
        {
            //Provide renting status
            Console.WriteLine((vehicle as IRentable)?.IsRented); //note I didn't cast for Truck directly
        }

        if(vehicle.GetType() is ITrackable)
        {
            //Provide position
            Console.WriteLine((vehicle as ITrackable)?.Position);
        }
    }

Edit:

Another good practice if you create one big vehicle class with a lot of functionality:

• Size
• MainType with an enum { Truck, PassengerCar }
• WheelBase (8, 4, etc)
• CanHaveMoreThan1Engine
• FuelType with an enum { Electric, Kerosene }
• List<KeyValuePair<string, string> Engines (e.g. <"CommonRail4", "Diesel">)
• CanProvideTrackingInfo
• GetTrackingInfo()

Answer 2

in your case, using interface would be more appropriate.

you can define your contract in your interfaces, and also you can inherit multiple interfaces on each class.

The interface would implement the methods, properties in the class, and then, you can customize their logic as needed. When you initialize the object with this interface, you'll be able to use the exposed properties or methods.

example :

public enum VehicleMake
{
    Acura,
    Audi,
    BMW,
    Chevrolet,
    Dodge,
    Fait,
    Ford,
    Hyundai,
    Honda,
    Nissan,
    Toyota
}

public enum FuelType
{
    Gas,
    Diesel
}

public interface IVehicle
{
    FuelType Fuel { get; }

    VehicleMake Make { get; set; }

    string Model { get; set; }

    int MakeYear { get; set; }

    IRental Rental { get; set; }
}

public interface IRental
{
    bool IsRented { get; set; }
}

public class Rental : IRental
{
    public bool IsRented { get; set; }
}

public class Car : IVehicle
{
    public FuelType Fuel => FuelType.Gas;

    public VehicleMake Make { get; set; }

    public string Model { get; set; }

    public int MakeYear { get; set; }

    public IRental Rental { get; set; }

}

public class Truck : IVehicle
{
    public FuelType Fuel => FuelType.Diesel;

    public VehicleMake Make { get; set; }

    public string Model { get; set; }

    public int MakeYear { get; set; }

    public IRental Rental { get; set; }

}

This would give us this :

var vehicles = new List<IVehicle>
{
    new Car
    {
        Make = VehicleMake.BMW,
        MakeYear = 2020,
        Rental = new Rental { IsRented = true }
    },
    new Car
    {
        Make = VehicleMake.Toyota,
        MakeYear = 2000,
        Rental = new Rental { IsRented = false }
    },
    new Truck
    {
        Make = VehicleMake.Nissan,
        MakeYear = 2015,
        Rental = new Rental { IsRented = false }
    }
};


foreach (var vehicle in vehicles)
{
    Console.Write($"{vehicle.GetType().Name}\t");
    Console.Write($"{vehicle.Make.ToString()}\t");
    Console.Write($"{vehicle.MakeYear.ToString()}\t");
    Console.Write($"{vehicle.Fuel.ToString()}\t");    

    if (vehicle.Rental?.IsRented == true)
    {
        Console.Write("rented");
    }
    else
    {
        Console.Write("not rented");
    }

    Console.WriteLine();
}

So, any new vehicle type (such as Car, Truck, ..etc) it should implement IVehicle. The IRental interface I have put only one property as I don't know what you want to implement inside the actual class, likewise the other classes. but since you'll implement the concrete class, you should be able to determine the main properties and method that should be in the interface.