GetDefaultAbbreviation by enum is not working properly.

[farenasmz]

Hello everyone,

I'm currently working on a project utilizing units.net and have encountered an issue while handling custom units. I've defined a new custom unit called GasFlowRate and created two specific measures within it: StandardCubicMetersPerDay and ThousandStandardCubicFeetPerDay.

I've used UnitAbbreviationsCache.Default.MapUnitToDefaultAbbreviation to set the default abbreviations for these units, and they seem to be mapped correctly.

However, when I attempt to retrieve the abbreviation for these units using UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);, I encounter the following error: InnerException: null, Message: "No abbreviation is specified for Enum.ThousandStandardCubicFeetPerDay".

Interestingly, if I specify the unit directly, like UnitAbbreviationsCache.Default.GetDefaultAbbreviation(GasFlowRateUnit.StandardCubicMetersPerDay), it retrieves the abbreviation without any issue.

But when I send the unit as a parameter to a function, e.g., GetAbbreviation(quantity, GasFlowRateUnit.StandardCubicMetersPerDay), it throws the aforementioned error.

I've made sure that the unit is being passed correctly, and the enumeration value seems to be in the right format. I've attempted to cast the enum to its specific type and used various methods to handle it, but the issue persists.

Here's a snippet of the relevant code:

Is there something specific I need to be aware of when working with custom units and abbreviations in units.net? Any insights or suggestions on how to resolve this issue would be greatly appreciated.

Thank you in advance for your assistance!

public static string GetAbbreviation(this IQuantity quantity, Enum unit)
        {
            var unitType = quantity.QuantityInfo.UnitType;
            var unitValue = Convert.ToInt32(unit);
            var result = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
            return result;
       }            

 public enum GasFlowRateUnit
    {
        StandardCubicMetersPerDay = 1,
        ThousandStandardCubicFeetPerDay = 2,
    }

  public struct GasFlowRate : IQuantity
    {
        public GasFlowRate(double value, GasFlowRateUnit unit)
        {
            Unit = unit;
            Value = value;
            AddAbbreviations();
        }

        private void AddAbbreviations()
        {
            UnitAbbreviationsCache.Default.MapUnitToDefaultAbbreviation(GasFlowRateUnit.StandardCubicMetersPerDay, "m³/d");
            UnitAbbreviationsCache.Default.MapUnitToDefaultAbbreviation(GasFlowRateUnit.ThousandStandardCubicFeetPerDay, "kft³/d");
        }

        Enum IQuantity.Unit => Unit;

        public GasFlowRateUnit Unit { get; }

        public double Value { get; }

        #region IQuantity

        private static readonly GasFlowRate Zero = new GasFlowRate(0, GasFlowRateUnit.StandardCubicMetersPerDay);

        public BaseDimensions Dimensions => BaseDimensions.Dimensionless;

        public QuantityType Type => QuantityType.Undefined;

        public QuantityInfo QuantityInfo => new QuantityInfo(nameof(GasFlowRate), Type.GetType(),
        new UnitInfo[]
              {
                new UnitInfo<GasFlowRateUnit>(GasFlowRateUnit.StandardCubicMetersPerDay, "m³/d", BaseUnits.Undefined),
                new UnitInfo<GasFlowRateUnit>(GasFlowRateUnit.ThousandStandardCubicFeetPerDay, "kft³/d", BaseUnits.Undefined),
              }, GasFlowRateUnit.StandardCubicMetersPerDay, Zero, BaseDimensions.Dimensionless);

        public double As(Enum unit)
        {
            if (Unit == GasFlowRateUnit.StandardCubicMetersPerDay && unit.Equals(GasFlowRateUnit.ThousandStandardCubicFeetPerDay))
            {
                return Value * 35.315 / 1000;
            }

            if (Unit == GasFlowRateUnit.ThousandStandardCubicFeetPerDay && unit.Equals(GasFlowRateUnit.StandardCubicMetersPerDay))
            {
                return Value * 1000 / 35.315;
            }

            return Convert.ToDouble(unit);
        }

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

        public IQuantity ToUnit(Enum unit)
        {
            if (unit is GasFlowRateUnit gasRateFlowUnit)
            {
                return new GasFlowRate(As(unit), gasRateFlowUnit);
            }

            throw new ArgumentException("Must be of type GasFlowRateUnit.", nameof(unit));
        }

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

        public static GasFlowRate FromStandardCubicMetersPerDay(QuantityValue footPerDay)
        {
            double value = (double)footPerDay;
            return new GasFlowRate(value, GasFlowRateUnit.StandardCubicMetersPerDay);
        }

        public override string ToString() => $"{Value} {UnitAbbreviationsCache.Default.GetDefaultAbbreviation(Unit)}";

        public string ToString(string format, IFormatProvider formatProvider) => $"{Value} {UnitAbbreviationsCache.Default.GetDefaultAbbreviation(Unit)} ({format}, {formatProvider})";

        public string ToString(IFormatProvider provider) => $"{Value} {UnitAbbreviationsCache.Default.GetDefaultAbbreviation(Unit)} ({provider})";

        public string ToString(IFormatProvider provider, int significantDigitsAfterRadix) => $"{Value} {UnitAbbreviationsCache.Default.GetDefaultAbbreviation(Unit)} ({provider}, {significantDigitsAfterRadix})";

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

        public bool Equals(IQuantity other, IQuantity tolerance)
        {
            throw new NotImplementedException();
        }

        #endregion
    }

[angularsen]

Closing as duplicate of #1301