diff --git a/src/LinqToDB.Include.Tests/LinqToDB.Include.Tests/TestModel/Person.cs b/src/LinqToDB.Include.Tests/LinqToDB.Include.Tests/TestModel/Person.cs
index bc4e74a..fb1cd7f 100644
--- a/src/LinqToDB.Include.Tests/LinqToDB.Include.Tests/TestModel/Person.cs
+++ b/src/LinqToDB.Include.Tests/LinqToDB.Include.Tests/TestModel/Person.cs
@@ -18,7 +18,7 @@ public class Person
         public int? SpouseId { get; set; }
         public Person Spouse { get; set; }
 
-        public List<Order> Orders { get; set; } = new List<Order>();
+        public IEnumerable<Order> Orders { get; set; } = new List<Order>();
 
         public static Expression<Func<Person, Order, bool>> ExtraJoinOptions() => (p, o) => o.OrderId < 99;        
     }
diff --git a/src/LinqToDB.Include/Accessors/IPropertyAccessor.cs b/src/LinqToDB.Include/Accessors/IPropertyAccessor.cs
index 0ae1aa5..7abadf8 100644
--- a/src/LinqToDB.Include/Accessors/IPropertyAccessor.cs
+++ b/src/LinqToDB.Include/Accessors/IPropertyAccessor.cs
@@ -10,7 +10,7 @@ interface IPropertyAccessor
         Type MemberEntityType { get; }
         HashSet<IPropertyAccessor> Properties { get; }
         string PropertyName { get; }
-        bool IsMemberTypeICollection { get; }
+        bool IsMemberTypeIEnumerable { get; }
 
 
         IPropertyAccessor FindAccessor(List<string> pathParts);
diff --git a/src/LinqToDB.Include/Accessors/PropertyAccessor.cs b/src/LinqToDB.Include/Accessors/PropertyAccessor.cs
index dc5274c..f499dba 100644
--- a/src/LinqToDB.Include/Accessors/PropertyAccessor.cs
+++ b/src/LinqToDB.Include/Accessors/PropertyAccessor.cs
@@ -18,7 +18,7 @@ public PropertyAccessor(MemberExpression exp, MappingSchema mappingSchema)
             _declaringType = exp.Member.DeclaringType;
             _memberType = exp.Type;
             _memberEntityType = typeof(TProperty);
-            _isMemberTypeICollection = _memberType.IsICollection();
+            _isMemberTypeIEnumerable = _memberType.IsIEnumerable();
             _isMemberEntityTypeIEnumerable = _memberEntityType.IsIEnumerable();
 
             ChildEntityDescriptor = mappingSchema.GetEntityDescriptor(_memberEntityType);
diff --git a/src/LinqToDB.Include/Accessors/PropertyAccessorAbstract.cs b/src/LinqToDB.Include/Accessors/PropertyAccessorAbstract.cs
index f38fafb..e6cc9af 100644
--- a/src/LinqToDB.Include/Accessors/PropertyAccessorAbstract.cs
+++ b/src/LinqToDB.Include/Accessors/PropertyAccessorAbstract.cs
@@ -11,7 +11,7 @@ abstract class PropertyAccessor<TClass> : IPropertyAccessor<TClass> where TClass
         protected Type _declaringType;
         protected Type _memberType;
         protected Type _memberEntityType;
-        protected bool _isMemberTypeICollection;
+        protected bool _isMemberTypeIEnumerable;
         protected bool _isMemberEntityTypeIEnumerable;
 
         internal abstract void Load(List<TClass> entities, IQueryable<TClass> query);
@@ -21,7 +21,7 @@ abstract class PropertyAccessor<TClass> : IPropertyAccessor<TClass> where TClass
         public Type MemberType { get => _memberType; }
         public Type MemberEntityType { get => _memberEntityType; }
 
-        public bool IsMemberTypeICollection { get => _isMemberTypeICollection; }
+        public bool IsMemberTypeIEnumerable { get => _isMemberTypeIEnumerable; }
         public bool IsMemberEntityTypeIEnumerable { get => _isMemberEntityTypeIEnumerable; }
 
         public abstract HashSet<IPropertyAccessor> Properties { get; }
diff --git a/src/LinqToDB.Include/ReflectionExtensions.cs b/src/LinqToDB.Include/ReflectionExtensions.cs
index 8200f86..204223e 100644
--- a/src/LinqToDB.Include/ReflectionExtensions.cs
+++ b/src/LinqToDB.Include/ReflectionExtensions.cs
@@ -28,25 +28,6 @@ internal static Type GetTypeToUse(this Type type)
         }
 
         internal static bool IsIEnumerable(this Type type)
-        {
-            if (type.IsGenericType)
-            {
-                if (type.IsInterface)
-                {
-                    return type.GetGenericTypeDefinition().GetInterfaces()
-                                .Any(x => x.GetGenericTypeDefinition() == typeof(IEnumerable<>));                    
-                }
-
-                var genericTypeDefinition = type.GetGenericTypeDefinition();
-
-                return genericTypeDefinition.GetInterfaces()
-                            .Any(t => t.IsGenericType && t.GetGenericTypeDefinition() == typeof(IEnumerable<>));
-            }
-
-            return false;
-        }
-
-        internal static bool IsICollection(this Type type)
         {
             if (type.IsGenericType)
             {
@@ -54,19 +35,19 @@ internal static bool IsICollection(this Type type)
                 {
                     var def = type.GetGenericTypeDefinition();
 
-                    return def == typeof(ICollection<>) ||
-                        def.GetInterfaces().Any(x => x.GetGenericTypeDefinition() == typeof(ICollection<>));
+                    return def == typeof(IEnumerable<>) || type.GetGenericTypeDefinition().GetInterfaces()
+                                .Any(x => x.GetGenericTypeDefinition() == typeof(IEnumerable<>));                    
                 }
 
                 var genericTypeDefinition = type.GetGenericTypeDefinition();
 
                 return genericTypeDefinition.GetInterfaces()
-                            .Any(t => t.IsGenericType && t.GetGenericTypeDefinition() == typeof(ICollection<>));
+                            .Any(t => t.IsGenericType && t.GetGenericTypeDefinition() == typeof(IEnumerable<>));
             }
 
             return false;
         }
-
+        
         internal static Action<TElement, TValue> CreatePropertySetter<TElement, TValue>(
             this Type elementType, string propertyName)
         {
@@ -81,38 +62,16 @@ internal static Action<TElement, TValue> CreatePropertySetter<TElement, TValue>(
             return action.Compile();
         }
 
-        [Obsolete]
-        internal static Action<TElement, ICollection<TValue>> CreateICollectionPropertySetter<TElement, TValue>(
-            this Type elementType, string propertyName)
-        {
-            var pi = elementType.GetProperty(propertyName, BindingFlags.Public | BindingFlags.Instance);
-            var mi = pi.GetSetMethod();
-
-            var oParam = Expression.Parameter(elementType, "obj");
-            var vParam = Expression.Parameter(typeof(ICollection<TValue>), "val");
-            var mce = Expression.Call(oParam, mi, vParam);
-
-            var clearMethod = Expression.Call(vParam, typeof(ICollection<TValue>).GetMethod("Clear"));
-            var ifCriteria = Expression.Equal(Expression.Call(oParam, pi.GetGetMethod()), Expression.Constant(null));
-            var ifnullSetter = Expression.IfThenElse(ifCriteria, mce, clearMethod);
-
-            var action = Expression.Lambda<Action<TElement, ICollection<TValue>>>(ifnullSetter, oParam, vParam);
-
-            return action.Compile();
-        }
-
-        
-
         internal static Action<TElement, TValue> CreateCollectionPropertySetter<TElement, TValue>(
                 this Type elementType, string propertyName, Type propertyType)
         {
-            var pi = elementType.GetProperty(propertyName, BindingFlags.Public | BindingFlags.Instance);            
-            var mi = pi.GetSetMethod();
-
             var oParam = Expression.Parameter(elementType, "obj");
             var vParam = Expression.Parameter(typeof(TValue), "val");
-            var mce = Expression.Call(Expression.Property(oParam, propertyName), 
-                            typeof(ICollection<TValue>).GetMethod("Add"), vParam);
+            var mce = Expression.Call(
+                            Expression.Convert(
+                                Expression.Property(oParam, propertyName)
+                            , typeof(ICollection<TValue>))
+                      , typeof(ICollection<TValue>).GetMethod("Add"), vParam);
 
             var action = Expression.Lambda<Action<TElement, TValue>>(mce, oParam, vParam);
 
@@ -153,9 +112,7 @@ internal static Action<TParent> CreatePropertySetup<TParent, TChild>(this Type i
             var mi = pi.GetSetMethod();
             var mce = Expression.Call(parentParam, mi, newCollection);
             
-            var @if = Expression.IfThenElse(isParamNull,
-                mce,
-                Expression.Call(property, typeof(ICollection<TChild>).GetMethod(nameof(ICollection<int>.Clear))));
+            var @if = Expression.IfThen(isParamNull, mce);
 
             var finalCode = Expression.Lambda<Action<TParent>>(@if, parentParam);
 
@@ -183,7 +140,7 @@ private static Type GetTypeToCreate(Type type)
                 {
                     typeNum = 2;
                 }
-                else if (def == typeof(ICollection<>))
+                else if (def == typeof(ICollection<>) || def == typeof(IEnumerable<>))
                 {
                     typeNum = 3;
                 }
diff --git a/src/LinqToDB.Include/Setters/EntityPropertySetter.cs b/src/LinqToDB.Include/Setters/EntityPropertySetter.cs
index 26b1dd4..58fd9f9 100644
--- a/src/LinqToDB.Include/Setters/EntityPropertySetter.cs
+++ b/src/LinqToDB.Include/Setters/EntityPropertySetter.cs
@@ -109,7 +109,7 @@ private static void MatchEntityLookup<TParent, TChild>(PropertyAccessor<TParent,
             where TParent : class
             where TChild : class
         {
-            if (schema.IsMemberTypeICollection)
+            if (schema.IsMemberTypeIEnumerable)
             {
                 var setter = schema.DeclaringType.CreateCollectionPropertySetter<TParent, TChild>(schema.PropertyName,
                     schema.MemberType);
@@ -146,7 +146,7 @@ private static void MatchEntityList<TParent, TChild>(PropertyAccessor<TParent, T
             where TParent : class
             where TChild : class
         {
-            if (schema.IsMemberTypeICollection)
+            if (schema.IsMemberTypeIEnumerable)
             {
                 var setter = schema.DeclaringType.CreateCollectionPropertySetter<TParent, TChild>(schema.PropertyName,
                     schema.MemberType);
diff --git a/src/LinqToDB.Include/Visitors/PropertyVisitor.cs b/src/LinqToDB.Include/Visitors/PropertyVisitor.cs
index a9c52c4..7ad9dee 100644
--- a/src/LinqToDB.Include/Visitors/PropertyVisitor.cs
+++ b/src/LinqToDB.Include/Visitors/PropertyVisitor.cs
@@ -15,11 +15,11 @@ internal PropertyVisitor(IRootAccessor<TClass> rootAccessor)
         {
             _rootAccessor = rootAccessor;
         }
-        
+
         private static void AddFilterForDynamicType<T, TProperty>(IPropertyAccessor<T> accessor,
-    Expression<Func<TProperty, bool>> includeFilter)
-    where T : class
-    where TProperty : class
+                Expression<Func<TProperty, bool>> includeFilter)
+                where T : class
+                where TProperty : class
         {
             var accessorImpl = accessor as PropertyAccessor<T, TProperty>;
             if (accessorImpl == null)
@@ -29,7 +29,7 @@ private static void AddFilterForDynamicType<T, TProperty>(IPropertyAccessor<T> a
             accessorImpl.AddFilter(includeFilter);
         }
 
-        public IRootAccessor<TClass> MapProperties<TProperty>(Expression<Func<TClass, TProperty>> expr, 
+        public IRootAccessor<TClass> MapProperties<TProperty>(Expression<Func<TClass, TProperty>> expr,
             Expression<Func<TProperty, bool>> includeFilter = null)
             where TProperty : class
         {
@@ -41,7 +41,7 @@ public IRootAccessor<TClass> MapProperties<TProperty>(Expression<Func<TClass, TP
             {
                 _rootAccessor.Properties.Add(accessor);
             }
-            
+
             if (includeFilter != null)
             {
                 if (latestAccessor is PropertyAccessor<TClass, TProperty> accessorImpl)
@@ -53,8 +53,8 @@ public IRootAccessor<TClass> MapProperties<TProperty>(Expression<Func<TClass, TP
                     //can type checking be added here?
                     var propertyAccessor = _rootAccessor.GetByPath(PathWalker.GetPath(expr));
                     dynamic dynamicAccessor = propertyAccessor;
-                    AddFilterForDynamicType(dynamicAccessor, includeFilter);                    
-                }                
+                    AddFilterForDynamicType(dynamicAccessor, includeFilter);
+                }
             }
 
             return _rootAccessor;
@@ -99,7 +99,7 @@ private IPropertyAccessor CreateAccessor(MemberExpression node)
             var declaringType = GetTypeToUse(node.Member.DeclaringType);
             var nodeType = GetTypeToUse(node.Type);
 
-            if (latestAccessor != null && latestAccessor.DeclaringType == declaringType && 
+            if (latestAccessor != null && latestAccessor.DeclaringType == declaringType &&
                 latestAccessor.PropertyName == node.Member.Name)
             {
                 return latestAccessor;
@@ -125,9 +125,9 @@ internal static Type GetTypeToUse(Type type)
             {
                 var genericTypeDefinition = type.GetGenericTypeDefinition();
 
-                if (genericTypeDefinition.GetInterfaces()
-                            .Any(t => t.IsGenericType &&
-                                      t.GetGenericTypeDefinition() == typeof(IEnumerable<>)))
+                if (genericTypeDefinition == typeof(IEnumerable<>) ||
+                    genericTypeDefinition.GetInterfaces().Any(t => t.IsGenericType &&
+                                                t.GetGenericTypeDefinition() == typeof(IEnumerable<>)))
                 {
                     return type.GetGenericArguments()[0];
                 }