Nuget Units.NET添加单元而不重新编译

我们需要在测量单位之间进行动态转换，units.NET似乎是理想的解决方案，但是，它缺少一些我们需要的单位（加仑/分钟）。我知道添加到规范文件并重新创建类很简单，但最好能够简单地使用nuget包。有人知道在不重新编译units.NET解决方案的情况下将units添加到units.NET的方法吗

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

---

谢谢

在Units.NET的github上询问这个问题，您可能会得到更好的回答。在主库之外添加自定义单元是有困难的，但我承认这部分不是很完善，需要改进

从wiki复制： 如果您希望向UnitsNet nuget添加新数量或单位，请参阅

NET结构 Units.NET大致由以下部分组成：

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

示例：自定义数量多少，单位为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
));

将单元缩写解析回枚举值

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

Console.WriteLine（“Parse（）：”+string.Join（“，”，
UnitParser.Default.Parse（“sm”），//一些
UnitParser.Default.Parse（“lts”），//Lots
UnitParser.Default.Parse（“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

var unitConverter=unitConverter.Default；
unitConverter.SetConversionFunction（HowMuchUnit.Lots，HowMuchUnit.Some，x=>new howmous（x.Value*2，HowMuchUnit.Some））；
unitConverter.SetConversionFunction（HowMuchUnit.Tons，HowMuchUnit.Lots，x=>new howmous（x.Value*10，HowMuchUnit.Lots））；
unitConverter.SetConversionFunction（HowMuchUnit.Tons，HowMuchUnit.Some，x=>new howmount（x.Value*20，HowMuchUnit.Some））；
var from=新的多少（10，多少吨）；
IQuantity转换（HowMuchUnit toUnit）=>unitConverter.GetConversionFunction（from.Unit，toUnit）（from）；
Console.WriteLine（$“将10吨转换为：”）；
Console.WriteLine（转换（HowMuchUnit.Some））；//200公分
Console.WriteLine（转换（HowMuchUnit.Lots））；//100升
Console.WriteLine（转换（HowMuchUnit.Tons））；//10吨

样本量

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
}

public enum HowMuchUnit
{
一些
太多了，
吨
}
公共结构多少钱：IQuantity
{
公共多少（双倍值，多少单位）
{
单位=单位；
价值=价值；
}
Enum IQuantity.Unit=>Unit；
公共HowMuchUnit单元{get；}
公共双值{get；}
#地域分类学
私有静态只读多少零=新多少（0，HowMuchUnit.Some）；
公共QuantityType=>QuantityType.Undefined；
公共BaseDimensions Dimensions=>BaseDimensions.无量纲；
公共QuantityInfo QuantityInfo=>新QuantityInfo（类型，
新UnitInfo[]
{
新UnitInfo（HowMuchUnit.Some，BaseUnits.Undefined），
新UnitInfo（HowMuchUnit.Lots，BaseUnits.Undefined），
新UnitInfo（HowMuchUnit.ton，基本单位未定义），
},
多少钱，多少钱，
零,，
基本尺寸（无量纲）；
公共双As（枚举单位）=>Convert.ToDouble（单位）；
public double As（UnitSystem UnitSystem）=>抛出新的NotImplementedException（）；
公共酒类单位（枚举单位）
{
如果（单位为HowMuchUnit HowMuchUnit）返回新的HowMuch（作为（单位），HowMuchUnit）；
抛出新ArgumentException（“必须是HowMuchUnit.”类型，nameof（unit））；
}
公共IQuantity ToUnit（UnitSystem UnitSystem）=>抛出新的NotImplementedException（）；
公共重写字符串ToString（）=>$“{Value}{unitabrevisionscache.Default.getDefault缩写（单位）}”；
公共字符串ToString（字符串格式，IFormatProvider formatProvider）=>$“多少（{format}，{formatProvider}）”；
公共字符串ToString（IFormatProvider provider）=>$“多少（{provider}）”；
公共字符串ToString（IFormatProvider提供程序，int-signifintDigitAfterRadius）=>$“多少（{provider}，{signifintDigitAfterRadius}）”；
公共字符串ToString（IFormatProvider提供程序，字符串格式，params对象[]args）=>$“多少（{provider}，{string.Join（“，”，args）}）”；
#端区
}