c# - 给定类型T，解析并使用通用类型Calc <T>的其他对象处理T

抱歉，标题不能很好地解释问题，但是我想不出更好的名字了。这最终可能会是一个很长的问题，但请忍受。

假设我有两种类型的车辆Car和Yacht扩展了称为IVehicle的接口。

接口本身对这个问题并不重要，但是类包含描述它们的属性。

然后，我有一个包含方法ITaxCalculator<T> where T : IVehicle的double Calculate(T vehicle);。

然后，有几个类实现不同版本的ITaxCalculator<T>（并采用不同的构造函数参数），例如：


LegitYachtTaxCalculator : ITaxCalculator<Yacht>
TaxHavenYachtTaxCalculator : ITaxCalculator<Yacht>
CarTaxCalculator : ITaxCalculator<Car>


然后，我有一个List<IVehicle>，其中包含我的多辆汽车和游艇，我想计算出我将要为它们支付的税款总额，同时能够切换出用于计算每种税项的方法类型的税金。



这是一些代码：

接口：

ITaxCalculator<T>

public interface ITaxCalculator<T> where T : IVehicle
{
    double Calculate(T vehicle);
}

IVehicle

public interface IVehicle
{
    string RegistrationPlate { get; }
}

实作

Car

public class Car : IVehicle
{
    public Car(string registrationPlate)
    {
        RegistrationPlate = registrationPlate;
    }
    public string RegistrationPlate { get; }
}

Yacht

public class Yacht : IVehicle
{
    public int WeightInTons { get; }
    public Yacht(string registrationPlate, int weightInTons)
    {
        RegistrationPlate = registrationPlate;
        WeightInTons = weightInTons;
    }
    public string RegistrationPlate { get; }
}

CarTaxCalculator : ITaxCalculator<Car>

public class CarTaxCalculator : ITaxCalculator<Car>
{
    public double Calculate(Car vehicle)
    {
        Console.WriteLine($"Calculating tax for {vehicle.GetType().FullName} with plate {vehicle.RegistrationPlate} using {this.GetType().FullName}");

        return 4999.95;
    }
}

LegitYachtTaxCalculator : ITaxCalculator<Yacht>

public class LegitYachtTaxCalculator : ITaxCalculator<Yacht>
{
    public double WeightMultiplier { get; }
    public LegitYachtTaxCalculator(double weightMultiplier)
    {
        WeightMultiplier = weightMultiplier;
    }
    public double Calculate(Yacht vehicle)
    {
        Console.WriteLine($"Calculating tax for {vehicle.GetType().FullName} with plate {vehicle.RegistrationPlate} using {this.GetType().FullName}");

        return vehicle.WeightInTons * WeightMultiplier;
    }
}

TaxHavenYachtTaxCalculator : ITaxCalculator<Yacht>

public class TaxHavenYachtTaxCalculator : ITaxCalculator<Yacht>
{
    public double Calculate(Yacht vehicle)
    {
        Console.WriteLine($"Calculating tax for {vehicle.GetType().FullName} with plate {vehicle.RegistrationPlate} using {this.GetType().FullName}");

        return 0.0; // No taxes, woho!
    }
}

主要

static void Main(string[] args)
{
    List<IVehicle> vehicles = new List<IVehicle>
    {
        new Car("PLT111"),
        new Yacht("PLT333", 2500)
    };

    double totalTaxes = 0;

    foreach (var vehicle in vehicles)
    {
        //Here I want to use engines which are configurable earlier to calculate the taxes for the vehicles
    }
}

我已经尝试了多种解决方法，例如


IoC容器
“ Resolver”变体要轻得多，您可以在包含Dictionary<Type, object>的类中注册引擎，其中object是通过以下方法注册和解析的ITaxCalculators


public ITaxCalculator<T> GetTaxCalculator<T>() where T : IVehicle
public void RegisterTaxCalculator<T>(ITaxCalculator<T> calculator) where T : IPosition

在创建过程中将ITaxCalculator传递给T的每个实例，然后让T使用它来计算自己的税额。


他们最终都会觉得自己过于复杂，使用不良做法或需要太多样板。所以我想知道最好的方法是构造它吗？我是从一开始就走错了路，还是我还没有想到过任何模式？

谢谢！

最佳答案

基本上，您需要一种方法来定义税收计算器和车辆之间的映射。

首先，使税收计算器非通用：

public interface ITaxCalculator
{
    double Calculate(IVehicle vehicle);
}

发现所有非通用实现，将它们加载到集合中，然后调用Calculate，要容易得多。

要处理特定的IVehicle实现细节，请声明税费计算器的基类，并使其通用：

public abstract class TaxCalculator<T> : ITaxCalculator
    where T : IVehicle
{
    public double Calculate(IVehicle vehicle)
    {
        // this is a single place, where cast is required
        return Calculate((T)vehicle);
    }

    protected abstract double Calculate(T vehicle);
}

映射任务将我们引向元数据。
大多数DI容器都具有此功能。例如，这是Autofac文档。

定义元数据类：

// This is metadata class;
// It defines vehicle type to calculate the tax value
public class TaxCalculatorMetadata
{
    public Type VehicleType { get; set; }
}

注册ITaxCalculator实现：

// Every implementation of ITaxCalculator must be registered like this
builder.RegisterType<CarTaxCalculator>()
    .As<ITaxCalculator>()
    .WithMetadata<TaxCalculatorMetadata>(m => m.For(_ => _.VehicleType, typeof(Car)));

现在，您可以加载所有ITaxCalculator实现，以某种方式对其进行过滤（“将其插入”插槽”），并使用“插槽”中的车辆类型获得特定的计算器：

var vehicles = new List<Vehicle>
{
    // ...
};

// assuming, that tax calculators were imported
// using IEnumerable<Lazy<ITaxCalculator, TaxCalculatorMetadata>>
foreach (var vehicle in vehicles)
{
    var taxCalculator = taxCalculators
        .First(_ => _.Metadata.VehicleType == vehicle.GetType());

    Console.WriteLine(taxCalculator.Value.Calculate(vehicle));
}

关于c# - 给定类型T，解析并使用通用类型Calc <T>的其他对象处理T，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/50253062/