Cleanup around type helpers

Author: Bart Koelman

src/Examples/JsonApiDotNetCoreExample/Models/Article.cs

@@ -20,7 +20,7 @@ public sealed class Article : Identifiable
 
         [NotMapped]
         [HasManyThrough(nameof(IdentifiableArticleTags))]
-        public ISet<Tag> IdentifiableTags { get; set; }
-        public ISet<IdentifiableArticleTag> IdentifiableArticleTags { get; set; }
+        public ICollection<Tag> IdentifiableTags { get; set; }
+        public ICollection<IdentifiableArticleTag> IdentifiableArticleTags { get; set; }
     }
 }

src/JsonApiDotNetCore/Builders/ResourceGraphBuilder.cs

@@ -57,7 +57,7 @@ public IResourceGraphBuilder AddResource(Type resourceType, Type idType = null,
         {
             if (_resources.All(e => e.ResourceType != resourceType))
             {
-                if (resourceType.Implements<IIdentifiable>())
+                if (resourceType.IsOrImplementsInterface(typeof(IIdentifiable)))
                 {
                     pluralizedTypeName ??= FormatResourceName(resourceType);
                     idType ??= TypeLocator.GetIdType(resourceType);
@@ -182,7 +182,7 @@ private static Type TryGetThroughType(PropertyInfo throughProperty)
                 if (typeArguments.Length == 1)
                 {
                     var constructedThroughType = typeof(ICollection<>).MakeGenericType(typeArguments[0]);
-                    if (throughProperty.PropertyType.Implements(constructedThroughType))
+                    if (throughProperty.PropertyType.IsOrImplementsInterface(constructedThroughType))
                     {
                         return typeArguments[0];
                     }

src/JsonApiDotNetCore/Data/DefaultResourceRepository.cs

@@ -159,7 +159,7 @@ private bool IsHasOneRelationship(string internalRelationshipName, Type type)
             }
             // relationshipAttr is null when we don't put a [RelationshipAttribute] on the inverse navigation property.
             // In this case we use reflection to figure out what kind of relationship is pointing back.
-            return !type.GetProperty(internalRelationshipName).PropertyType.Inherits(typeof(IEnumerable));
+            return !type.GetProperty(internalRelationshipName).PropertyType.IsOrImplementsInterface(typeof(IEnumerable));
         }
 
         private void DetachRelationships(TResource entity)

src/JsonApiDotNetCore/Extensions/QueryableExtensions.cs

@@ -206,8 +206,10 @@ private static IQueryable<TSource> CallGenericWhereContainsMethod<TSource>(IQuer
                 member = Expression.Property(entity, filter.Attribute.PropertyInfo.Name);
 
             var method = ContainsMethod.MakeGenericMethod(member.Type);
-            
-            var list = TypeHelper.CreateListFor(member.Type);
+
+            var listType = typeof(List<>).MakeGenericType(member.Type);
+            var list = (IList)TypeHelper.CreateInstance(listType);
+
             foreach (var value in propertyValues)
             {
                 object targetType;

src/JsonApiDotNetCore/Extensions/TypeExtensions.cs

@@ -16,10 +16,10 @@ internal static class TypeExtensions
         /// ((IList)myList).CopyToList(targetType).
         /// </code>
         /// </summary>
-        public static IList CopyToList(this IEnumerable source, Type type)
+        public static IList CopyToList(this IEnumerable copyFrom, Type elementType)
         {
-            Type collectionType = typeof(List<>).MakeGenericType(type);
-            return (IList)CopyToTypedCollection(source, collectionType);
+            Type collectionType = typeof(List<>).MakeGenericType(elementType);
+            return (IList)CopyToTypedCollection(copyFrom, collectionType);
         }
 
         /// <summary>
@@ -34,7 +34,7 @@ public static IEnumerable CopyToTypedCollection(this IEnumerable source, Type co
             if (collectionType == null) throw new ArgumentNullException(nameof(collectionType));
 
             var concreteCollectionType = collectionType.ToConcreteCollectionType();
-            dynamic concreteCollectionInstance = concreteCollectionType.New<dynamic>();
+            dynamic concreteCollectionInstance = TypeHelper.CreateInstance(concreteCollectionType);
 
             foreach (var item in source)
             {
@@ -44,80 +44,29 @@ public static IEnumerable CopyToTypedCollection(this IEnumerable source, Type co
             return concreteCollectionInstance;
         }
 
-        /// <summary>
-        /// Creates a List{TInterface} where TInterface is the generic for type specified by t
-        /// </summary>
-        public static IEnumerable GetEmptyCollection(this Type t)
-        {
-            if (t == null) throw new ArgumentNullException(nameof(t));
-
-            var listType = typeof(List<>).MakeGenericType(t);
-            var list = (IEnumerable)CreateNewInstance(listType);
-            return list;
-        }
-
         public static string GetResourceStringId<TResource, TId>(TId id) where TResource : class, IIdentifiable<TId>
         {
-            var tempResource = typeof(TResource).New<TResource>();
+            var tempResource = TypeHelper.CreateInstance<TResource>();
             tempResource.Id = id;
             return tempResource.StringId;
         }
 
-        public static object New(this Type t)
-        {
-            return New<object>(t);
-        }
-
         /// <summary>
-        /// Creates a new instance of type t, casting it to the specified type.
+        /// Whether the specified source type implements or equals the specified interface.
         /// </summary>
-        public static T New<T>(this Type t)
+        public static bool IsOrImplementsInterface(this Type source, Type interfaceType)
         {
-            if (t == null) throw new ArgumentNullException(nameof(t));
-
-            var instance = (T)CreateNewInstance(t);
-            return instance;
-        }
-
-        private static object CreateNewInstance(Type type)
-        {
-            try
+            if (interfaceType == null)
             {
-                return Activator.CreateInstance(type);
+                throw new ArgumentNullException(nameof(interfaceType));
             }
-            catch (Exception exception)
+
+            if (source == null)
             {
-                throw new InvalidOperationException($"Failed to create an instance of '{type.FullName}' using its default constructor.", exception);
+                return false;
             }
-        }
-
-        /// <summary>
-        /// Whether or not a type implements an interface.
-        /// </summary>
-        public static bool Implements<T>(this Type concreteType) 
-            => Implements(concreteType, typeof(T));
-
-        /// <summary>
-        /// Whether or not a type implements an interface.
-        /// </summary>
-        public static bool Implements(this Type concreteType, Type interfaceType) 
-            => interfaceType?.IsAssignableFrom(concreteType) == true;
 
-        /// <summary>
-        /// Whether or not a type inherits a base type.
-        /// </summary>
-        public static bool Inherits<T>(this Type concreteType) 
-            => Inherits(concreteType, typeof(T));
-
-        /// <summary>
-        /// Whether or not a type inherits a base type.
-        /// </summary>
-        public static bool Inherits(this Type concreteType, Type interfaceType) 
-            => interfaceType?.IsAssignableFrom(concreteType) == true;
-
-        public static bool ImplementsInterface(this Type source, Type interfaceType)
-        {
-            return source.GetInterfaces().Any(type => type == interfaceType);
+            return source == interfaceType || source.GetInterfaces().Any(type => type == interfaceType);
         }
     }
 }

src/JsonApiDotNetCore/Graph/TypeLocator.cs

@@ -29,7 +29,7 @@ public static Type GetIdType(Type resourceType)
         /// </returns>
         internal static bool TryGetResourceDescriptor(Type type, out ResourceDescriptor descriptor)
         {
-            if (type.Implements<IIdentifiable>())
+            if (type.IsOrImplementsInterface(typeof(IIdentifiable)))
             {
                 descriptor = new ResourceDescriptor(type, GetIdType(type));
                 return true;

src/JsonApiDotNetCore/Hooks/Execution/DiffableEntityHashSet.cs

@@ -75,12 +75,12 @@ public IEnumerable<EntityDiffPair<TResource>> GetDiffs()
         {
             var propertyInfo = TypeHelper.ParseNavigationExpression(navigationAction);
             var propertyType = propertyInfo.PropertyType;
-            if (propertyType.ImplementsInterface(typeof(IEnumerable)))
+            if (propertyType.IsOrImplementsInterface(typeof(IEnumerable)))
             {
                 propertyType = TypeHelper.TryGetCollectionElementType(propertyType);
             }
 
-            if (propertyType.Implements<IIdentifiable>())
+            if (propertyType.IsOrImplementsInterface(typeof(IIdentifiable)))
             {
                 // the navigation action references a relationship. Redirect the call to the relationship dictionary. 
                 return base.GetAffected(navigationAction);

src/JsonApiDotNetCore/Hooks/Traversal/TraversalHelper.cs

@@ -264,7 +264,7 @@ private HashSet<TResource> UniqueInTree<TResource>(IEnumerable<TResource> entiti
         /// <param name="attr">Relationship attribute</param>
         private RightType GetRightTypeFromRelationship(RelationshipAttribute attr)
         {
-            if (attr is HasManyThroughAttribute throughAttr && throughAttr.ThroughType.Inherits(typeof(IIdentifiable)))
+            if (attr is HasManyThroughAttribute throughAttr && throughAttr.ThroughType.IsOrImplementsInterface(typeof(IIdentifiable)))
             {
                 return throughAttr.ThroughType;
             }

src/JsonApiDotNetCore/Internal/DefaultRoutingConvention.cs

@@ -128,15 +128,14 @@ private Type GetResourceTypeFromController(Type type)
             var controllerBase = typeof(ControllerBase);
             var jsonApiMixin = typeof(JsonApiControllerMixin);
             var target = typeof(BaseJsonApiController<,>);
-            var identifiable = typeof(IIdentifiable);
             var currentBaseType = type;
             while (!currentBaseType.IsGenericType || currentBaseType.GetGenericTypeDefinition() != target)
             {
                 var nextBaseType = currentBaseType.BaseType;
 
                 if ( (nextBaseType == controllerBase || nextBaseType == jsonApiMixin) && currentBaseType.IsGenericType)
                 {
-                    var potentialResource = currentBaseType.GetGenericArguments().FirstOrDefault(t => t.Inherits(identifiable));
+                    var potentialResource = currentBaseType.GetGenericArguments().FirstOrDefault(t => t.IsOrImplementsInterface(typeof(IIdentifiable)));
                     if (potentialResource != null)
                     {
                         return potentialResource;

src/JsonApiDotNetCore/Internal/Generics/RepositoryRelationshipUpdateHelper.cs

@@ -74,7 +74,7 @@ private async Task UpdateOneToManyAsync(IIdentifiable parent, RelationshipAttrib
             if (!relationshipIds.Any())
             {
                 var collectionType = relationship.PropertyInfo.PropertyType.ToConcreteCollectionType();
-                value = collectionType.New<IEnumerable>();
+                value = (IEnumerable)TypeHelper.CreateInstance(collectionType);
             }
             else
             {
@@ -123,7 +123,7 @@ private async Task UpdateManyToManyAsync(IIdentifiable parent, HasManyThroughAtt
 
             var newLinks = relationshipIds.Select(x =>
             {
-                var link = relationship.ThroughType.New();
+                var link = TypeHelper.CreateInstance(relationship.ThroughType);
                 relationship.LeftIdProperty.SetValue(link, TypeHelper.ConvertType(parentId, relationship.LeftIdProperty.PropertyType));
                 relationship.RightIdProperty.SetValue(link, TypeHelper.ConvertType(x, relationship.RightIdProperty.PropertyType));
                 return link;