Fix #36 Throws exception on ToString() for cultures with no unit...

...abbreviations

Fall back to default culture, then fall back to default abbreviation

* Add test GetDefaultAbbreviationFallsBackToUsEnglishCulture

Fixes #36
#36

Author: angularsen

Src/UnitsNet/CustomCode/UnitSystem.cs

@@ -34,11 +34,12 @@ namespace UnitsNet
     public partial class UnitSystem
     {
         private static readonly Dictionary<CultureInfo, UnitSystem> CultureToInstance;
+        private static readonly CultureInfo DefaultCulture = CultureInfo.GetCultureInfo("en-US");
 
         /// <summary>
         ///     The culture of which this unit system is based on. Either passed in to constructor or the default culture.
         /// </summary>
-        [PublicAPI] public readonly CultureInfo Culture;
+        [NotNull] [PublicAPI] public readonly CultureInfo Culture;
 
         /// <summary>
         ///     Per-unit-type dictionary of enum values by abbreviation. This is the inverse of
@@ -66,7 +67,7 @@ static UnitSystem()
         public UnitSystem([CanBeNull] CultureInfo cultureInfo = null)
         {
             if (cultureInfo == null)
-                cultureInfo = new CultureInfo("en-US");
+                cultureInfo = new CultureInfo(DefaultCulture.Name);
 
             Culture = cultureInfo;
             _unitTypeToUnitValueToAbbrevs = new Dictionary<Type, Dictionary<int, List<string>>>();
@@ -75,6 +76,11 @@ public UnitSystem([CanBeNull] CultureInfo cultureInfo = null)
             LoadDefaultAbbreviatons(cultureInfo);
         }
 
+        public bool IsDefaultCulture
+        {
+            get { return Culture.Equals(DefaultCulture); }
+        }
+
         [PublicAPI]
         public static void ClearCache()
         {
@@ -145,7 +151,7 @@ public string GetDefaultAbbreviation<TUnit>(TUnit unit)
         public void MapUnitToAbbreviation<TUnit>(TUnit unit, params string[] abbreviations)
             where TUnit : /*Enum constraint hack*/ struct, IComparable, IFormattable
         {
-            // Assuming TUnit is an enum, this conversion is safe. Not possible to cleanly enforce this today.
+            // Assuming TUnit is an enum, this conversion is safe. Seems not possible to enforce this today.
             // Src: http://stackoverflow.com/questions/908543/how-to-convert-from-system-enum-to-base-integer
             // http://stackoverflow.com/questions/79126/create-generic-method-constraining-t-to-an-enum
             int unitValue = Convert.ToInt32(unit);
@@ -197,22 +203,31 @@ public bool TryParse<TUnit>(string unitAbbreviation, out TUnit unit)
             Type unitType = typeof (TUnit);
 
             Dictionary<string, int> abbrevToUnitValue;
-            if (!_unitTypeToAbbrevToUnitValue.TryGetValue(unitType, out abbrevToUnitValue))
-                throw new NotImplementedException(
-                    string.Format("No abbreviations defined for unit type [{0}] for culture [{1}].", unitType,
-                        Culture.EnglishName));
-
             int unitValue;
-            if (!abbrevToUnitValue.TryGetValue(unitAbbreviation, out unitValue))
+
+            if (!_unitTypeToAbbrevToUnitValue.TryGetValue(unitType, out abbrevToUnitValue) ||
+                !abbrevToUnitValue.TryGetValue(unitAbbreviation, out unitValue))
             {
-                unit = default(TUnit);
-                return false;
+                if (IsDefaultCulture)
+                {
+                    unit = default(TUnit);
+                    return false;
+                }
+
+                // Fall back to default culture
+                return GetCached(DefaultCulture).TryParse(unitAbbreviation, out unit);
             }
 
             unit = (TUnit) (object) unitValue;
             return true;
         }
 
+        /// <summary>
+        ///     Get all abbreviations for unit.
+        /// </summary>
+        /// <typeparam name="TUnit">Enum type for units.</typeparam>
+        /// <param name="unit">Enum value for unit.</param>
+        /// <returns>Unit abbreviations associated with unit.</returns>
         [PublicAPI]
         public string[] GetAllAbbreviations<TUnit>(TUnit unit)
             where TUnit : /*Enum constraint hack*/ struct, IComparable, IFormattable
@@ -221,18 +236,20 @@ public string[] GetAllAbbreviations<TUnit>(TUnit unit)
             int unitValue = Convert.ToInt32(unit);
 
             Dictionary<int, List<string>> unitValueToAbbrevs;
-            if (!_unitTypeToUnitValueToAbbrevs.TryGetValue(unitType, out unitValueToAbbrevs))
-                throw new NotImplementedException(
-                    string.Format("No abbreviations defined for unit type [{0}] for culture [{1}].", unitType,
-                        Culture.EnglishName));
-
             List<string> abbrevs;
-            if (!unitValueToAbbrevs.TryGetValue(unitValue, out abbrevs))
-                throw new NotImplementedException(
-                    string.Format("No abbreviations defined for unit type [{0}.{1}] for culture [{2}].", unitType,
-                        unitValue, Culture.EnglishName));
 
-            // Return the first (most commonly used) abbreviation for this unit)
+            if (!_unitTypeToUnitValueToAbbrevs.TryGetValue(unitType, out unitValueToAbbrevs) ||
+                !unitValueToAbbrevs.TryGetValue(unitValue, out abbrevs))
+            {
+                if (IsDefaultCulture)
+                {
+                    return new[] {string.Format("(no abbreviation for {0})", unit.ToString())};
+                }
+
+                // Fall back to default culture
+                return GetCached(DefaultCulture).GetAllAbbreviations(unit);
+            }
+
             return abbrevs.ToArray();
         }
 

Tests/UnitSystemTests.cs

@@ -55,6 +55,15 @@ private static IEnumerable<object> GetUnitTypesWithMissingAbbreviations<TUnit>(s
             return unitsMissingAbbreviations.Cast<object>();
         }
 
+        private enum CustomUnit
+        {
+// ReSharper disable UnusedMember.Local
+            Undefined = 0,
+            Unit1,
+            Unit2
+// ReSharper restore UnusedMember.Local
+        }
+
         [Test]
         public void AllUnitAbbreviationsImplemented([Values("en-US", "nb-NO", "ru-RU")] string cultureName)
         {
@@ -174,6 +183,25 @@ public void AllUnitsImplementToStringForRussian()
             }
         }
 
+        [Test]
+        public void GetDefaultAbbreviationFallsBackToUsEnglishCulture()
+        {
+            // CurrentCulture affects number formatting, such as comma or dot as decimal separator.
+            // CurrentUICulture affects localization, in this case the abbreviation.
+            // Zulu (South Africa)
+            UnitSystem zuluUnits = UnitSystem.GetCached(CultureInfo.GetCultureInfo("zu-ZA"));
+            Thread.CurrentThread.CurrentCulture = Thread.CurrentThread.CurrentUICulture = zuluUnits.Culture;
+
+            UnitSystem usUnits = UnitSystem.GetCached(CultureInfo.GetCultureInfo("en-US"));
+            usUnits.MapUnitToAbbreviation(CustomUnit.Unit1, "US english abbreviation for Unit1");
+
+            // Act
+            string abbreviation = zuluUnits.GetDefaultAbbreviation(CustomUnit.Unit1);
+
+            // Assert
+            Assert.AreEqual("US english abbreviation for Unit1", abbreviation);
+        }
+
         [Test]
         public void ToStringRoundsToTwoDecimals()
         {