Updated BindingModelValidator to use MemberAccessor

Previously, the `BindingModelValidator` was operating directly off of the `PropertyInfo`, instead of using the `MemberAccessor`, since most of the methods only had access to the `PropertyInfo` . As a result, the calls to `SetValue()` and `GetValue()` were going directly through reflection, and not using the optimizations built into the new `MemberAccessor`.

This behavior was a holdover from the legacy `TypeMemberInfoCollection` and `MemberDispatcher` architecture. While `BindingModelValidator` doesn't have any dependencies on those classes, it did continue to operate off of `PropertyInfo`.

Now, for consistency, I've updated `ValidateModel()` to simply accept a `TypeAccessor` instead of a `sourceType` and a `properties` list. Further, all of its private methods now accept a `MemberAccessor` instead of a `PropertyInfo`.

In addition to being more consistent with other libraries, this should also be a bit more performant, and at minimum helps ensure that all reflection access is going through `MemberAccessor`.

This also mitigates a dependency on `PropertyConfiguration` needed to support the new constructor signature, which accepts a `MemberAccessor` (49ffd61).

Author: JeremyCaney

OnTopic/Mapping/Reverse/BindingModelValidator.cs

@@ -57,7 +57,7 @@ static internal class BindingModelValidator {
     ///     This helper function is intended to provide reporting to developers about errors in their model. As a result, it
     ///     will exclusively throw exceptions, as opposed to populating validation object for rendering to the view. Because
     ///     it's only evaluating the compiled model, which will not change during the application's life cycle, the <paramref
-    ///     name="sourceType"/> and <paramref name="contentTypeDescriptor"/> are stored as a <see cref="Tuple"/> in a static
+    ///     name="typeAccessor"/> and <paramref name="contentTypeDescriptor"/> are stored as a <see cref="Tuple"/> in a static
     ///     <see cref="ConcurrentBag{T}"/> once a particular combination has passed validation—that way, this check only needs
     ///     to be executed once for any combination, at least for the current application life cycle.
     ///   </para>
@@ -72,48 +72,43 @@ static internal class BindingModelValidator {
     ///     cref="ContentTypeDescriptor"/> may not have undergone explicit testing.
     ///   </para>
     /// </remarks>
-    /// <param name="sourceType">
-    ///   The binding model <see cref="Type"/> to validate.
-    /// </param>
-    /// <param name="properties">
-    ///   A <see cref="IEnumerable{PropertyInfo}"/> describing the <paramref name="sourceType"/>'s properties.
+    /// <param name="typeAccessor">
+    ///   The <see cref="TypeAccessor"/> of the binding model to validate.
     /// </param>
     /// <param name="contentTypeDescriptor">
     ///   The <see cref="ContentTypeDescriptor"/> object against which to validate the model.
     /// </param>
     /// <param name="attributePrefix">The prefix to apply to the attributes.</param>
     static internal void ValidateModel(
-      [AllowNull]Type sourceType,
-      [AllowNull]IEnumerable<PropertyInfo> properties,
+      [AllowNull]TypeAccessor typeAccessor,
       [AllowNull]ContentTypeDescriptor contentTypeDescriptor,
       [AllowNull]string attributePrefix = ""
       ) {
 
       /*------------------------------------------------------------------------------------------------------------------------
       | Validate parameters
       \-----------------------------------------------------------------------------------------------------------------------*/
-      Contract.Requires(sourceType, nameof(sourceType));
-      Contract.Requires(properties, nameof(properties));
+      Contract.Requires(typeAccessor, nameof(typeAccessor));
       Contract.Requires(contentTypeDescriptor, nameof(contentTypeDescriptor));
 
       /*------------------------------------------------------------------------------------------------------------------------
       | Skip validation if this type has already been validated for this content type
       \-----------------------------------------------------------------------------------------------------------------------*/
-      if (_modelsValidated.Contains((sourceType, contentTypeDescriptor.Key))) {
+      if (_modelsValidated.Contains((typeAccessor.Type, contentTypeDescriptor.Key))) {
         return;
       }
 
       /*------------------------------------------------------------------------------------------------------------------------
       | Validate
       \-----------------------------------------------------------------------------------------------------------------------*/
-      foreach (var property in properties) {
-        ValidateProperty(sourceType, property, contentTypeDescriptor, attributePrefix);
+      foreach (var property in typeAccessor.GetMembers(MemberTypes.Property)) {
+        ValidateProperty(typeAccessor.Type, property, contentTypeDescriptor, attributePrefix);
       }
 
       /*------------------------------------------------------------------------------------------------------------------------
       | Add type, content type to model validation cache so it isn't checked again
       \-----------------------------------------------------------------------------------------------------------------------*/
-      _modelsValidated.Add((sourceType, contentTypeDescriptor.Key));
+      _modelsValidated.Add((typeAccessor.Type, contentTypeDescriptor.Key));
 
       return;
 
@@ -129,16 +124,16 @@ static internal void ValidateModel(
     /// <param name="sourceType">
     ///   The binding model <see cref="Type"/> to validate.
     /// </param>
-    /// <param name="property">
-    ///   A <see cref="PropertyInfo"/> describing a specific property of the <paramref name="sourceType"/>.
+    /// <param name="propertyAccessor">
+    ///   A <see cref="MemberAccessor"/> describing a specific property of the <paramref name="sourceType"/>.
     /// </param>
     /// <param name="contentTypeDescriptor">
     ///   The <see cref="ContentTypeDescriptor"/> object against which to validate the model.
     /// </param>
     /// <param name="attributePrefix">The prefix to apply to the attributes.</param>
     static internal void ValidateProperty(
       [AllowNull]Type sourceType,
-      [AllowNull]PropertyInfo property,
+      [AllowNull]MemberAccessor propertyAccessor,
       [AllowNull]ContentTypeDescriptor contentTypeDescriptor,
       [AllowNull]string attributePrefix = ""
     ) {
@@ -147,14 +142,13 @@ static internal void ValidateProperty(
       | Validate parameters
       \-----------------------------------------------------------------------------------------------------------------------*/
       Contract.Requires(sourceType, nameof(sourceType));
-      Contract.Requires(property, nameof(property));
+      Contract.Requires(propertyAccessor, nameof(propertyAccessor));
       Contract.Requires(contentTypeDescriptor, nameof(contentTypeDescriptor));
 
       /*------------------------------------------------------------------------------------------------------------------------
       | Define variables
       \-----------------------------------------------------------------------------------------------------------------------*/
-      var propertyType          = property.PropertyType;
-      var configuration         = new PropertyConfiguration(property, attributePrefix);
+      var configuration         = new PropertyConfiguration(propertyAccessor, attributePrefix);
       var compositeAttributeKey = configuration.AttributeKey;
       var attributeDescriptor   = contentTypeDescriptor.AttributeDescriptors.GetValue(compositeAttributeKey);
       var childCollections      = new[] { CollectionType.Children, CollectionType.NestedTopics };
@@ -171,20 +165,18 @@ static internal void ValidateProperty(
       /*------------------------------------------------------------------------------------------------------------------------
       | Skip properties injected by the compiler for record types
       \-----------------------------------------------------------------------------------------------------------------------*/
-      if (configuration.Property.Name is "EqualityContract") {
+      if (propertyAccessor.Name is "EqualityContract") {
         return;
       }
 
       /*------------------------------------------------------------------------------------------------------------------------
       | Handle mapping properties from referenced objects
       \-----------------------------------------------------------------------------------------------------------------------*/
       if (configuration.MapToParent) {
-        var typeAccessor        = TypeAccessorCache.GetTypeAccessor(propertyType);
-        var childProperties     = typeAccessor.GetMembers<PropertyInfo>();
+        var typeAccessor        = TypeAccessorCache.GetTypeAccessor(propertyAccessor.Type);
 
         ValidateModel(
-          propertyType,
-          childProperties,
+          typeAccessor,
           contentTypeDescriptor,
           configuration.AttributePrefix
         );
@@ -194,7 +186,7 @@ static internal void ValidateProperty(
       /*------------------------------------------------------------------------------------------------------------------------
       | Define list type (if it's a list)
       \-----------------------------------------------------------------------------------------------------------------------*/
-      foreach (var type in configuration.Property.PropertyType.GetInterfaces()) {
+      foreach (var type in propertyAccessor.Type.GetInterfaces()) {
         if (type.IsGenericType && typeof(IList<>) == type.GetGenericTypeDefinition()) {
           //Uses last argument in case it's a KeyedCollection; in that case, we want the TItem type
           listType = type.GetGenericArguments().Last();
@@ -232,7 +224,7 @@ static internal void ValidateProperty(
         throw new MappingModelValidationException(
           $"A '{nameof(sourceType)}' object was provided with a content type set to '{contentTypeDescriptor.Key}'. This " +
           $"content type does not contain an attribute named '{compositeAttributeKey}', as requested by the " +
-          $"'{configuration.Property.Name}' property. If this property is not intended to be mapped by the " +
+          $"'{propertyAccessor.Name}' property. If this property is not intended to be mapped by the " +
           $"{nameof(ReverseTopicMappingService)}, then it should be decorated with {nameof(DisableMappingAttribute)}."
         );
       }
@@ -252,7 +244,7 @@ attributeDescriptor.ModelType is ModelType.NestedTopic &&
         !typeof(ITopicBindingModel).IsAssignableFrom(listType)
       ) {
         throw new MappingModelValidationException(
-          $"The '{property.Name}' property on the '{sourceType.Name}' class has been determined to be a " +
+          $"The '{propertyAccessor.Name}' property on the '{sourceType.Name}' class has been determined to be a " +
           $"{configuration.CollectionType}, but the generic type '{listType.Name}' does not implement the " +
           $"{nameof(ITopicBindingModel)} interface. This is required for binding models. If this collection is not intended " +
           $"to be mapped as a {ModelType.NestedTopic} then update the definition in the associated " +
@@ -266,11 +258,11 @@ attributeDescriptor.ModelType is ModelType.NestedTopic &&
       \-----------------------------------------------------------------------------------------------------------------------*/
       if (
         attributeDescriptor.ModelType is ModelType.Reference &&
-        !typeof(IAssociatedTopicBindingModel).IsAssignableFrom(propertyType)
+        !typeof(IAssociatedTopicBindingModel).IsAssignableFrom(propertyAccessor.Type)
       ) {
         throw new MappingModelValidationException(
-          $"The '{property.Name}' property on the '{sourceType.Name}' class has been determined to be a " +
-          $"{ModelType.Reference}, but the generic type '{propertyType.Name}' does not implement the " +
+          $"The '{propertyAccessor.Name}' property on the '{sourceType.Name}' class has been determined to be a " +
+          $"{ModelType.Reference}, but the generic type '{propertyAccessor.Type.Name}' does not implement the " +
           $"{nameof(IAssociatedTopicBindingModel)} interface. This is required for references. If this property is not " +
           $"intended to be mapped as a {ModelType.Reference} then update the definition in the associated " +
           $"{nameof(ContentTypeDescriptor)}. If this property is not intended to be mapped at all, include the " +
@@ -314,12 +306,12 @@ [DisallowNull]Type                   listType
       /*------------------------------------------------------------------------------------------------------------------------
       | Define variables
       \-----------------------------------------------------------------------------------------------------------------------*/
-      var property              = configuration.Property;
+      var property              = configuration.MemberAccessor;
 
       /*------------------------------------------------------------------------------------------------------------------------
       | Validate list
       \-----------------------------------------------------------------------------------------------------------------------*/
-      if (!typeof(IList).IsAssignableFrom(property.PropertyType)) {
+      if (!typeof(IList).IsAssignableFrom(property.Type)) {
         throw new MappingModelValidationException(
           $"The '{property.Name}' property on the '{sourceType.Name}' class maps to a relationship attribute " +
           $"'{attributeDescriptor.Key}', but does not implement {nameof(IList)}. Relationships must implement " +

OnTopic/Mapping/Reverse/ReverseTopicMappingService.cs

@@ -196,10 +196,9 @@ public ReverseTopicMappingService(ITopicRepository topicRepository) {
       | Validate model
       \-----------------------------------------------------------------------------------------------------------------------*/
       var typeAccessor          = TypeAccessorCache.GetTypeAccessor(source.GetType());
-      var properties            = typeAccessor.GetMembers<PropertyInfo>();
       var contentTypeDescriptor = _contentTypeDescriptors.GetValue(target.ContentType);
 
-      BindingModelValidator.ValidateModel(source.GetType(), properties, contentTypeDescriptor, attributePrefix);
+      BindingModelValidator.ValidateModel(typeAccessor, contentTypeDescriptor, attributePrefix);
 
       /*------------------------------------------------------------------------------------------------------------------------
       | Loop through properties, mapping each one