Make binders handle exceptions during conversion

Author: rynowak

src/Components/Components/src/EventCallbackFactoryBinderExtensions.cs

@@ -330,7 +330,22 @@ public static EventCallback<UIChangeEventArgs> CreateBinder(
             // when a format is used.
             Action<UIChangeEventArgs> callback = (e) =>
             {
-                setter(ConvertDateTime(e.Value, format: null));
+                DateTime value = default;
+                var converted = false;
+                try
+                {
+                    value = ConvertDateTime(e.Value, format: null);
+                    converted = true;
+                }
+                catch
+                {
+                }
+
+                // See comments in CreateBinderCore
+                if (converted)
+                {
+                    setter(value);
+                }
             };
             return factory.Create<UIChangeEventArgs>(receiver, callback);
         }
@@ -355,7 +370,22 @@ public static EventCallback<UIChangeEventArgs> CreateBinder(
             // when a format is used.
             Action<UIChangeEventArgs> callback = (e) =>
             {
-                setter(ConvertDateTime(e.Value, format));
+                DateTime value = default;
+                var converted = false;
+                try
+                {
+                    value = ConvertDateTime(e.Value, format);
+                    converted = true;
+                }
+                catch
+                {
+                }
+
+                // See comments in CreateBinderCore
+                if (converted)
+                {
+                    setter(value);
+                }
             };
             return factory.Create<UIChangeEventArgs>(receiver, callback);
         }
@@ -403,7 +433,24 @@ private static EventCallback<UIChangeEventArgs> CreateBinderCore<T>(
         {
             Action<UIChangeEventArgs> callback = e =>
             {
-                setter(converter(e.Value));
+                T value = default;
+                var converted = false;
+                try
+                {
+                    value = converter(e.Value);
+                    converted = true;
+                }
+                catch
+                {
+                }
+
+                // We only invoke the setter if the conversion didn't throw. This is valuable because it allows us to attempt
+                // to process invalid input but avoid dirtying the state of the component if can't be converted. Imagine if
+                // we assigned default(T) on failure - this would result in trouncing the user's typed in value.
+                if (converted)
+                {
+                    setter(value);
+                }
             };
             return factory.Create<UIChangeEventArgs>(receiver, callback);
         }

src/Components/Components/test/EventCallbackFactoryBinderExtensionsTest.cs

@@ -10,7 +10,7 @@ namespace Microsoft.AspNetCore.Components
     public class EventCallbackFactoryBinderExtensionsTest
     {
         [Fact]
-        public async Task CreateBinder_ThrowsConversionException()
+        public async Task CreateBinder_SwallowsConversionException()
         {
             // Arrange
             var value = 17;
@@ -20,12 +20,27 @@ public async Task CreateBinder_ThrowsConversionException()
             var binder = EventCallback.Factory.CreateBinder(component, setter, value);
 
             // Act
-            await Assert.ThrowsAsync<FormatException>(() =>
+            await binder.InvokeAsync(new UIChangeEventArgs() { Value = "not-an-integer!", });
+
+            Assert.Equal(17, value); // Setter not called
+            Assert.Equal(1, component.Count);
+        }
+
+        [Fact]
+        public async Task CreateBinder_ThrowsSetterException()
+        {
+            // Arrange
+            var component = new EventCountingComponent();
+            Action<int> setter = (_) => { throw new InvalidTimeZoneException(); };
+
+            var binder = EventCallback.Factory.CreateBinder(component, setter, 17);
+
+            // Act
+            await Assert.ThrowsAsync<InvalidTimeZoneException>(() =>
             {
-                return binder.InvokeAsync(new UIChangeEventArgs() { Value = "not-an-integer!", });
+                return binder.InvokeAsync(new UIChangeEventArgs() { Value = "18", });
             });
 
-            Assert.Equal(17, value);
             Assert.Equal(1, component.Count);
         }
 

src/Components/test/E2ETest/Tests/BindTest.cs

@@ -397,7 +397,7 @@ public void CanBindTextboxDecimal()
             target.Clear();
             target.SendKeys("0.010\t");
             WaitAssert.Equal("0.010", () => boundValue.Text);
-            Assert.Equal("0.010", mirrorValue.GetAttribute("value"));
+            WaitAssert.Equal("0.010", () => mirrorValue.GetAttribute("value"));
         }
 
         [Fact]