實施通用工廠方法

Question

我已經實施了車輛服務，負責維修汽車和卡車等車輛：

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<Car>轉換為有效的返回類型，將是IVehicleService<Vehicle> （如果我輸入錯誤，請更正我）。

希望對如何解決此問題提供一些指導。

Answer 1

您正在要求編譯時類型安全。 但是，您正在使用在編譯時未知類型的代碼。 在這個例子中...

var factory = new VehicleServiceFactory();
Vehicle vehicle = GetVehicle();  //Could return any kind of vehicle
var vehicleService = factory.GetVehicleService(vehicle);  
vehicleService.ServiceVehicle(vehicle);

...編譯代碼時根本不知道vehicle的類型。

即使可以將其刪除，也不能對返回的類做任何事情，因為同樣，您在編譯時也不知道類型：

CarService s = new CarSevice();
Vehicle v = new Car();
s.ServiceVehicle(v); //Compilation error

如果要進行編譯時檢查，則需要在編譯時聲明類型。 因此，只需將其更改為：

var factory = new VehicleServiceFactory();
Car vehicle = GetCar();  //<-- specific type
var vehicleService = factory.GetVehicleService(vehicle);  
vehicleService.ServiceVehicle(vehicle);

或者，如果您堅持使用類型為Vehicle的變量持有Vehicle ，則可以使用

var factory = new VehicleServiceFactory();
Vehicle vehicle = GetCar();  
var vehicleService = factory.GetVehicleService<Car>(vehicle);   //Explicit type
vehicleService.ServiceVehicle(vehicle);

工廠將返回相應的服務等級。

要么，要么堅持運行時檢查，這在您的第一個示例中已實現。

Answer 2

問題

您面臨的問題與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未實現的IVehicleService<Vehicle> 。

如果您完全刪除演員表，

return new CarService();

您甚至會在編譯時出錯，告訴您這些類型不能相互轉換。

一個辦法

不幸的是，我不知道C＃可以處理的整潔解決方案。 但是，您可以為服務創建一個抽象基類，實現一個非通用接口：

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

如您所見，工廠和接口現在都是非通用的（就像您以前使用過的一樣）。 但是，服務的絕對基類現在可以處理類型並在類型不匹配時拋出異常（不幸的是僅在運行時）。

一個（也許）有用的補充

如果您的工廠有很多不同的類型，並且您想保存數十條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語句相比不應該那么慢。

Answer 3

我將在Factory類中使用類似以下的內容：

public T GetVehicle<T>(T it) {
    try {
        Type type = it.GetType();                                   // read  incoming Vehicle type
        ConstructorInfo ctor = type.GetConstructor(new[] { type }); // get its constructor
        object instance = ctor.Invoke(new object[] { it });         // invoke its constructor
        return (T)instance;                                         // return proper vehicle type
    } catch { return default(T); }
}

Answer 4

有一種方法可以避免在IVehicleService上使用泛型，並避免將Truck傳遞到CarService的問題，反之亦然。 您可以先將IVehicleService更改IVehicleService通用，或在以下位置傳遞IVehicleService ：

public interface IVehicleService
{
    void ServiceVehicle();
}

相反，我們將車輛傳遞到CarService / TruckService的構造函數中：

    public class CarService : IVehicleService
    {
        private readonly Car _car;

        public CarService(Car car)
        {
            _car = car;
        }

        public void ServiceVehicle()
        {
            Console.WriteLine($"Service Car {_car.Id}");
        }
    }

並讓工廠通過車輛：

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

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

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

這就是我要實現的方式

    public static void Main(string[] args)
    {
        var factory = new VehicleServiceFactory();
        Vehicle vehicle = GetVehicle();
        var vehicleService = factory.GetVehicleService(vehicle);
        vehicleService.ServiceVehicle();

        Console.ReadLine();

    }

    public static Vehicle GetVehicle()
    {
        return new Truck() {Id=1};

        //return new Car() { Id = 2 }; ;
    }


    public interface IVehicleService
    {
        void ServiceVehicle();
    }

    public class CarService : IVehicleService
    {
        private readonly Car _car;

        public CarService(Car car)
        {
            _car = car;
        }

        public void ServiceVehicle()
        {
            Console.WriteLine($"Service Car {_car.Id}");
        }
    }

    public class TruckService : IVehicleService
    {
        private readonly Truck _truck;

        public TruckService(Truck truck)
        {
            _truck = truck;
        }

        public void ServiceVehicle()
        {
            Console.WriteLine($"Service Truck {_truck.Id}");
        }
    }

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

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

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


    public abstract class Vehicle
    {
        public int Id;

    }

    public class Car : Vehicle
    {

    }

    public class Truck : Vehicle
    {

    }

Answer 5

對於工廠實施，您可以使用MEF

這將使您可以使用具有唯一名稱的Export和Import屬性來實現，並且不需要if if / witch語句來創建工廠。

class Program
{
    private static CompositionContainer _container;

    public Program()
    {

        var aggList = AppDomain.CurrentDomain
                               .GetAssemblies()
                               .Select(asm => new AssemblyCatalog(asm))
                               .Cast<ComposablePartCatalog>()
                               .ToArray();

        var catalog = new AggregateCatalog(aggList);

        _container = new CompositionContainer(catalog);
        _container.ComposeParts(this);
    }

    static void Main(string[] args)
    {
        var prg = new Program();

        var car = _container.GetExportedValue<IVehicle>("CAR") as Car; 
        var carService = _container.GetExportedValue<IVehicleService<Car>>("CARSERVICE") as CarService;
        carService.ServiceVehicle(car);

        var truck = _container.GetExportedValue<IVehicle>("TRUCK") as Truck;
        var truckService = _container.GetExportedValue<IVehicleService<Truck>>("TRUCKSERVICE") as TruckService;
        truckService.ServiceVehicle(truck);

        Console.ReadLine();
    }
}

public interface IVehicleService<in T> 
{
    void ServiceVehicle(T vehicle);
}

public interface IVehicle
{
}

[Export("CARSERVICE", typeof(IVehicleService<Car>)), PartCreationPolicy(System.ComponentModel.Composition.CreationPolicy.NonShared)]
public class CarService : IVehicleService<Car>
{
    public void ServiceVehicle(Car vehicle)
    {
    }
}

[Export("TRUCKSERVICE", typeof(IVehicleService<Truck>)), PartCreationPolicy(System.ComponentModel.Composition.CreationPolicy.NonShared)]
public class TruckService : IVehicleService<Truck>
{
    public void ServiceVehicle(Truck vehicle)
    {

    }
}

public abstract class Vehicle : IVehicle
{

}

[Export("CAR", typeof(IVehicle)), PartCreationPolicy(System.ComponentModel.Composition.CreationPolicy.NonShared)]
public class Car : Vehicle
{

}

[Export("TRUCK", typeof(IVehicle)), PartCreationPolicy(System.ComponentModel.Composition.CreationPolicy.NonShared)]
public class Truck : Vehicle
{

}