我实现了一个车辆服务，负责为汽车和卡车等车辆提供服务:

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

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

        if (vehicle is Truck)
        {
            return new TruckService() as IVehicleService<T>;
        }

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

我目前遇到的问题是按如下方式调用该工厂时:

var factory = new VehicleServiceFactory();
Vehicle vehicle = GetVehicle();
var vehicleService = factory.GetVehicleService(vehicle);  // this returns null!
vehicleService.ServiceVehicle(vehicle);

GetVehicleService返回 null ，我猜是因为我传递了基本类型 Vehicle进入这个方法，所以T将评估为 Vehicle并且无法从 CarService 转换(实现 IVehicleService<Car> )到有效返回类型，即 IVehicleService<Vehicle> (如果我错了，请纠正我)。

希望获得有关如何解决此问题的指导。

最佳答案

问题

您面临的问题与 C# 推导的泛型类型有关。

Vehicle vehicle = GetVehicle();

这一行会给你带来麻烦，因为 vehicle你传入的变量类型

var vehicleService = factory.GetVehicleService(vehicle);  // this returns null!

属于 Vehicle 类型并且不是类型Car (或 Truck )。因此，您的工厂方法 GetVehicleService<T> 的类型推导 (T)，是 Vehicle .但是，在您的 GetVehicleService 方法中，您执行安全转换 ( as )，它返回 null ，如果给定的类型不能按您的意愿进行转换。 如果改成直接投

return (IVehicleService<T>) new CarService();

您会看到，调试器会在这一行捕获 InvalidCastException。这是因为你的 CarService工具 IVehicleService<Car>但程序实际上试图将其转换为 IVehicleService<Vehicle>这不是由你的 CarService 实现的因此抛出异常。

如果你完全删除类型转换

return new CarService();

你甚至会在编译时得到一个错误，告诉你这些类型不能相互转换。

解决方案

不幸的是，我不知道可以由 C# 处理的简洁解决方案。但是，您可以为您的服务创建一个抽象基类，实现一个非通用接口(interface):

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

public abstract class VehicleService<T> : IVehicleService where T : Vehicle
{
    public void ServiceVehicle(Vehicle vehicle)
    {
        if (vehicle is T actual)
            ServiceVehicle(actual);
        else
            throw new InvalidEnumArgumentException("Wrong type");
    }

    public abstract void ServiceVehicle(T vehicle);
}

public class CarService : VehicleService<Car>
{
    public override void ServiceVehicle(Car vehicle)
    {
        Console.WriteLine("Service Car");
    }
}

public class TruckService : VehicleService<Truck>
{
    public override void ServiceVehicle(Truck vehicle)
    {
        Console.WriteLine("Service Truck");
    }
}

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

如您所见，工厂现在是非通用的，接口(interface)也是如此(就像您之前拥有的那样)。但是，服务的抽象基类现在可以处理类型并在类型不匹配时抛出异常(遗憾的是仅在运行时)。

一个(可能)有用的补充

如果你的工厂有很多不同的类型，你想节省几十个if语句，您可以使用属性做一些变通方法。

首先，创建一个ServiceAttribute类:

[AttributeUsage(AttributeTargets.Class)]
public class ServiceAttribute : Attribute
{
    public Type Service { get; }

    public ServiceAttribute(Type service)
    {
        Service = service;
    }
}

然后将此属性附加到您的车辆类别:

[Service(typeof(TruckService))]
public class Truck : Vehicle
// ...

然后像这样改变你的工厂:

public class VehicleServiceFactory
{
    public IVehicleService GetVehicleService(Vehicle vehicle)
    {
        var attributes = vehicle.GetType().GetCustomAttributes(typeof(ServiceAttribute), false);

        if (attributes.Length == 0)
            throw new NotSupportedException("Vehicle not supported");

        return (IVehicleService) Activator.CreateInstance(((ServiceAttribute)attributes[0]).Service);
    }
}

这种方法不使用反射，因此与 if 语句相比应该不会那么慢。

关于c# - 实现通用工厂方法，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/47020773/