如何从基类通用地实例化派生类

本文关键字：实例化 派生 基类 | 更新日期: 2023-09-27 18:15:16

我已经扩展了这篇文章中给出的单位转换器类:https://stackoverflow.com/a/7852721/1474894这是我现在的代码:

public abstract class UnitBase<TUnitType, TValueType> where TUnitType : struct, IComparable, IConvertible, IFormattable
{
    protected static TUnitType BaseUnit;
    protected static TValueType BaseValue;
    private static ConcurrentDictionary<TUnitType, Func<TValueType, TValueType>> ConversionsTo = new ConcurrentDictionary<TUnitType, Func<TValueType, TValueType>>();
    private static ConcurrentDictionary<TUnitType, Func<TValueType, TValueType>> ConversionsFrom = new ConcurrentDictionary<TUnitType, Func<TValueType, TValueType>>();
    public static TValueType Convert(TValueType value, TUnitType from, TUnitType to)
    {
        // If both From/To are the same, don't do any work.
        if (from.Equals(to))
            return value;
        // Convert into the base unit, if required.
        var valueInBaseUnit = from.Equals(BaseUnit)
                                ? value
                                : ConversionsFrom[from](value);
        // Convert from the base unit into the requested unit, if required
        var valueInRequiredUnit = to.Equals(BaseUnit)
                                ? valueInBaseUnit
                                : ConversionsTo[to](valueInBaseUnit);
        return valueInRequiredUnit;
    }
    protected static void RegisterConversion(TUnitType convertToUnit, Func<TValueType, TValueType> conversionTo, Func<TValueType, TValueType> conversionFrom)
    {
        if (!ConversionsTo.TryAdd(convertToUnit, conversionTo))
            throw new ArgumentException("Already exists", "convertToUnit");
        if (!ConversionsFrom.TryAdd(convertToUnit, conversionFrom))
            throw new ArgumentException("Already exists", "convertToUnit");
    }
    public static string GetUnit(TUnitType unit)
    {
        var type = typeof(TUnitType);
        if (!type.IsEnum)
        {
            throw new ArgumentException();
        }
        return Enums.GetEnumDescription(unit as Enum);
    }
    public TValueType InUnit(TUnitType unit)
    {
        return Convert(BaseValue, BaseUnit, unit);
    }
}

我有这样的具体实现:

public enum TemperatureUnit
{
    [System.ComponentModel.Description("°C")]
    Celcius,
    [System.ComponentModel.Description("°F")]
    Fahrenheit
}
public class Temperature : UnitBase<TemperatureUnit, double>
{
    static Temperature()
    {
        BaseUnit = TemperatureUnit.Celcius;
        RegisterConversion(TemperatureUnit.Fahrenheit, x => x * 1.8d + 32d, x => (x - 32d) / 1.8d);
    }
    private Temperature(double value)
    {
        BaseValue = value;
    }
    public static Temperature FromUnit(double value, TemperatureUnit unit)
    {
        return new Temperature(Convert(value, unit, BaseUnit));
    }
}

我设法使ToUnit方法作为基类的一部分泛型，但是使用FromUnit方法，我现在每个具体类都有一个(它们看起来都非常相似)。我希望能够这样做:

Temperature temperature = Temperature.FromUnit(10, TemperatureUnit.Celcius);
Pressure pressure = Pressure.FromUnit(50, PressureUnit.Bar);

…而不必在每个具体类中实现FromUnit。因为它是一个静态方法，所以我不能通过使用接口强制实现。我可以在具体类中有一个公共构造函数，像这样:

public static T FromUnit<T>(TValueType value, TUnitType unit) where T : new()
{
    BaseValue = Convert(value, unit, BaseUnit);
    return new T();
}

但我猜它不是那么好，我将不得不去:

Temperature temperature = Temperature.FromUnit<Temperature>(10, TemperatureUnit.Celcius);

我认为<Temperature>有点多余。

是否有可能以更好的方式实现通用FromUnit ?

编辑:

基本上，我想，而不是在每个子类中实现FromUnit:

public static Temperature FromUnit(double value, TemperatureUnit unit)
{
    return new Temperature(Convert(value, unit, BaseUnit));
}
public static Pressure FromUnit(double value, PressureUnit unit)
{
    return new Pressure(Convert(value, unit, BaseUnit));
}
public static Speed FromUnit(double value, SpeedUnit unit)
{
    return new Speed(Convert(value, unit, BaseUnit));
}
...

…将泛型FromUnit放在基类中

如何从基类通用地实例化派生类

您的"不太好的"解决方案中的<Temperature>类型参数似乎是多余的，但实际上并非如此。当你写

Temperature temperature = Temperature.FromUnit<Temperature>(10, TemperatureUnit.Celcius);

代码实际上被翻译成

Temperature temperature = UnitBase<TemperatureUnit, double>.FromUnit<Temperature>(10, TemperatureUnit.Celcius);

编译器很简单，允许您使用Temperature来访问该方法。因为它实际上调用UnitBase.FromUnit()，它不知道您实际上想使用Temperature，这就是为什么您必须将其作为附加类型参数提供的原因。

为什么不把FromUnit的实现推到UnitBase本身呢? 

    public static TValueType FromUnit(TValueType value, TUnitType unit)
    {
        return Convert(value, BaseUnit, unit);
    }
相关文章：