Components: Forms and validation

eng/Dependencies.props

@@ -134,6 +134,8 @@ and are generated based on the last package release.
     <LatestPackageReference Include="StackExchange.Redis" Version="$(StackExchangeRedisPackageVersion)" />
     <LatestPackageReference Include="System.Buffers" Version="$(SystemBuffersPackageVersion)" />
     <LatestPackageReference Include="System.CodeDom" Version="$(SystemCodeDomPackageVersion)" />
+    <LatestPackageReference Include="System.ComponentModel" Version="$(SystemComponentModelPackageVersion)" />
+    <LatestPackageReference Include="System.ComponentModel.Annotations" Version="$(SystemComponentModelAnnotationsPackageVersion)" />
     <LatestPackageReference Include="System.Data.SqlClient" Version="$(SystemDataSqlClientPackageVersion)" />
     <LatestPackageReference Include="System.Diagnostics.EventLog" Version="$(SystemDiagnosticsEventLogPackageVersion)" />
     <LatestPackageReference Include="System.IdentityModel.Tokens.Jwt" Version="$(SystemIdentityModelTokensJwtPackageVersion)" />

eng/SharedFramework.External.props

@@ -90,6 +90,7 @@
   -->
   <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
     <_CompilationOnlyReference Include="System.Buffers" />
+    <_CompilationOnlyReference Include="System.ComponentModel.Annotations" />
   </ItemGroup>
 
   <!--

eng/Version.Details.xml

@@ -293,6 +293,10 @@
       <Uri>https://github.com/dotnet/corefx</Uri>
       <Sha>0abec4390b30fdda97dc496594f9b1f9c9b20e17</Sha>
     </Dependency>
+    <Dependency Name="System.ComponentModel.Annotations" Version="4.6.0-preview.19109.6">
+      <Uri>https://github.com/dotnet/corefx</Uri>
+      <Sha>0abec4390b30fdda97dc496594f9b1f9c9b20e17</Sha>
+    </Dependency>
     <Dependency Name="System.Data.SqlClient" Version="4.7.0-preview.19109.6">
       <Uri>https://github.com/dotnet/corefx</Uri>
       <Sha>0abec4390b30fdda97dc496594f9b1f9c9b20e17</Sha>

eng/Versions.props

@@ -25,6 +25,7 @@
     <MicrosoftBclJsonSourcesPackageVersion>4.6.0-preview.19109.6</MicrosoftBclJsonSourcesPackageVersion>
     <MicrosoftCSharpPackageVersion>4.6.0-preview.19109.6</MicrosoftCSharpPackageVersion>
     <MicrosoftWin32RegistryPackageVersion>4.6.0-preview.19109.6</MicrosoftWin32RegistryPackageVersion>
+    <SystemComponentModelAnnotationsPackageVersion>4.6.0-preview.19109.6</SystemComponentModelAnnotationsPackageVersion>
     <SystemDataSqlClientPackageVersion>4.7.0-preview.19109.6</SystemDataSqlClientPackageVersion>
     <SystemDiagnosticsEventLogPackageVersion>4.6.0-preview.19109.6</SystemDiagnosticsEventLogPackageVersion>
     <SystemIOPipelinesPackageVersion>4.6.0-preview.19109.6</SystemIOPipelinesPackageVersion>
@@ -134,6 +135,7 @@
     <!-- Stable dotnet/corefx packages no longer updated for .NET Core 3 -->
     <SystemBuffersPackageVersion>4.5.0</SystemBuffersPackageVersion>
     <SystemCodeDomPackageVersion>4.4.0</SystemCodeDomPackageVersion>
+    <SystemComponentModelPackageVersion>4.3.0</SystemComponentModelPackageVersion>
     <SystemNetHttpPackageVersion>4.3.2</SystemNetHttpPackageVersion>
     <SystemThreadingTasksExtensionsPackageVersion>4.5.2</SystemThreadingTasksExtensionsPackageVersion>
     <!-- Packages developed by @aspnet, but manually updated as necessary. -->

src/Components/Blazor/Build/src/targets/BuiltInBclLinkerDescriptor.xml

@@ -9,4 +9,9 @@
     to implement timers. Fixes https://github.com/aspnet/Blazor/issues/239 -->
     <type fullname="System.Threading.WasmRuntime" />
   </assembly>
+
+  <assembly fullname="System">
+    <!-- Without this, [Required(typeof(bool), "true", "true", ErrorMessage = "...")] fails -->
+    <type fullname="System.ComponentModel.BooleanConverter" />
+  </assembly>
 </linker>

src/Components/Blazor/Build/test/RuntimeDependenciesResolverTest.cs

@@ -84,6 +84,8 @@ uncalled implementation code from mscorlib.dll anyway.
                 "System.Collections.dll",
                 "System.ComponentModel.Composition.dll",
                 "System.ComponentModel.dll",
+                "System.ComponentModel.Annotations.dll",
+                "System.ComponentModel.DataAnnotations.dll",
                 "System.Core.dll",
                 "System.Data.dll",
                 "System.Diagnostics.Debug.dll",

src/Components/Components/src/Forms/DataAnnotationsValidator.cs

@@ -0,0 +1,28 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+
+namespace Microsoft.AspNetCore.Components.Forms
+{
+    /// <summary>
+    /// Adds Data Annotations validation support to an <see cref="EditContext"/>.
+    /// </summary>
+    public class DataAnnotationsValidator : ComponentBase
+    {
+        [CascadingParameter] EditContext CurrentEditContext { get; set; }
+
+        /// <inheritdoc />
+        protected override void OnInit()
+        {
+            if (CurrentEditContext == null)
+            {
+                throw new InvalidOperationException($"{nameof(DataAnnotationsValidator)} requires a cascading " +
+                    $"parameter of type {nameof(EditContext)}. For example, you can use {nameof(DataAnnotationsValidator)} " +
+                    $"inside an {nameof(EditForm)}.");
+            }
+
+            CurrentEditContext.AddDataAnnotationsValidation();
+        }
+    }
+}

src/Components/Components/src/Forms/EditContext.cs

@@ -0,0 +1,191 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Microsoft.AspNetCore.Components.Forms
+{
+    /// <summary>
+    /// Holds metadata related to a data editing process, such as flags to indicate which
+    /// fields have been modified and the current set of validation messages.
+    /// </summary>
+    public sealed class EditContext
+    {
+        // Note that EditContext tracks state for any FieldIdentifier you give to it, plus
+        // the underlying storage is sparse. As such, none of the APIs have a "field not found"
+        // error state. If you give us an unrecognized FieldIdentifier, that just means we
+        // didn't yet track any state for it, so we behave as if it's in the default state
+        // (valid and unmodified).
+        private readonly Dictionary<FieldIdentifier, FieldState> _fieldStates = new Dictionary<FieldIdentifier, FieldState>();
+
+        /// <summary>
+        /// Constructs an instance of <see cref="EditContext"/>.
+        /// </summary>
+        /// <param name="model">The model object for the <see cref="EditContext"/>. This object should hold the data being edited, for example as a set of properties.</param>
+        public EditContext(object model)
+        {
+            // The only reason we disallow null is because you'd almost always want one, and if you
+            // really don't, you can pass an empty object then ignore it. Ensuring it's nonnull
+            // simplifies things for all consumers of EditContext.
+            Model = model ?? throw new ArgumentNullException(nameof(model));
+        }
+
+        /// <summary>
+        /// An event that is raised when a field value changes.
+        /// </summary>
+        public event EventHandler<FieldChangedEventArgs> OnFieldChanged;
+
+        /// <summary>
+        /// An event that is raised when validation is requested.
+        /// </summary>
+        public event EventHandler<ValidationRequestedEventArgs> OnValidationRequested;
+
+        /// <summary>
+        /// An event that is raised when validation state has changed.
+        /// </summary>
+        public event EventHandler<ValidationStateChangedEventArgs> OnValidationStateChanged;
+
+        /// <summary>
+        /// Supplies a <see cref="FieldIdentifier"/> corresponding to a specified field name
+        /// on this <see cref="EditContext"/>'s <see cref="Model"/>.
+        /// </summary>
+        /// <param name="fieldName">The name of the editable field.</param>
+        /// <returns>A <see cref="FieldIdentifier"/> corresponding to a specified field name on this <see cref="EditContext"/>'s <see cref="Model"/>.</returns>
+        public FieldIdentifier Field(string fieldName)
+            => new FieldIdentifier(Model, fieldName);
+
+        /// <summary>
+        /// Gets the model object for this <see cref="EditContext"/>.
+        /// </summary>
+        public object Model { get; }
+
+        /// <summary>
+        /// Signals that the value for the specified field has changed.
+        /// </summary>
+        /// <param name="fieldIdentifier">Identifies the field whose value has been changed.</param>
+        public void NotifyFieldChanged(in FieldIdentifier fieldIdentifier)
+        {
+            GetFieldState(fieldIdentifier, ensureExists: true).IsModified = true;
+            OnFieldChanged?.Invoke(this, new FieldChangedEventArgs(fieldIdentifier));
+        }
+
+        /// <summary>
+        /// Signals that some aspect of validation state has changed.
+        /// </summary>
+        public void NotifyValidationStateChanged()
+        {
+            OnValidationStateChanged?.Invoke(this, ValidationStateChangedEventArgs.Empty);
+        }
+
+        /// <summary>
+        /// Clears any modification flag that may be tracked for the specified field.
+        /// </summary>
+        /// <param name="fieldIdentifier">Identifies the field whose modification flag (if any) should be cleared.</param>
+        public void MarkAsUnmodified(in FieldIdentifier fieldIdentifier)
+        {
+            if (_fieldStates.TryGetValue(fieldIdentifier, out var state))
+            {
+                state.IsModified = false;
+            }
+        }
+
+        /// <summary>
+        /// Clears all modification flags within this <see cref="EditContext"/>.
+        /// </summary>
+        public void MarkAsUnmodified()
+        {
+            foreach (var state in _fieldStates)
+            {
+                state.Value.IsModified = false;
+            }
+        }
+
+        /// <summary>
+        /// Determines whether any of the fields in this <see cref="EditContext"/> have been modified.
+        /// </summary>
+        /// <returns>True if any of the fields in this <see cref="EditContext"/> have been modified; otherwise false.</returns>
+        public bool IsModified()
+        {
+            // If necessary, we could consider caching the overall "is modified" state and only recomputing
+            // when there's a call to NotifyFieldModified/NotifyFieldUnmodified
+            foreach (var state in _fieldStates)
+            {
+                if (state.Value.IsModified)
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Gets the current validation messages across all fields.
+        ///
+        /// This method does not perform validation itself. It only returns messages determined by previous validation actions.
+        /// </summary>
+        /// <returns>The current validation messages.</returns>
+        public IEnumerable<string> GetValidationMessages()
+        {
+            // Since we're only enumerating the fields for which we have a non-null state, the cost of this grows
+            // based on how many fields have been modified or have associated validation messages
+            foreach (var state in _fieldStates)
+            {
+                foreach (var message in state.Value.GetValidationMessages())
+                {
+                    yield return message;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets the current validation messages for the specified field.
+        ///
+        /// This method does not perform validation itself. It only returns messages determined by previous validation actions.
+        /// </summary>
+        /// <param name="fieldIdentifier">Identifies the field whose current validation messages should be returned.</param>
+        /// <returns>The current validation messages for the specified field.</returns>
+        public IEnumerable<string> GetValidationMessages(FieldIdentifier fieldIdentifier)
+        {
+            if (_fieldStates.TryGetValue(fieldIdentifier, out var state))
+            {
+                foreach (var message in state.GetValidationMessages())
+                {
+                    yield return message;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Determines whether the specified fields in this <see cref="EditContext"/> has been modified.
+        /// </summary>
+        /// <returns>True if the field has been modified; otherwise false.</returns>
+        public bool IsModified(in FieldIdentifier fieldIdentifier)
+            => _fieldStates.TryGetValue(fieldIdentifier, out var state)
+            ? state.IsModified
+            : false;
+
+        /// <summary>
+        /// Validates this <see cref="EditContext"/>.
+        /// </summary>
+        /// <returns>True if there are no validation messages after validation; otherwise false.</returns>
+        public bool Validate()
+        {
+            OnValidationRequested?.Invoke(this, ValidationRequestedEventArgs.Empty);
+            return !GetValidationMessages().Any();
+        }
+
+        internal FieldState GetFieldState(in FieldIdentifier fieldIdentifier, bool ensureExists)
+        {
+            if (!_fieldStates.TryGetValue(fieldIdentifier, out var state) && ensureExists)
+            {
+                state = new FieldState(fieldIdentifier);
+                _fieldStates.Add(fieldIdentifier, state);
+            }
+
+            return state;
+        }
+    }
+}

src/Components/Components/src/Forms/EditContextDataAnnotationsExtensions.cs

@@ -0,0 +1,101 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Linq;
+using System.Reflection;
+
+namespace Microsoft.AspNetCore.Components.Forms
+{
+    /// <summary>
+    /// Extension methods to add DataAnnotations validation to an <see cref="EditContext"/>.
+    /// </summary>
+    public static class EditContextDataAnnotationsExtensions
+    {
+        private static ConcurrentDictionary<(Type ModelType, string FieldName), PropertyInfo> _propertyInfoCache
+            = new ConcurrentDictionary<(Type, string), PropertyInfo>();
+
+        /// <summary>
+        /// Adds DataAnnotations validation support to the <see cref="EditContext"/>.
+        /// </summary>
+        /// <param name="editContext">The <see cref="EditContext"/>.</param>
+        public static EditContext AddDataAnnotationsValidation(this EditContext editContext)
+        {
+            if (editContext == null)
+            {
+                throw new ArgumentNullException(nameof(editContext));
+            }
+
+            var messages = new ValidationMessageStore(editContext);
+
+            // Perform object-level validation on request
+            editContext.OnValidationRequested +=
+                (sender, eventArgs) => ValidateModel((EditContext)sender, messages);
+
+            // Perform per-field validation on each field edit
+            editContext.OnFieldChanged +=
+                (sender, eventArgs) => ValidateField(editContext, messages, eventArgs.FieldIdentifier);
+
+            return editContext;
+        }
+
+        private static void ValidateModel(EditContext editContext, ValidationMessageStore messages)
+        {
+            var validationContext = new ValidationContext(editContext.Model);
+            var validationResults = new List<ValidationResult>();
+            Validator.TryValidateObject(editContext.Model, validationContext, validationResults, true);
+
+            // Transfer results to the ValidationMessageStore
+            messages.Clear();
+            foreach (var validationResult in validationResults)
+            {
+                foreach (var memberName in validationResult.MemberNames)
+                {
+                    messages.Add(editContext.Field(memberName), validationResult.ErrorMessage);
+                }
+            }
+
+            editContext.NotifyValidationStateChanged();
+        }
+
+        private static void ValidateField(EditContext editContext, ValidationMessageStore messages, in FieldIdentifier fieldIdentifier)
+        {
+            if (TryGetValidatableProperty(fieldIdentifier, out var propertyInfo))
+            {
+                var propertyValue = propertyInfo.GetValue(fieldIdentifier.Model);
+                var validationContext = new ValidationContext(fieldIdentifier.Model)
+                {
+                    MemberName = propertyInfo.Name
+                };
+                var results = new List<ValidationResult>();
+
+                Validator.TryValidateProperty(propertyValue, validationContext, results);
+                messages.Clear(fieldIdentifier);
+                messages.AddRange(fieldIdentifier, results.Select(result => result.ErrorMessage));
+
+                // We have to notify even if there were no messages before and are still no messages now,
+                // because the "state" that changed might be the completion of some async validation task
+                editContext.NotifyValidationStateChanged();
+            }
+        }
+
+        private static bool TryGetValidatableProperty(in FieldIdentifier fieldIdentifier, out PropertyInfo propertyInfo)
+        {
+            var cacheKey = (ModelType: fieldIdentifier.Model.GetType(), fieldIdentifier.FieldName);
+            if (!_propertyInfoCache.TryGetValue(cacheKey, out propertyInfo))
+            {
+                // DataAnnotations only validates public properties, so that's all we'll look for
+                // If we can't find it, cache 'null' so we don't have to try again next time
+                propertyInfo = cacheKey.ModelType.GetProperty(cacheKey.FieldName);
+
+                // No need to lock, because it doesn't matter if we write the same value twice
+                _propertyInfoCache[cacheKey] = propertyInfo;
+            }
+
+            return propertyInfo != null;
+        }
+    }
+}