C＃从工厂返回通用接口

Question

I've implemented a Vehicle service that is responsible for servicing vehicles such as cars and trucks:

public interface IVehicleService
{
    void ServiceVehicle(Vehicle vehicle);   
}

public class CarService : IVehicleService
{
    void ServiceVehicle(Vehicle vehicle)
    {
        if(!(vehicle is Car))
            throw new Exception("This service only services cars")

       //logic to service the car goes here
    }
}

I also have a vehicle service factory that is responsible for creating a vehicle service according to the type of vehicle passed in to the factory method:

public class VehicleServiceFactory 
{
    public IVehicleService GetVehicleService(Vehicle vehicle)
    {
        if(vehicle is Car)
        {
            return new CarService();
        }

        if(vehicle is Truck)
        {
            return new TruckService();
        }

        throw new NotSupportedException("Vehicle not supported");
    }

}

The main issue I have is specifically with CarService.ServiceVehicle method. It's accepting a Vehicle when ideally it should accept a Car instead, as it knows that it will only service cars. So I decided to update this implementation to use generics instead:

public interface IVehicleService<T> where T : Vehicle
{
    void ServiceVehicle(T vehicle); 
}

public class CarService : IVehicleService<Car>
{
    void ServiceVehicle(Car vehicle)
    {
        //this is better as we no longer need to check if vehicle is a car

        //logic to service the car goes here 
    }
}

The issue I'm having is how to update VehicleServiceFactory to return the generic version of the vehicle service. I've tried the following but it results in a compilation error as it's unable to cast CarService to the generic return type IVehicleService:

public class VehicleServiceFactory 
{
    public IVehicleService<T> GetVehicleService<T>(T vehicle) where T : Vehicle
    {
        if(vehicle is Car)
        {
            return new CarService();
        }

        if(vehicle is Truck)
        {
            return new TruckService();
        }

        throw new NotSupportedException("Vehicle not supported");
    }

}

Any suggestions would be appreciated.

Answer 1

Simply cast the service to the interface:

return new CarService() as IVehicleService<T>;

You know T is car but the compiler doesn't, its not smart enough to follow the method logic nor is it meant to be; as far as the compiler knows, T can be anything as long as its a Vehicle . You need to tell the compiler, "Hey, I know what I'm doing, T and Car are in fact the same type."

Answer 2

Solution that @InBetween suggests is the most straightforward one. Yet, if number of inheritors is more than 2 or 3, or if it's expected to grow, I would advocate for a different solution.

If we write if (vehicle is Car) and if (vehicle is Truck) , we probably follow this pattern in multiple places in the code. What happens when we need to introduce another kind of Vehicle? We'll have to change every place in the code where we check for concrete implementations. This is not how OOP is intended to be used.

The design goal is avoiding multiple changes in existing code when introducing a new implementation of an abstraction .

public class VehicleServiceFactory
{
    // the code of this method doesn't change when new Vehicle type is introduced

    public IVehicleService<T> GetVehicleService<T>(T vehicle) where T : Vehicle
    {
        Func<object> concreteFactory;

        if (_factoryByType.TryGetValue(typeof(T), out concreteFactory))
        {
            var serviceInstance = (IVehicleService<T>)concreteFactory();
            return serviceInstance;
        }

        throw new NotSupportedException("Vehicle not supported");
    }

    // the simplest service locator below is just an example
    // of decoupling clients of an abstraction from its implementations

    // instead of hard-coded initialization, the dictionary can be built 
    // from configuration or a database, for example

    private static readonly Dictionary<Type, Func<object>> _factoryByType = 
        new Dictionary<Type, Func<object>> {
            { typeof(Car),   () => new CarService() },
            { typeof(Truck), () => new TruckService() }
            // .... the rest of Vehicle types
        };

}

So here I just use Dictionary inside the factory, since I don't know much about the rest of your system. In general, think how you introduce new types of Vehicle with minimal changes in the rest of your code.

Answer 3

Does this work for you?

public class VehicleServiceFactory
{
    public S GetVehicleService<T, S>(T vehicle)
        where T : Vehicle
        where S : IVehicleService<T>, new()
    {
        return new S();
    }
}