C# 从工厂返回通用接口

Question

我已经实现了一个 Vehicle 服务，负责维修汽车和卡车等车辆：

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
    }
}

我还有一个车辆服务工厂，负责根据传入工厂方法的车辆类型创建车辆服务：

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");
    }

}

我遇到的主要问题是CarService.ServiceVehicle 方法。它接受Vehicle，而理想情况下它应该接受Car，因为它知道它只会为汽车服务。所以我决定更新这个实现以使用泛型：

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 
    }
}

我遇到的问题是如何更新 VehicleServiceFactory 以返回车辆服务的通用版本。我尝试了以下方法，但它导致编译错误，因为它无法将 CarService 转换为通用返回类型 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");
    }

}

任何建议将不胜感激。

Answer 1

只需将服务强制转换为接口：

return new CarService() as IVehicleService<T>;

你知道T是car，但编译器不知道，它不够聪明，无法遵循方法逻辑，也不是它的本意；据编译器所知，T 可以是任何东西，只要它是Vehicle。你需要告诉编译器，“嘿，我知道我在做什么，T 和 Car 实际上是同一个类型。”

Answer 2

这对你有用吗？

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

Answer 3

@InBetween 建议的解决方案是最直接的解决方案。但是，如果继承者的数量超过 2 或 3 个，或者预计会增加，我会主张采用不同的解决方案。

如果我们编写if (vehicle is Car) 和if (vehicle is Truck)，我们可能在代码的多个位置都遵循这种模式。当我们需要引入另一种车辆时会发生什么？我们必须更改代码中检查具体实现的每个地方。这不是 OOP 的使用方式。

设计目标是在引入抽象的新实现时避免对现有代码进行多次更改。

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
        };

}

所以在这里我只是在工厂内部使用 Dictionary，因为我对您系统的其余部分了解不多。一般来说，想想你是如何在其余代码中进行最小更改的情况下引入新类型的车辆的。