Cleanup around type helpers

Bart Koelman · Bart Koelman · commit 90c24322d003 · 2020-04-29T12:41:33.000+02:00
diff --git a/src/Examples/JsonApiDotNetCoreExample/Models/Article.cs b/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; }
     }
 }
diff --git a/src/JsonApiDotNetCore/Builders/ResourceGraphBuilder.cs b/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];
                     }
diff --git a/src/JsonApiDotNetCore/Data/DefaultResourceRepository.cs b/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)
diff --git a/src/JsonApiDotNetCore/Extensions/QueryableExtensions.cs b/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;
diff --git a/src/JsonApiDotNetCore/Extensions/TypeExtensions.cs b/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);
         }
     }
 }
diff --git a/src/JsonApiDotNetCore/Graph/TypeLocator.cs b/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;
diff --git a/src/JsonApiDotNetCore/Hooks/Execution/DiffableEntityHashSet.cs b/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);
diff --git a/src/JsonApiDotNetCore/Hooks/Traversal/TraversalHelper.cs b/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;
             }
diff --git a/src/JsonApiDotNetCore/Internal/DefaultRoutingConvention.cs b/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;
diff --git a/src/JsonApiDotNetCore/Internal/Generics/RepositoryRelationshipUpdateHelper.cs b/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;
diff --git a/src/JsonApiDotNetCore/Internal/TypeHelper.cs b/src/JsonApiDotNetCore/Internal/TypeHelper.cs
@@ -5,7 +5,6 @@
 using System.Reflection;
 using System.Linq.Expressions;
 using JsonApiDotNetCore.Extensions;
-using JsonApiDotNetCore.Graph;
 using JsonApiDotNetCore.Models;
 
 namespace JsonApiDotNetCore.Internal
@@ -61,7 +60,7 @@ private static bool CanBeNull(Type type)
 
         internal static object GetDefaultValue(this Type type)
         {
-            return type.IsValueType ? type.New() : null;
+            return type.IsValueType ? CreateInstance(type) : null;
         }
 
         public static Type TryGetCollectionElementType(Type type)
@@ -70,7 +69,7 @@ public static Type TryGetCollectionElementType(Type type)
             {
                 if (type.IsGenericType && type.GenericTypeArguments.Length == 1)
                 {
-                    if (type.ImplementsInterface(typeof(IEnumerable)))
+                    if (type.IsOrImplementsInterface(typeof(IEnumerable)))
                     {
                         return type.GenericTypeArguments[0];
                     }
@@ -160,18 +159,6 @@ public static Dictionary<PropertyInfo, HashSet<TValueOut>> ConvertAttributeDicti
             return attributes?.ToDictionary(attr => attr.PropertyInfo, attr => entities);
         }
 
-        /// <summary>
-        /// Use this overload if you need to instantiate a type that has a internal constructor
-        /// </summary>
-        private static object CreateInstanceOfOpenType(Type openType, Type[] parameters, bool hasInternalConstructor, params object[] constructorArguments)
-        {
-            if (!hasInternalConstructor) return CreateInstanceOfOpenType(openType, parameters, constructorArguments);
-            var parameterizedType = openType.MakeGenericType(parameters);
-            // note that if for whatever reason the constructor of AffectedResource is set from
-            // internal to public, this will throw an error, as it is looking for a no
-            return Activator.CreateInstance(parameterizedType, BindingFlags.NonPublic | BindingFlags.Instance, null, constructorArguments, null);
-        }
-
         /// <summary>
         /// Creates an instance of the specified generic type
         /// </summary>
@@ -189,7 +176,12 @@ public static object CreateInstanceOfOpenType(Type openType, Type parameter, par
         /// </summary>
         public static object CreateInstanceOfOpenType(Type openType, Type parameter, bool hasInternalConstructor, params object[] constructorArguments)
         {
-            return CreateInstanceOfOpenType(openType, new[] { parameter }, hasInternalConstructor, constructorArguments);
+            Type[] parameters = { parameter };
+            if (!hasInternalConstructor) return CreateInstanceOfOpenType(openType, parameters, constructorArguments);
+            var parameterizedType = openType.MakeGenericType(parameters);
+            // note that if for whatever reason the constructor of AffectedResource is set from
+            // internal to public, this will throw an error, as it is looking for a no
+            return Activator.CreateInstance(parameterizedType, BindingFlags.NonPublic | BindingFlags.Instance, null, constructorArguments, null);
         }
 
         /// <summary>
@@ -244,5 +236,24 @@ public static Type GetIdType(Type resourceType)
             if (property == null) throw new ArgumentException("Type does not have 'Id' property.");
             return property.PropertyType;
         }
+
+        public static T CreateInstance<T>()
+        {
+            return (T) CreateInstance(typeof(T));
+        }
+
+        public static object CreateInstance(Type type)
+        {
+            if (type == null) throw new ArgumentNullException(nameof(type));
+            
+            try
+            {
+                return Activator.CreateInstance(type);
+            }
+            catch (Exception exception)
+            {
+                throw new InvalidOperationException($"Failed to create an instance of '{type.FullName}' using its default constructor.", exception);
+            }
+        }
     }
 }
diff --git a/src/JsonApiDotNetCore/Models/Annotation/HasManyThroughAttribute.cs b/src/JsonApiDotNetCore/Models/Annotation/HasManyThroughAttribute.cs
@@ -4,6 +4,7 @@
 using System.Linq;
 using System.Reflection;
 using JsonApiDotNetCore.Extensions;
+using JsonApiDotNetCore.Internal;
 using JsonApiDotNetCore.Models.Links;
 
 namespace JsonApiDotNetCore.Models
@@ -98,7 +99,7 @@ public override void SetValue(object entity, object newValue)
                 List<object> joinEntities = new List<object>();
                 foreach (IIdentifiable resource in (IEnumerable)newValue)
                 {
-                    object joinEntity = ThroughType.New();
+                    object joinEntity = TypeHelper.CreateInstance(ThroughType);
                     LeftProperty.SetValue(joinEntity, entity);
                     RightProperty.SetValue(joinEntity, resource);
                     joinEntities.Add(joinEntity);
diff --git a/src/JsonApiDotNetCore/Serialization/Client/ResponseDeserializer.cs b/src/JsonApiDotNetCore/Serialization/Client/ResponseDeserializer.cs
@@ -80,7 +80,7 @@ protected override void AfterProcessField(IIdentifiable entity, IResourceField f
         /// </summary>
         private IIdentifiable ParseIncludedRelationship(RelationshipAttribute relationshipAttr, ResourceIdentifierObject relatedResourceIdentifier)
         {
-            var relatedInstance = relationshipAttr.RightType.New<IIdentifiable>();
+            var relatedInstance = (IIdentifiable)TypeHelper.CreateInstance(relationshipAttr.RightType);
             relatedInstance.StringId = relatedResourceIdentifier.Id;
 
             var includedResource = GetLinkedResource(relatedResourceIdentifier);
diff --git a/src/JsonApiDotNetCore/Serialization/Common/BaseDocumentParser.cs b/src/JsonApiDotNetCore/Serialization/Common/BaseDocumentParser.cs
@@ -1,5 +1,4 @@
 using System;
-using System.Collections;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
@@ -141,7 +140,7 @@ private IIdentifiable ParseResourceObject(ResourceObject data)
                     "If you have manually registered the resource, check that the call to AddResource correctly sets the public name.", null);
             }
 
-            var entity = resourceContext.ResourceType.New<IIdentifiable>();
+            var entity = (IIdentifiable)TypeHelper.CreateInstance(resourceContext.ResourceType);
 
             entity = SetAttributes(entity, data.Attributes, resourceContext.Attributes);
             entity = SetRelationships(entity, data.Relationships, resourceContext.Relationships);
@@ -213,7 +212,7 @@ private void SetNavigation(IIdentifiable entity, HasOneAttribute attr, string re
             }
             else
             {
-                var relatedInstance = attr.RightType.New<IIdentifiable>();
+                var relatedInstance = (IIdentifiable)TypeHelper.CreateInstance(attr.RightType);
                 relatedInstance.StringId = relatedId;
                 attr.SetValue(entity, relatedInstance);
             }
@@ -231,7 +230,7 @@ private void SetHasManyRelationship(
             {   // if the relationship is set to null, no need to set the navigation property to null: this is the default value.
                 var relatedResources = relationshipData.ManyData.Select(rio =>
                 {
-                    var relatedInstance = attr.RightType.New<IIdentifiable>();
+                    var relatedInstance = (IIdentifiable)TypeHelper.CreateInstance(attr.RightType);
                     relatedInstance.StringId = rio.Id;
                     return relatedInstance;
                 });
diff --git a/src/JsonApiDotNetCore/Services/DefaultResourceService.cs b/src/JsonApiDotNetCore/Services/DefaultResourceService.cs
@@ -81,7 +81,7 @@ public virtual async Task DeleteAsync(TId id)
         {
             _logger.LogTrace($"Entering {nameof(DeleteAsync)}('{id}').");
 
-            var entity = typeof(TResource).New<TResource>();
+            var entity = TypeHelper.CreateInstance<TResource>();
             entity.Id = id;
             if (!IsNull(_hookExecutor, entity)) _hookExecutor.BeforeDelete(AsList(entity), ResourcePipeline.Delete);
             
diff --git a/test/UnitTests/Extensions/TypeExtensions_Tests.cs b/test/UnitTests/Extensions/TypeExtensions_Tests.cs

Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ public sealed class Article : Identifiable`
`20`	`20`
`21`	`21`	`[NotMapped]`
`22`	`22`	`[HasManyThrough(nameof(IdentifiableArticleTags))]`
`23`		`- public ISet<Tag> IdentifiableTags { get; set; }`
`24`		`- public ISet<IdentifiableArticleTag> IdentifiableArticleTags { get; set; }`
	`23`	`+ public ICollection<Tag> IdentifiableTags { get; set; }`
	`24`	`+ public ICollection<IdentifiableArticleTag> IdentifiableArticleTags { get; set; }`
`25`	`25`	`}`
`26`	`26`	`}`
Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ public IResourceGraphBuilder AddResource(Type resourceType, Type idType = null,`
`57`	`57`	`{`
`58`	`58`	`if (_resources.All(e => e.ResourceType != resourceType))`
`59`	`59`	`{`
`60`		`- if (resourceType.Implements<IIdentifiable>())`
	`60`	`+ if (resourceType.IsOrImplementsInterface(typeof(IIdentifiable)))`
`61`	`61`	`{`
`62`	`62`	`pluralizedTypeName ??= FormatResourceName(resourceType);`
`63`	`63`	`idType ??= TypeLocator.GetIdType(resourceType);`
`@@ -182,7 +182,7 @@ private static Type TryGetThroughType(PropertyInfo throughProperty)`
`182`	`182`	`if (typeArguments.Length == 1)`
`183`	`183`	`{`
`184`	`184`	`var constructedThroughType = typeof(ICollection<>).MakeGenericType(typeArguments[0]);`
`185`		`- if (throughProperty.PropertyType.Implements(constructedThroughType))`
	`185`	`+ if (throughProperty.PropertyType.IsOrImplementsInterface(constructedThroughType))`
`186`	`186`	`{`
`187`	`187`	`return typeArguments[0];`
`188`	`188`	`}`
Original file line number	Diff line number	Diff line change
`@@ -159,7 +159,7 @@ private bool IsHasOneRelationship(string internalRelationshipName, Type type)`
`159`	`159`	`}`
`160`	`160`	`// relationshipAttr is null when we don't put a [RelationshipAttribute] on the inverse navigation property.`
`161`	`161`	`// In this case we use reflection to figure out what kind of relationship is pointing back.`
`162`		`- return !type.GetProperty(internalRelationshipName).PropertyType.Inherits(typeof(IEnumerable));`
	`162`	`+ return !type.GetProperty(internalRelationshipName).PropertyType.IsOrImplementsInterface(typeof(IEnumerable));`
`163`	`163`	`}`
`164`	`164`
`165`	`165`	`private void DetachRelationships(TResource entity)`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ public static Type GetIdType(Type resourceType)`
`29`	`29`	`/// </returns>`
`30`	`30`	`internal static bool TryGetResourceDescriptor(Type type, out ResourceDescriptor descriptor)`
`31`	`31`	`{`
`32`		`- if (type.Implements<IIdentifiable>())`
	`32`	`+ if (type.IsOrImplementsInterface(typeof(IIdentifiable)))`
`33`	`33`	`{`
`34`	`34`	`descriptor = new ResourceDescriptor(type, GetIdType(type));`
`35`	`35`	`return true;`
Original file line number	Diff line number	Diff line change
`@@ -75,12 +75,12 @@ public IEnumerable<EntityDiffPair<TResource>> GetDiffs()`
`75`	`75`	`{`
`76`	`76`	`var propertyInfo = TypeHelper.ParseNavigationExpression(navigationAction);`
`77`	`77`	`var propertyType = propertyInfo.PropertyType;`
`78`		`- if (propertyType.ImplementsInterface(typeof(IEnumerable)))`
	`78`	`+ if (propertyType.IsOrImplementsInterface(typeof(IEnumerable)))`
`79`	`79`	`{`
`80`	`80`	`propertyType = TypeHelper.TryGetCollectionElementType(propertyType);`
`81`	`81`	`}`
`82`	`82`
`83`		`- if (propertyType.Implements<IIdentifiable>())`
	`83`	`+ if (propertyType.IsOrImplementsInterface(typeof(IIdentifiable)))`
`84`	`84`	`{`
`85`	`85`	`// the navigation action references a relationship. Redirect the call to the relationship dictionary.`
`86`	`86`	`return base.GetAffected(navigationAction);`
Original file line number	Diff line number	Diff line change
`@@ -264,7 +264,7 @@ private HashSet<TResource> UniqueInTree<TResource>(IEnumerable<TResource> entiti`
`264`	`264`	`/// <param name="attr">Relationship attribute</param>`
`265`	`265`	`private RightType GetRightTypeFromRelationship(RelationshipAttribute attr)`
`266`	`266`	`{`
`267`		`- if (attr is HasManyThroughAttribute throughAttr && throughAttr.ThroughType.Inherits(typeof(IIdentifiable)))`
	`267`	`+ if (attr is HasManyThroughAttribute throughAttr && throughAttr.ThroughType.IsOrImplementsInterface(typeof(IIdentifiable)))`
`268`	`268`	`{`
`269`	`269`	`return throughAttr.ThroughType;`
`270`	`270`	`}`
Original file line number	Diff line number	Diff line change
`@@ -128,15 +128,14 @@ private Type GetResourceTypeFromController(Type type)`
`128`	`128`	`var controllerBase = typeof(ControllerBase);`
`129`	`129`	`var jsonApiMixin = typeof(JsonApiControllerMixin);`
`130`	`130`	`var target = typeof(BaseJsonApiController<,>);`
`131`		`- var identifiable = typeof(IIdentifiable);`
`132`	`131`	`var currentBaseType = type;`
`133`	`132`	`while (!currentBaseType.IsGenericType \|\| currentBaseType.GetGenericTypeDefinition() != target)`
`134`	`133`	`{`
`135`	`134`	`var nextBaseType = currentBaseType.BaseType;`
`136`	`135`
`137`	`136`	`if ( (nextBaseType == controllerBase \|\| nextBaseType == jsonApiMixin) && currentBaseType.IsGenericType)`
`138`	`137`	`{`
`139`		`- var potentialResource = currentBaseType.GetGenericArguments().FirstOrDefault(t => t.Inherits(identifiable));`
	`138`	`+ var potentialResource = currentBaseType.GetGenericArguments().FirstOrDefault(t => t.IsOrImplementsInterface(typeof(IIdentifiable)));`
`140`	`139`	`if (potentialResource != null)`
`141`	`140`	`{`
`142`	`141`	`return potentialResource;`
Original file line number	Diff line number	Diff line change
`@@ -74,7 +74,7 @@ private async Task UpdateOneToManyAsync(IIdentifiable parent, RelationshipAttrib`
`74`	`74`	`if (!relationshipIds.Any())`
`75`	`75`	`{`
`76`	`76`	`var collectionType = relationship.PropertyInfo.PropertyType.ToConcreteCollectionType();`
`77`		`- value = collectionType.New<IEnumerable>();`
	`77`	`+ value = (IEnumerable)TypeHelper.CreateInstance(collectionType);`
`78`	`78`	`}`
`79`	`79`	`else`
`80`	`80`	`{`
`@@ -123,7 +123,7 @@ private async Task UpdateManyToManyAsync(IIdentifiable parent, HasManyThroughAtt`
`123`	`123`
`124`	`124`	`var newLinks = relationshipIds.Select(x =>`
`125`	`125`	`{`
`126`		`- var link = relationship.ThroughType.New();`
	`126`	`+ var link = TypeHelper.CreateInstance(relationship.ThroughType);`
`127`	`127`	`relationship.LeftIdProperty.SetValue(link, TypeHelper.ConvertType(parentId, relationship.LeftIdProperty.PropertyType));`
`128`	`128`	`relationship.RightIdProperty.SetValue(link, TypeHelper.ConvertType(x, relationship.RightIdProperty.PropertyType));`
`129`	`129`	`return link;`