nuget - Units.NET 添加单位而不重新编译

Question

我们需要在运行中的测量单位之间进行转换，Units.NET 似乎是理想的解决方案，但是，它缺少我们需要的一些单位(每分钟加仑)。我知道添加到规范文件并重新创建类是微不足道的，但最好能够简单地使用 nuget 包。有谁知道无需重新编译 Units.NET 解决方案即可将单位添加到 Units.NET 的方法吗？

应该注意的是，我们并没有与 Units.NET 结合，我们只需要能够在任意流量和长度单位之间进行转换。

谢谢!

Answer 1

在 Units.NET 的 github issues page 上提问，您可能会得到更好的回应.有一个wiki page关于在主库之外添加自定义单元，但我承认这部分不是很完善，需要改进。

从维基复制:

如果您希望向 UnitsNet nuget 添加新的数量或单位，请参阅 https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit .

Units.NET结构

Units.NET 大致由以下部分组成:

• 长度和力等量
• 单位枚举值，如 LengthUnit.Meter 和 ForceUnit.Newton
• UnitAbbreviationsCache、UnitParser、QuantityParser 和 UnitConverter，用于解析和转换数量和单位
• 用于定义单位、转换函数和缩写的 JSON 文件
• CodeGen.exe 根据JSON文件生成C#代码

示例:自定义数量 HowMuch 和单位 HowMuchUnit

将单位枚举值映射到单位缩写

UnitAbbreviationsCache.Default.MapUnitToDefaultAbbreviation(HowMuchUnit.Some, "sm");
UnitAbbreviationsCache.Default.MapUnitToDefaultAbbreviation(HowMuchUnit.Lots, "lts");
UnitAbbreviationsCache.Default.MapUnitToDefaultAbbreviation(HowMuchUnit.Tons, "tns");

从枚举值中查找单位缩写

Console.WriteLine("GetDefaultAbbreviation(): " + string.Join(", ", 
    UnitAbbreviationsCache.Default.GetDefaultAbbreviation(HowMuchUnit.Some), // "sm"
    UnitAbbreviationsCache.Default.GetDefaultAbbreviation(HowMuchUnit.Lots), // "lts"
    UnitAbbreviationsCache.Default.GetDefaultAbbreviation(HowMuchUnit.Tons)  // "tns"
));

将单位缩写解析回枚举值

Console.WriteLine("Parse<HowMuchUnit>(): " + string.Join(", ",
    UnitParser.Default.Parse<HowMuchUnit>("sm"),  // Some
    UnitParser.Default.Parse<HowMuchUnit>("lts"), // Lots
    UnitParser.Default.Parse<HowMuchUnit>("tns")  // Tons
));

自定义数量单位之间的转换

var unitConverter = UnitConverter.Default;
unitConverter.SetConversionFunction<HowMuch>(HowMuchUnit.Lots, HowMuchUnit.Some, x => new HowMuch(x.Value * 2, HowMuchUnit.Some));
unitConverter.SetConversionFunction<HowMuch>(HowMuchUnit.Tons, HowMuchUnit.Lots, x => new HowMuch(x.Value * 10, HowMuchUnit.Lots));
unitConverter.SetConversionFunction<HowMuch>(HowMuchUnit.Tons, HowMuchUnit.Some, x => new HowMuch(x.Value * 20, HowMuchUnit.Some));

var from = new HowMuch(10, HowMuchUnit.Tons);
IQuantity Convert(HowMuchUnit toUnit) => unitConverter.GetConversionFunction<HowMuch>(from.Unit, toUnit)(from);

Console.WriteLine($"Convert 10 tons to:");
Console.WriteLine(Convert(HowMuchUnit.Some)); // 200 sm
Console.WriteLine(Convert(HowMuchUnit.Lots)); // 100 lts
Console.WriteLine(Convert(HowMuchUnit.Tons)); // 10 tns

sample 数量

public enum HowMuchUnit
{
    Some,
    Lots,
    Tons
}

public struct HowMuch : IQuantity
{
    public HowMuch(double value, HowMuchUnit unit)
    {
        Unit = unit;
        Value = value;
    }

    Enum IQuantity.Unit => Unit;
    public HowMuchUnit Unit { get; }

    public double Value { get; }

    #region IQuantity

    private static readonly HowMuch Zero = new HowMuch(0, HowMuchUnit.Some);

    public QuantityType Type => QuantityType.Undefined;
    public BaseDimensions Dimensions => BaseDimensions.Dimensionless;

    public QuantityInfo QuantityInfo => new QuantityInfo(Type,
        new UnitInfo[]
        {
                new UnitInfo<HowMuchUnit>(HowMuchUnit.Some, BaseUnits.Undefined),
                new UnitInfo<HowMuchUnit>(HowMuchUnit.Lots, BaseUnits.Undefined),
                new UnitInfo<HowMuchUnit>(HowMuchUnit.Tons, BaseUnits.Undefined),
        },
        HowMuchUnit.Some,
        Zero,
        BaseDimensions.Dimensionless);

    public double As(Enum unit) => Convert.ToDouble(unit);

    public double As(UnitSystem unitSystem) => throw new NotImplementedException();

    public IQuantity ToUnit(Enum unit)
    {
        if (unit is HowMuchUnit howMuchUnit) return new HowMuch(As(unit), howMuchUnit);
        throw new ArgumentException("Must be of type HowMuchUnit.", nameof(unit));
    }

    public IQuantity ToUnit(UnitSystem unitSystem) => throw new NotImplementedException();

    public override string ToString() => $"{Value} {UnitAbbreviationsCache.Default.GetDefaultAbbreviation(Unit)}";
    public string ToString(string format, IFormatProvider formatProvider) => $"HowMuch ({format}, {formatProvider})";
    public string ToString(IFormatProvider provider) => $"HowMuch ({provider})";
    public string ToString(IFormatProvider provider, int significantDigitsAfterRadix) => $"HowMuch ({provider}, {significantDigitsAfterRadix})";
    public string ToString(IFormatProvider provider, string format, params object[] args) => $"HowMuch ({provider}, {string.Join(", ", args)})";

    #endregion
}