Moved IsList and IsConvertible to ItemMetadata properties

With `ItemMetadata` incorporated into `ItemConfiguration`, any method which relies on `ItemConfiguration` or `PropertyConfiguration` now has access to metadata that's shared between parameters (via `ParameterMetadata`) or methods or properties (via `MemberAccessor`). Given that, we can move `IsList()` to `ItemMetadata`, and cache the values of both `IsList` and `IsConvertible` via properties on `ItemMetadata`.

This is useful as it means we can evaluate these once upfront, instead of evaluating them each time we evaluate a property. These lookups were pretty cheap—they primarily involve a `Contains()` check on a `List<Type>`—but needing to do this at least once for every property during `MapAsync()` adds some overhead. Since we already have a cache of `ItemMetadata` via `TypeAccessor` (and the `TypeAccessorCache`), it's easy to include that in the cached metadata.

Author: JeremyCaney

OnTopic/Internal/Reflection/ItemMetadata.cs

@@ -23,6 +23,19 @@ internal abstract class ItemMetadata {
     private readonly static     List<Type>                      _listTypes                      = new();
     private readonly            ICustomAttributeProvider        _attributeProvider;
     private readonly            Type                            _type                           = default!;
+    private                     List<Attribute>                 _customAttributes               = default!;
+
+    /*==========================================================================================================================
+    | CONSTRUCTOR
+    \-------------------------------------------------------------------------------------------------------------------------*/
+    /// <summary>
+    ///   Establishes a new instance of a <see cref="ItemMetadata"/> with required dependencies.
+    /// </summary>
+    static ItemMetadata() {
+      _listTypes.Add(typeof(IEnumerable<>));
+      _listTypes.Add(typeof(ICollection<>));
+      _listTypes.Add(typeof(IList<>));
+    }
 
     /*==========================================================================================================================
     | CONSTRUCTOR
@@ -101,6 +114,23 @@ bool isList()
     /// </remarks>
     internal bool IsNullable { get; init; }
 
+    /*==========================================================================================================================
+    | IS LIST?
+    \-------------------------------------------------------------------------------------------------------------------------*/
+    /// <summary>
+    ///   Determine if the member is a <see cref="IList"/>, <see cref="IList{T}"/>, <see cref="IEnumerable{T}"/>, or <see cref="
+    ///   ICollection{T}"/>.
+    /// </summary>
+    internal bool IsList { get; init; }
+
+    /*==========================================================================================================================
+    | IS CONVERTIBLE?
+    \-------------------------------------------------------------------------------------------------------------------------*/
+    /// <summary>
+    ///   Determine if the member is of a type that can be converted using the <see cref="AttributeValueConverter"/> class.
+    /// </summary>
+    internal bool IsConvertible { get; init; }
+
     /*==========================================================================================================================
     | CUSTOM ATTRIBUTES
     \-------------------------------------------------------------------------------------------------------------------------*/

OnTopic/Mapping/TopicMappingService.cs

@@ -30,19 +30,6 @@ public class TopicMappingService : ITopicMappingService {
     \-------------------------------------------------------------------------------------------------------------------------*/
     readonly                    ITopicRepository                _topicRepository;
     readonly                    ITypeLookupService              _typeLookupService;
-    static readonly             List<Type>                      _listTypes                      = new();
-
-    /*==========================================================================================================================
-    | CONSTRUCTOR
-    \-------------------------------------------------------------------------------------------------------------------------*/
-    /// <summary>
-    ///   Establishes a new instance of a <see cref="TopicMappingService"/> with required dependencies.
-    /// </summary>
-    static TopicMappingService() {
-      _listTypes.Add(typeof(IEnumerable<>));
-      _listTypes.Add(typeof(ICollection<>));
-      _listTypes.Add(typeof(IList<>));
-    }
 
     /*==========================================================================================================================
     | CONSTRUCTOR
@@ -404,7 +391,7 @@ private async Task<object> MapAsync(
       \-----------------------------------------------------------------------------------------------------------------------*/
       var value = await GetValue(source, parameter.Type, associations, configuration, cache, false).ConfigureAwait(false);
 
-      if (value is null && IsList(parameter.Type)) {
+      if (value is null && parameter.IsList) {
         return await getList(parameter.Type, configuration).ConfigureAwait(false);
       }
 
@@ -487,7 +474,7 @@ await MapAsync(
       \-----------------------------------------------------------------------------------------------------------------------*/
       else {
         var value = await GetValue(source, propertyAccessor.Type, associations, configuration, cache, mapAssociationsOnly).ConfigureAwait(false);
-        if (value is null && IsList(propertyAccessor.Type)) {
+        if (value is null && propertyAccessor.IsList) {
           await SetCollectionValueAsync(source, target, associations, configuration, cache).ConfigureAwait(false);
         }
         else if (value != null && propertyAccessor.CanWrite) {
@@ -545,12 +532,12 @@ await MapAsync(
           value = await GetTopicReferenceAsync(source.Parent, targetType, configuration, cache).ConfigureAwait(false);
         }
       }
-      else if (AttributeValueConverter.IsConvertible(targetType)) {
+      else if (configuration.Metadata.IsConvertible) {
         if (!mapAssociationsOnly) {
           value = GetScalarValue(source, configuration);
         }
       }
-      else if (IsList(targetType)) {
+      else if (configuration.Metadata.IsList) {
         return null;
       }
       else if (associations.HasFlag(AssociationTypes.References)) {
@@ -641,33 +628,6 @@ await MapAsync(
 
     }
 
-    /*==========================================================================================================================
-    | PRIVATE: IS LIST?
-    \-------------------------------------------------------------------------------------------------------------------------*/
-    /// <summary>
-    ///   Given a type, determines whether it's a list that is recognized by the <see cref="TopicMappingService"/>.
-    /// </summary>
-    /// <remarks>
-    ///   <para>
-    ///     To qualify, the <paramref name="targetType"/> must either implement <see cref="IList"/>, or it must be of type <see
-    ///     cref="IEnumerable{T}"/>, <see cref="ICollection{T}"/>, or <see cref="IList{T}"/>—any of which, if null, will be
-    ///     instantiated as a new <see cref="List{T}"/>.
-    ///   </para>
-    ///   <para>
-    ///     It is technically possible for the <paramref name="targetType"/> to implement one of the interfaces, such as <see
-    ///     cref="IList{T}"/>, while the assigned reference type is not compatible with the <see cref="IList"/> interface
-    ///     required by e.g. <see cref="PopulateTargetCollectionAsync(IList{Topic}, IList, ItemConfiguration, MappedTopicCache)"
-    ///     />. Detecting this requires looping through the interface implementations which is comparatively more costly given
-    ///     the number of times <see cref="IsList(Type)"/> gets called. In practice, collections that implement e.g. <see cref="
-    ///     IList{T}"/> are expected to also support <see cref="IList"/>. If they don't, however, the mapping will throw an
-    ///     exception since the assigned value will not be castable to an <see cref="IList"/>.
-    ///   </para>
-    /// </remarks>
-    /// <param name="targetType">The <see cref="Type"/> of collection to initialize.</param>
-    private static bool IsList(Type targetType) =>
-      typeof(IList).IsAssignableFrom(targetType) ||
-      targetType.IsGenericType && _listTypes.Contains(targetType.GetGenericTypeDefinition());
-
     /*==========================================================================================================================
     | PRIVATE: INITIALIZE COLLECTION
     \-------------------------------------------------------------------------------------------------------------------------*/