make reading settings more robust

Author: brettfo

src/IxMilia.BCad.Core.Test/SettingsTests.cs

@@ -1,4 +1,5 @@
-using Xunit;
+using System;
+using Xunit;
 
 namespace IxMilia.BCad.Core.Test
 {
@@ -122,5 +123,28 @@ public void SetValueFromString()
             var finalCursorSize = Workspace.SettingsService.GetValue<int>("Display.CursorSize");
             Assert.Equal(4242, finalCursorSize);
         }
+
+        [Theory]
+        [InlineData(typeof(bool), "TRUE", "True")] // boolean - valid
+        [InlineData(typeof(bool), "indeed", "False")] // boolean - invalid
+        [InlineData(typeof(int), "42", "42")] // int - valid
+        [InlineData(typeof(int), "not-an-int", "0")] // int - invalid
+        [InlineData(typeof(double), "3.5", "3.5")] // double - valid
+        [InlineData(typeof(double), "not-a-double", "0")] // double - invalid
+        [InlineData(typeof(string), "a string value", "a string value")] // string - valid
+        [InlineData(typeof(CadColor), "#FF2F2F2F", "#FF2F2F2F")] // CadColor - valid
+        [InlineData(typeof(CadColor), "a-beautiful-color", "#00000000")] // CadColor - invalid
+        [InlineData(typeof(DrawingUnits), "Metric", "Metric")] // DrawingUnits - valid
+        [InlineData(typeof(DrawingUnits), "2", "English")] // DrawingUnits - invalid
+        [InlineData(typeof(UnitFormat), "Decimal", "Decimal")] // UnitFormat - valid
+        [InlineData(typeof(UnitFormat), "not-a-unit-format", "Architectural")] // UnitFormat - invalid
+        [InlineData(typeof(double[]), "0;90;180;270", "0;90;180;270")] // double[] - valid
+        [InlineData(typeof(double[]), "not-an-array", "0")] // double[] - invalid
+        public void SetInvalidValueFromStringSetsReasonableDefault(Type valueType, string originalValue, string expectedString)
+        {
+            var parsedValue = Workspace.SettingsService.StringToValue(valueType, originalValue);
+            var actualString = Workspace.SettingsService.ValueToString(valueType, parsedValue);
+            Assert.Equal(expectedString, actualString);
+        }
     }
 }

src/IxMilia.BCad.Core/Services/ISettingsService.cs

@@ -15,7 +15,7 @@ public interface ISettingsService : IWorkspaceService
 
         T GetValue<T>(string settingName);
         void SetValue<T>(string settingName, T value);
-        void SetValueFromString(string settinggName, string value);
+        void SetValueFromString(string settingName, string value);
 
         void LoadFromLines(string[] lines);
         string WriteWithLines(string[] existingLines);

src/IxMilia.BCad.Core/Services/SettingsService.cs

@@ -166,27 +166,67 @@ public SettingData(string name, Type type, object value)
             }
         }
 
-        private static object BoolReader(string value) => bool.Parse(value);
+        private static object BoolReader(string value)
+        {
+            if (bool.TryParse(value, out var result))
+            {
+                return result;
+            }
+
+            return default(bool);
+        }
+
         private static string BoolWriter(object value) => ((bool)value).ToString(CultureInfo.InvariantCulture);
 
         private static object CadColorReader(string value) => CadColor.Parse(value);
         private static string CadColorWriter(object value) => ((CadColor)value).ToString();
 
-        private static object DoubleReader(string value) => double.Parse(value, CultureInfo.InvariantCulture);
+        private static object DoubleReader(string value)
+        {
+            if (double.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
+            {
+                return result;
+            }
+
+            return default(double);
+        }
+
         private static string DoubleWriter(object value) => ((double)value).ToString(CultureInfo.InvariantCulture);
 
-        private static object DrawingUnitsReader(string value) => Enum.Parse(typeof(DrawingUnits), value);
+        private static object DrawingUnitsReader(string value) => EnumReader<DrawingUnits>(value);
         private static string DrawingUnitsWriter(object value) => ((DrawingUnits)value).ToString();
 
-        private static object IntReader(string value) => int.Parse(value, CultureInfo.InvariantCulture);
+        private static object IntReader(string value)
+        {
+            if (int.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
+            {
+                return result;
+            }
+
+            return default(int);
+        }
+
         private static string IntWriter(object value) => ((int)value).ToString(CultureInfo.InvariantCulture);
 
         private static object StringReader(string value) => value;
         private static string StringWriter(object value) => value.ToString();
 
-        private static object UnitFormatReader(string value) => Enum.Parse(typeof(UnitFormat), value);
+        private static object UnitFormatReader(string value) => EnumReader<UnitFormat>(value);
         private static string UnitFormatWriter(object value) => ((UnitFormat)value).ToString();
 
+        private static object EnumReader<T>(string value) where T : struct
+        {
+            if (Enum.TryParse<T>(value, out var result))
+            {
+                if (Enum.IsDefined(typeof(T), result))
+                {
+                    return result;
+                }
+            }
+
+            return default(T);
+        }
+
         private static ValueReader CreateArrayReader<T>(Func<string, object> elementReader) => value => value.Split(';').Select(elementReader).Cast<T>().ToArray();
         private static ValueWriter CreateArrayWriter(Func<object, string> elementWriter)
         {