LuObjectConverter stuff

.idea/.idea.luticate2/.idea/contentModel.xml

         <e p="Luticate2.Auth.csproj" t="IncludeRecursive" />
         <e p="Utils" t="Include">
           <e p="Business" t="Include">
+            <e p="Converters" t="Include">
+              <e p="LuConvertersAllocator.cs" t="Include" />
+              <e p="LuConvertersOptions.cs" t="Include" />
+              <e p="LuConvertersTypeConverter.cs" t="Include" />
+            </e>
             <e p="Crud" t="Include">
               <e p="LuEfCrudBusiness.cs" t="Include" />
             </e>
             <e p="ExpressionConverter" t="Include">
-              <e p="LuExpressionConverterOptions.cs" t="Include" />
               <e p="LuExpressionConverterVisitor.cs" t="Include" />
               <e p="LuExpressionParamReplaceVisitor.cs" t="Include" />
-              <e p="LuObjectConverterIdentity.cs" t="Include" />
             </e>
             <e p="Fields" t="Include">
               <e p="LuFieldsExtensions.cs" t="Include" />
               <e p="LuPartialFieldsParser.cs" t="Include" />
             </e>
             <e p="ObjectConverter" t="Include">
+              <e p="LuObjectConverterIdentity.cs" t="Include" />
+              <e p="LuObjectConverterLists.cs" t="Include" />
               <e p="LuObjectConverterPoco.cs" t="Include" />
+              <e p="LuObjectConverterUtils.cs" t="Include" />
             </e>
             <e p="ObjectConverterDescriptor" t="Include">
               <e p="LuObjectConverterDescriptor.cs" t="Include" />
             <e p="LuResultException.cs" t="Include" />
           </e>
           <e p="Interfaces" t="Include">
+            <e p="ILuConvertersAllocator.cs" t="Include" />
+            <e p="ILuConvertersTypeConverter.cs" t="Include" />
             <e p="ILuCrud.cs" t="Include" />
             <e p="ILuObjectConverter.cs" t="Include" />
             <e p="ILuObjectConverterDescriptor.cs" t="Include" />
             <e p="LuFieldDboTests.cs" t="Include" />
           </e>
           <e p="ObjectConverter" t="Include">
-            <e p="ObjectConverter.cs" t="Include" />
+            <e p="ObjectConverterTests.cs" t="Include" />
             <e p="Objects.cs" t="Include" />
           </e>
           <e p="Pagination" t="Include">

Luticate2.Auth.Tests/Business/ExpressionConverter/ExpressionConverterTests.cs

 using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
+using Luticate2.Auth.Utils.Business.Converters;
 using Luticate2.Auth.Utils.Business.ExpressionConverter;
 using Luticate2.Auth.Utils.Business.ObjectConverterDescriptor;
 using Luticate2.Auth.Utils.Interfaces;
             return serviceProvider;
         }
 
-        protected LuExpressionConverterOptions GetConverterOptions()
+        protected LuConvertersOptions GetConverterOptions()
         {
-            var options = new LuExpressionConverterOptions
+            var options = new LuConvertersOptions
             {
                 Parameters = new Dictionary<ParameterExpression, Expression>(),
-                Types = new Dictionary<Type, Type>
+                TypeConverter = new LuConvertersTypeConverter(new Dictionary<Type, Type>
                 {
                     {typeof(TestDbo1), typeof(TestModel1)},
                     {typeof(TestDbo2), typeof(TestModel2)}
-                }
+                })
             };
             return options;
         }
         public void TestVirtualProperty1()
         {
             Expression<Func<TestDbo2, string>> expDbo = (x => x.NameVirtual);
-            Expression<Func<TestModel2, string>> expModel = (Param_0 => Param_0.name + " " + Param_0.name);
+            Expression<Func<TestModel2, string>> expModel = (Param_0 => Param_0.name == null ? "[no data]" : Param_0.name + " " + Param_0.name);
             var converter = GetConverter();
             var result = converter.Visit(expDbo);
             Assert.Equal(expModel.ToString(), result?.ToString());
         public void TestVirtualProperty2()
         {
             Expression<Func<TestDbo2, string>> expDbo = (x => x.Parent.NameVirtual);
-            Expression<Func<TestModel2, string>> expModel = (Param_0 => Param_0.parent.name + " " + Param_0.parent.name);
+            Expression<Func<TestModel2, string>> expModel = (Param_0 => Param_0.parent.name == null ? "[no data]" : Param_0.parent.name + " " + Param_0.parent.name);
             var converter = GetConverter();
             var result = converter.Visit(expDbo);
             Assert.Equal(expModel.ToString(), result?.ToString());
         public void TestComplexExpression2()
         {
             Expression<Func<TestDbo2, int>> expDbo = (x => (x.NameVirtual + " " + x.Name).Length);
-            Expression<Func<TestModel2, int>> expModel = (Param_0 => (Param_0.name + " " + Param_0.name + " " + Param_0.name).Length);
+            Expression<Func<TestModel2, int>> expModel = (Param_0 => ((Param_0.name == null ? "[no data]" : (Param_0.name + " " + Param_0.name)) + " " + Param_0.name).Length);
             var converter = GetConverter();
             var result = converter.Visit(expDbo);
             Assert.Equal(expModel.ToString(), result?.ToString());

Luticate2.Auth.Tests/Business/ExpressionConverter/Objects.cs

     {
         public LuOcdTest1()
         {
-            AddMemberConverter(x => x.Id, y => y.id, PropertyType.Value);
-            AddMemberConverter(x => x.Name, y => y.name, PropertyType.Value);
-            AddMemberConverter(x => x.TestDbo2s, y => y.test_model2, PropertyType.Object);
+            AddMemberConverter(x => x.Id, y => y.id);
+            AddMemberConverter(x => x.Name, y => y.name);
+            AddMemberConverter(x => x.TestDbo2s, y => y.test_model2);
             AddStaticMethodConverter(
                 (Expression<Func<TestDbo1, string>>)(x => x.ToString()),
                 (Expression<Func<TestModel1, string>>)(x => x.id + ": " + x.name)
     {
         public LuOcdTest2()
         {
-            AddMemberConverter(x => x.Id, y => y.id, PropertyType.Value);
-            AddMemberConverter(x => x.Name, y => y.name, PropertyType.Value);
-            AddMemberConverter(x => x.NameVirtual, y => y.name + " " + y.name, PropertyType.Value);
-            AddMemberConverter(x => x.TestDbo1, y => y.test_model1, PropertyType.Object);
-            AddMemberConverter(x => x.Parent, y => y.parent, PropertyType.Object);
+            AddMemberConverter(x => x.Id, y => y.id);
+            AddMemberConverter(x => x.Name, y => y.name);
+            AddMemberConverter(x => x.NameVirtual, y => y.name == null ? "[no data]" : (y.name + " " + y.name));
+            AddMemberConverter(x => x.TestDbo1, y => y.test_model1);
+            AddMemberConverter(x => x.Parent, y => y.parent);
         }
     }
 }

Luticate2.Auth.Tests/Business/ObjectConverter/ObjectConverterTests.cs

 using System;
+using System.Collections;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using System.Linq;
 using System.Linq.Expressions;
+using Luticate2.Auth.Utils.Business.Converters;
 using Luticate2.Auth.Utils.Business.ExpressionConverter;
 using Luticate2.Auth.Utils.Business.Fields;
 using Luticate2.Auth.Utils.Business.ObjectConverter;
             var typeILuObjectConverterDescriptorEnumerable =
                 typeILuObjectConverterDescriptor.MakeGenericType(typeof(Enumerable), typeof(Enumerable));
 
+            var typeILuObjectConverter = typeof(ILuObjectConverter<,>);
+            var listTypes = new []
+            {
+                typeof(IEnumerable<>),
+                typeof(ICollection<>),
+                typeof(Collection<>),
+                typeof(IList<>),
+                typeof(List<>)
+            };
+            var listImplemType = new Dictionary<Type, Type>
+            {
+                {typeof(IEnumerable<>), typeof(LuObjectConverterList)},
+                {typeof(ICollection<>), typeof(LuObjectConverterCollection)},
+                {typeof(Collection<>), typeof(LuObjectConverterCollection)},
+                {typeof(IList<>), typeof(LuObjectConverterList)},
+                {typeof(List<>), typeof(LuObjectConverterList)}
+            };
+
             var services = new ServiceCollection();
             services.AddSingleton<ILuObjectConverterDescriptorIdentity, LuObjectConverterDescriptorIdentity>();
             services.AddSingleton(typeILuObjectConverterDescriptorEnumerable, typeof(LuObjectConverterDescriptorEnumerable));
             services.AddSingleton<ILuObjectConverterDescriptor<TestDbo1, TestModel1>, LuOcdTest1>();
             services.AddSingleton<ILuObjectConverterDescriptor<TestDbo2, TestModel2>, LuOcdTest2>();
 
-
             services.AddSingleton<ILuObjectConverterIdentity, LuObjectConverterIdentity>();
+            foreach (var typeFrom in listTypes)
+            {
+                foreach (var typeTo in listTypes)
+                {
+                    services.AddSingleton(typeILuObjectConverter.MakeGenericType(typeFrom, typeTo), listImplemType[typeTo]);
+                }
+            }
             services.AddSingleton<ILuObjectConverter<TestModel1, TestDbo1>, LuObjectConverterPoco<TestModel1, TestDbo1>>();
             services.AddSingleton<ILuObjectConverter<TestModel2, TestDbo2>, LuObjectConverterPoco<TestModel2, TestDbo2>>();
 
             return serviceProvider;
         }
 
-        protected LuExpressionConverterOptions GetConverterOptions()
+        protected LuConvertersOptions GetConverterOptions()
         {
-            var options = new LuExpressionConverterOptions
+            var options = new LuConvertersOptions
             {
                 Parameters = new Dictionary<ParameterExpression, Expression>(),
-                Types = new Dictionary<Type, Type>
+                TypeConverter = new LuConvertersTypeConverter(new Dictionary<Type, Type>
                 {
                     {typeof(TestDbo1), typeof(TestModel1)},
-                    {typeof(TestDbo2), typeof(TestModel2)}
-                },
-                Allocator = type =>
-                {
-                    return Activator.CreateInstance(type);
-                }
+                    {typeof(TestDbo2), typeof(TestModel2)},
+                    {typeof(TestModel1), typeof(TestDbo1)},
+                    {typeof(TestModel2), typeof(TestDbo2)}
+                }),
+                Allocator = new LuConvertersAllocator()
             };
             return options;
         }
             Assert.NotNull(dbo);
             Assert.Equal(model.id, dbo.Id);
             Assert.Equal(model.name, dbo.Name);
+            Assert.Equal(model.test_model2.Count, dbo.TestDbo2s.Count);
+            foreach (var e in model.test_model2.Zip(dbo.TestDbo2s, (model2, dbo2) => new {Model = model2, Dbo = dbo2}))
+            {
+                Assert.Equal(e.Model.id, e.Dbo.Id);
+                Assert.Equal(e.Model.name, e.Dbo.Name);
+                Assert.Equal(e.Model.name + " " + e.Model.name, e.Dbo.NameVirtual);
+                Assert.Equal(null, e.Dbo.Parent);
+                Assert.Equal(null, e.Dbo.TestDbo1);
+            }
         }
     }
 }

Luticate2.Auth.Tests/Business/ObjectConverter/Objects.cs

 
         public string Name { get; set; }
 
-//        public IList<TestDbo2> TestDbo2s { get; set; } // TODO
+        public IList<TestDbo2> TestDbo2s { get; set; }
 
         public string ToString()
         {
 
         public TestDbo2 Parent { get; set; }
 
-        public TestModel1 Unused { get; set; }
+        public TestDbo1 Unused { get; set; }
     }
 
     public class TestModel1
     {
         public LuOcdTest1()
         {
-            AddMemberConverter(x => x.Id, y => y.id, PropertyType.Value);
-            AddMemberConverter(x => x.Name, y => y.name, PropertyType.Value);
-//            AddMemberConverter(x => x.TestDbo2s, y => y.test_model2, PropertyType.Object); // TODO
+            AddMemberConverter(x => x.Id, y => y.id);
+            AddMemberConverter(x => x.Name, y => y.name);
+            AddMemberConverter(x => x.TestDbo2s, y => y.test_model2);
             AddStaticMethodConverter(
                 (Expression<Func<TestDbo1, string>>)(x => x.ToString()),
                 (Expression<Func<TestModel1, string>>)(x => x.id + ": " + x.name)
     {
         public LuOcdTest2()
         {
-            AddMemberConverter(x => x.Id, y => y.id, PropertyType.Value);
-            AddMemberConverter(x => x.Name, y => y.name, PropertyType.Value);
-            AddMemberConverter(x => x.NameVirtual, y => y.name + " " + y.name, PropertyType.Value);
-            AddMemberConverter(x => x.TestDbo1, y => y.test_model1, PropertyType.Object);
-            AddMemberConverter(x => x.Parent, y => y.parent, PropertyType.Object);
+            AddMemberConverter(x => x.Id, y => y.id);
+            AddMemberConverter(x => x.Name, y => y.name);
+            AddMemberConverter(x => x.NameVirtual, y => y.name + " " + y.name);
+            AddMemberConverter(x => x.TestDbo1, y => y.test_model1);
+            AddMemberConverter(x => x.Parent, y => y.parent);
+            AddMemberConverter((LambdaExpression) (Expression<Func<TestDbo2, TestDbo1>>) (x => x.Unused), (Expression<Func<TestModel2, TestModel1>>) (y => null));
         }
     }
 }

Luticate2.Auth.Tests/RandomTests.cs

-namespace Luticate2.Auth.Tests
+using Luticate2.Auth.Utils.Business.ObjectConverter;
+using Xunit;
+
+namespace Luticate2.Auth.Tests
 {
     public class RandomTests
     {
 //            services.TryAddSingleton<ILuExpressionConverter<TTypeFrom>, TTypeImpl>();
 //        }
 
-//        [Fact]
-//        public void Test()
-//        {
-////            var parentScopeVar = new TestDbo1();
-////            Expression<Func<TestDbo2, Guid>> expDbo = (x => parentScopeVar.Id);
-////            var type = typeof(ILuObjectConverterDescriptor<,>);
-////            var gtype = type.MakeGenericType(typeof(int), typeof(Enumerable));
-//        }
+        [Fact]
+        public void Test()
+        {
+//            var parentScopeVar = new TestDbo1();
+//            Expression<Func<TestDbo2, Guid>> expDbo = (x => parentScopeVar.Id);
+//            var type = typeof(ILuObjectConverterDescriptor<,>);
+//            var gtype = type.MakeGenericType(typeof(int), typeof(Enumerable));
+        }
 
     }
 }

Luticate2.Auth/Utils/Business/Converters/LuConvertersAllocator.cs

+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using Luticate2.Auth.Utils.Interfaces;
+
+namespace Luticate2.Auth.Utils.Business.Converters
+{
+    public class LuConvertersAllocator : ILuConvertersAllocator
+    {
+        protected static IDictionary<Type, Type> listTypes = new Dictionary<Type, Type>
+        {
+            {typeof(IEnumerable<>), typeof(List<>)},
+            {typeof(ICollection<>), typeof(Collection<>)},
+            {typeof(Collection<>), typeof(Collection<>)},
+            {typeof(IList<>), typeof(List<>)},
+            {typeof(List<>), typeof(List<>)}
+        };
+
+        public object GetInstance(Type type)
+        {
+            if (type.IsGenericType)
+            {
+                var gtype = type.GetGenericTypeDefinition();
+
+                if (listTypes.ContainsKey(gtype))
+                {
+                    var glistType = listTypes[gtype].MakeGenericType(type.GenericTypeArguments[0]);
+                    return Activator.CreateInstance(glistType);
+                }
+            }
+            return Activator.CreateInstance(type);
+        }
+    }
+}

Luticate2.Auth/Utils/Business/Converters/LuConvertersOptions.cs

+using System.Collections.Generic;
+using System.Linq.Expressions;
+using Luticate2.Auth.Utils.Interfaces;
+
+namespace Luticate2.Auth.Utils.Business.Converters
+{
+    public class LuConvertersOptions
+    {
+        public IDictionary<ParameterExpression, Expression> Parameters { get; set; }
+
+        public ILuConvertersTypeConverter TypeConverter { get; set; }
+
+        public ILuConvertersAllocator Allocator { get; set; }
+    }
+}

Luticate2.Auth/Utils/Business/Converters/LuConvertersTypeConverter.cs

+using System;
+using System.Collections.Generic;
+using Luticate2.Auth.Utils.Interfaces;
+
+namespace Luticate2.Auth.Utils.Business.Converters
+{
+    public class LuConvertersTypeConverter : ILuConvertersTypeConverter
+    {
+        protected IDictionary<Type, Type> Types { get; set; }
+
+        public LuConvertersTypeConverter(IDictionary<Type, Type> types)
+        {
+            Types = types;
+        }
+
+        public Type ConvertType(Type typeFrom)
+        {
+            if (Types.ContainsKey(typeFrom))
+            {
+                return Types[typeFrom];
+            }
+
+            return typeFrom;
+        }
+    }
+}

Luticate2.Auth/Utils/Business/Crud/LuEfCrudBusiness.cs

 using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
+using Luticate2.Auth.Utils.Business.Converters;
 using Luticate2.Auth.Utils.Business.ExpressionConverter;
 using Luticate2.Auth.Utils.Dbo;
 using Luticate2.Auth.Utils.Dbo.Fields;
         {
             var lamdbaDbo = (Expression<Func<TDbo, bool>>) filter.Expression;
 
-            var options = new LuExpressionConverterOptions
+            var options = new LuConvertersOptions
             {
                 Parameters = new Dictionary<ParameterExpression, Expression>(), // TODO
-                Types = null // TODO
+                TypeConverter = null // TODO
             };
             var converter = new LuExpressionConverterVisitor(options, ServiceProvider);
             var lamdbaModel = converter.Visit(lamdbaDbo) as Expression<Func<TModel, bool>>;// TODO Handle errors

Luticate2.Auth/Utils/Business/ExpressionConverter/LuExpressionConverterOptions.cs

-using System;
-using System.Collections.Generic;
-using System.Linq.Expressions;
-
-namespace Luticate2.Auth.Utils.Business.ExpressionConverter
-{
-    public class LuExpressionConverterOptions
-    {
-        public IDictionary<ParameterExpression, Expression> Parameters { get; set; }
-
-        public IDictionary<Type, Type> Types { get; set; }
-
-        public Func<Type, object> Allocator { get; set; }
-    }
-}

Luticate2.Auth/Utils/Business/ExpressionConverter/LuExpressionConverterVisitor.cs

 using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
+using Luticate2.Auth.Utils.Business.Converters;
 using Luticate2.Auth.Utils.Business.Utils;
 using Luticate2.Auth.Utils.Dbo;
 using Luticate2.Auth.Utils.Dbo.Result;
 {
     public class LuExpressionConverterVisitor : ExpressionVisitor
     {
-        public LuExpressionConverterOptions Options { get; }
+        public LuConvertersOptions Options { get; }
 
         protected IServiceProvider ServiceProvider { get; }
 
-        public LuExpressionConverterVisitor(LuExpressionConverterOptions options, IServiceProvider serviceProvider)
+        public LuExpressionConverterVisitor(LuConvertersOptions options, IServiceProvider serviceProvider)
         {
             Options = options;
             ServiceProvider = serviceProvider;
             else if (currentExp is MemberExpression memberExpression)
             {
                 var typeFrom = memberExpression.Member.DeclaringType;
-                var typeTo = Options.Types.ContainsKey(typeFrom) ? Options.Types[typeFrom] : typeFrom;
+                var typeTo = Options.TypeConverter.ConvertType(typeFrom);
 
                 var convertResult = ConvertMemberExpression(memberExpression, null, typeTo);
                 if (!convertResult)
             else if (currentExp is MethodCallExpression methodCallExpression)
             {
                 var typeFrom = methodCallExpression.Method.DeclaringType;
-                var typeTo = Options.Types.ContainsKey(typeFrom) ? Options.Types[typeFrom] : typeFrom;
+                var typeTo = Options.TypeConverter.ConvertType(typeFrom);
 
                 var convertResult = ConvertMethodCallExpression(methodCallExpression, null, typeTo);
                 if (!convertResult)
             var convertedParams = new List<ParameterExpression>();
             foreach (var parameter in node.Parameters)
             {
-                // TODO check Options.Types[parameter.Type] access
-                var convertedParam = Expression.Parameter(Options.Types[parameter.Type]);
+                var convertedParam = Expression.Parameter(Options.TypeConverter.ConvertType(parameter.Type));
                 Options.Parameters.Add(parameter, convertedParam);
                 convertedParams.Add(convertedParam);
             }

Luticate2.Auth/Utils/Business/ExpressionConverter/LuExpressionParamReplaceVisitor.cs

 using System.Linq.Expressions;
+using Luticate2.Auth.Utils.Business.Converters;
 using Luticate2.Auth.Utils.Dbo;
 using Luticate2.Auth.Utils.Dbo.Result;
 using Luticate2.Auth.Utils.Exceptions;
 {
     public class LuExpressionParamReplaceVisitor : ExpressionVisitor
     {
-        public LuExpressionConverterOptions Options { get; }
+        public LuConvertersOptions Options { get; }
 
-        public LuExpressionParamReplaceVisitor(LuExpressionConverterOptions options)
+        public LuExpressionParamReplaceVisitor(LuConvertersOptions options)
         {
             Options = options;
         }

Luticate2.Auth/Utils/Business/ExpressionConverter/LuObjectConverterIdentity.cs → Luticate2.Auth/Utils/Business/ObjectConverter/LuObjectConverterIdentity.cs

+using Luticate2.Auth.Utils.Business.Converters;
 using Luticate2.Auth.Utils.Dbo.Fields;
 using Luticate2.Auth.Utils.Dbo.Result;
 using Luticate2.Auth.Utils.Interfaces;
 
-namespace Luticate2.Auth.Utils.Business.ExpressionConverter
+namespace Luticate2.Auth.Utils.Business.ObjectConverter
 {
     public class LuObjectConverterIdentity : ILuObjectConverterIdentity
     {
-        public LuResult<object> Convert(object srcObj, LuPartialFieldsDbo fields, LuExpressionConverterOptions options)
+        public LuResult<object> Convert(object srcObj, LuPartialFieldsDbo fields, LuConvertersOptions options)
         {
             return LuResult<object>.Ok(srcObj);
         }

Luticate2.Auth/Utils/Business/ObjectConverter/LuObjectConverterLists.cs

+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using Luticate2.Auth.Utils.Business.Converters;
+using Luticate2.Auth.Utils.Dbo;
+using Luticate2.Auth.Utils.Dbo.Fields;
+using Luticate2.Auth.Utils.Dbo.Result;
+using Luticate2.Auth.Utils.Interfaces;
+
+namespace Luticate2.Auth.Utils.Business.ObjectConverter
+{
+    public abstract class LuObjectConverterLists : ILuObjectConverter
+    {
+        protected IServiceProvider ServiceProvider { get; }
+
+        public LuObjectConverterLists(IServiceProvider serviceProvider)
+        {
+            ServiceProvider = serviceProvider;
+        }
+
+        protected abstract Type GetListType();
+
+        public LuResult<object> Convert(object srcObj, LuPartialFieldsDbo fields, LuConvertersOptions options)
+        {
+            if (srcObj is IEnumerable enumerable)
+            {
+                var listType = GetListType();
+                var listTypeTo = options.TypeConverter.ConvertType(srcObj.GetType().GetGenericArguments()[0]);
+                var glistType = listType.MakeGenericType(listTypeTo);
+                var collection = options.Allocator.GetInstance(glistType);
+                foreach (var obj in enumerable)
+                {
+                    object convertedObj = null;
+                    if (obj != null)
+                    {
+                        var typeFrom = obj.GetType();
+                        var typeTo = options.TypeConverter.ConvertType(typeFrom);
+                        // TODO Handle converter == null
+                        var converter = LuObjectConverterUtils.GetObjectConverter(ServiceProvider, typeFrom, typeTo);
+                        var convertResult = converter.Convert(obj, fields, options);
+                        if (!convertResult)
+                        {
+                            return convertResult;
+                        }
+
+                        convertedObj = convertResult.Data;
+                    }
+
+                    var methodInfo = collection.GetType().GetMethod(nameof(ICollection<object>.Add));
+                    methodInfo.Invoke(collection, new []{convertedObj});
+                }
+
+                return LuResult<object>.Ok(collection);
+            }
+            else
+            {
+                return LuResult<object>.Error(LuStatus.InputError.ToInt(), $"Could not convert {nameof(srcObj)} to {nameof(IEnumerable)}");
+            }
+        }
+    }
+
+    public class LuObjectConverterList : LuObjectConverterLists
+    {
+        public LuObjectConverterList(IServiceProvider serviceProvider) : base(serviceProvider)
+        {
+        }
+
+        protected override Type GetListType()
+        {
+            return typeof(List<>);
+        }
+    }
+
+    public class LuObjectConverterCollection : LuObjectConverterLists
+    {
+        public LuObjectConverterCollection(IServiceProvider serviceProvider) : base(serviceProvider)
+        {
+        }
+
+        protected override Type GetListType()
+        {
+            return typeof(Collection<>);
+        }
+    }
+}

Luticate2.Auth/Utils/Business/ObjectConverter/LuObjectConverterPoco.cs

 using System;
-using Luticate2.Auth.Utils.Business.ExpressionConverter;
+using Luticate2.Auth.Utils.Business.Converters;
 using Luticate2.Auth.Utils.Business.Utils;
 using Luticate2.Auth.Utils.Dbo.Fields;
 using Luticate2.Auth.Utils.Dbo.Result;
             ServiceProvider = serviceProvider;
         }
 
-        protected ILuObjectConverter GetObjectConverter(Type typeFrom, Type typeTo)
-        {
-            var type = typeof(ILuObjectConverter<,>);
-            var gtype = type.MakeGenericType(typeFrom, typeTo);
-            var converter = (ILuObjectConverter) ServiceProvider.GetService(gtype);
-            if (converter == null && typeFrom == typeTo)
-            {
-                converter = (ILuObjectConverter) ServiceProvider.GetService(typeof(ILuObjectConverterIdentity));
-            }
-            return converter;
-        }
-
-        public LuResult<object> Convert(object srcObj, LuPartialFieldsDbo fields, LuExpressionConverterOptions options)
+        public LuResult<object> Convert(object srcObj, LuPartialFieldsDbo fields, LuConvertersOptions options)
         {
             // TODO Check if this is correct
             if (srcObj == null)
             // TODO Handle descriptor == null
             var descriptor = ServiceProvider.GetService<ILuObjectConverterDescriptor<TTypeTo, TTypeFrom>>();
             var typeTo = typeof(TTypeTo);
-            var dstObj = options.Allocator(typeTo);
+            var dstObj = options.Allocator.GetInstance(typeTo);
 
             foreach (var memberInfo in typeTo.GetProperties())
             {
                 // TODO check if field is included in fields
-                // TODO Handle valueExpression == null
+                // TODO Handle srcPropExpression == null
                 var srcPropExpression = descriptor.GetMemberValueExpression(memberInfo, options);
                 var srcPropDelegate = srcPropExpression.Compile();
                 var srcProp = srcPropDelegate.DynamicInvoke(srcObj);
-
-                var objectConverter = GetObjectConverter(srcProp.GetType(), memberInfo.GetUnderlyingType());
-                var dstProp = objectConverter.Convert(srcProp, fields, options);
-                if (!dstProp)
+                object dstProp = null;
+                if (srcProp != null)
                 {
-                    return dstProp;
+                    var srcType = srcProp.GetType();
+
+                    // TODO Handle objectConverter == null
+                    var objectConverter = LuObjectConverterUtils.GetObjectConverter(ServiceProvider, srcType, memberInfo.GetUnderlyingType());
+                    var dstPropResult = objectConverter.Convert(srcProp, fields, options);
+                    if (!dstPropResult)
+                    {
+                        return dstPropResult;
+                    }
+
+                    dstProp = dstPropResult.Data;
                 }
-                var result = LuExpressionUtils.SetValueFromMember(memberInfo, dstObj, dstProp.Data);
+
+                var result = LuExpressionUtils.SetValueFromMember(memberInfo, dstObj, dstProp);
                 if (!result)
                 {
                     return result.To<object>();

Luticate2.Auth/Utils/Business/ObjectConverter/LuObjectConverterUtils.cs

+using System;
+using Luticate2.Auth.Utils.Interfaces;
+
+namespace Luticate2.Auth.Utils.Business.ObjectConverter
+{
+    public static class LuObjectConverterUtils
+    {
+        public static ILuObjectConverter GetObjectConverter(IServiceProvider serviceProvider, Type typeFrom, Type typeTo)
+        {
+            var type = typeof(ILuObjectConverter<,>);
+            var gtype = type.MakeGenericType(typeFrom, typeTo);
+            var converter = (ILuObjectConverter) serviceProvider.GetService(gtype);
+
+            if (converter == null)
+            {
+                var baseTypeFrom = typeFrom;
+                if (typeFrom.IsGenericType)
+                {
+                    baseTypeFrom = typeFrom.GetGenericTypeDefinition();
+                }
+                var baseTypeTo = typeTo;
+                if (typeTo.IsGenericType)
+                {
+                    baseTypeTo = typeTo.GetGenericTypeDefinition();
+                }
+                gtype = type.MakeGenericType(baseTypeFrom, baseTypeTo);
+                converter = (ILuObjectConverter) serviceProvider.GetService(gtype);
+            }
+
+            if (converter == null && typeFrom == typeTo)
+            {
+                converter = (ILuObjectConverter) serviceProvider.GetService(typeof(ILuObjectConverterIdentity));
+            }
+
+            return converter;
+        }
+    }
+}

Luticate2.Auth/Utils/Business/ObjectConverterDescriptor/LuObjectConverterDescriptor.cs

 using System.Linq;
 using System.Linq.Expressions;
 using System.Reflection;
+using Luticate2.Auth.Utils.Business.Converters;
 using Luticate2.Auth.Utils.Business.ExpressionConverter;
 using Luticate2.Auth.Utils.Business.Utils;
 using Luticate2.Auth.Utils.Interfaces;
 {
     public class LuObjectConverterDescriptor : ILuObjectConverterDescriptor
     {
-        protected enum PropertyType
-        {
-            Value,
-            Object
-        }
-
         protected class LuObjectConverterDescriptorMemberInfo
         {
             public LambdaExpression ValueExpression { get; set; }
-
-            public PropertyType PropertyType { get; set; }
         }
 
         protected class LuObjectConverterDescriptorMethodInfo
             public LambdaExpression ValueExpression { get; set; }
         }
 
-        protected delegate LuObjectConverterDescriptorMethodInfo DynamicMethodConverter(MethodInfo methodInfo, IDictionary<Type, Type> types);
+        protected delegate LuObjectConverterDescriptorMethodInfo DynamicMethodConverter(MethodInfo methodInfo, ILuConvertersTypeConverter typeConverter);
 
         private IDictionary<MemberInfo, LuObjectConverterDescriptorMemberInfo> StaticMemberConverters { get; } = new Dictionary<MemberInfo, LuObjectConverterDescriptorMemberInfo>();
 
 
         private IDictionary<MethodInfo, DynamicMethodConverter> DynamicMethodConverters { get; } = new Dictionary<MethodInfo, DynamicMethodConverter>();
 
-        protected void AddMemberConverter(LambdaExpression memberFrom, LambdaExpression valueExpression, PropertyType propertyType)
+        protected void AddMemberConverter(LambdaExpression memberFrom, LambdaExpression valueExpression)
         {
             // TODO: check memberInfo != null
             var memberInfo = LuExpressionUtils.GetSingleMemberFromExpression(memberFrom);
             StaticMemberConverters.Add(memberInfo, new LuObjectConverterDescriptorMemberInfo
             {
-                ValueExpression = LuExpressionUtils.GetFromConvert(valueExpression),
-                PropertyType = propertyType
+                ValueExpression = LuExpressionUtils.GetFromConvert(valueExpression)
             });
         }
 
         protected void AddDynamicMethodConverterTemplate(LambdaExpression methodFrom)
         {
             AddDynamicMethodConverter(methodFrom,
-                (info, types) =>
+                (info, converter) =>
                 {
                     var genericMethodInfo = info.GetGenericMethodDefinition();
-                    var templateMethodInfo = genericMethodInfo.MakeGenericMethod(info.GetGenericArguments().Select(x => types[x]).ToArray());
+                    var templateMethodInfo = genericMethodInfo.MakeGenericMethod(info.GetGenericArguments().Select(converter.ConvertType).ToArray());
 
                     var lambdaParams = new List<ParameterExpression>
                     {
             );
         }
 
-        public LambdaExpression GetMemberValueExpression(MemberInfo memberInfo, LuExpressionConverterOptions options)
+        public LambdaExpression GetMemberValueExpression(MemberInfo memberInfo, LuConvertersOptions options)
         {
             if (StaticMemberConverters.ContainsKey(memberInfo))
             {
             return null;
         }
 
-        public LambdaExpression GetMethodValueExpression(MethodInfo methodInfo, LuExpressionConverterOptions options)
+        public LambdaExpression GetMethodValueExpression(MethodInfo methodInfo, LuConvertersOptions options)
         {
             if (StaticMethodConverters.ContainsKey(methodInfo))
             {
             var genericMethodInfo = methodInfo.GetGenericMethodDefinition();
             if (DynamicMethodConverters.ContainsKey(genericMethodInfo))
             {
-                var result = DynamicMethodConverters[genericMethodInfo](methodInfo, options.Types);
+                var result = DynamicMethodConverters[genericMethodInfo](methodInfo, options.TypeConverter);
                 if (result != null)
                 {
                     return result.ValueExpression;
     public class LuObjectConverterDescriptor<TTypeFrom, TTypeTo> : LuObjectConverterDescriptor, ILuObjectConverterDescriptor<TTypeFrom, TTypeTo>
     {
         protected void AddMemberConverter(Expression<Func<TTypeFrom, object>> memberFrom,
-            Expression<Func<TTypeTo, object>> valueExpression, PropertyType propertyType)
+            Expression<Func<TTypeTo, object>> valueExpression)
         {
-            AddMemberConverter((LambdaExpression) memberFrom, valueExpression, propertyType);
+            AddMemberConverter((LambdaExpression) memberFrom, valueExpression);
         }
 
         protected void AddNullMemberConverter(Expression<Func<TTypeFrom, object>> memberFrom)
         {
-            AddMemberConverter(memberFrom, to => default(TTypeTo), PropertyType.Value);
+            AddMemberConverter(memberFrom, to => null);
         }
     }
 }

Luticate2.Auth/Utils/Business/ObjectConverterDescriptor/LuObjectConverterDescriptorIdentity.cs

 using System.Linq;
 using System.Linq.Expressions;
 using System.Reflection;
+using Luticate2.Auth.Utils.Business.Converters;
 using Luticate2.Auth.Utils.Business.ExpressionConverter;
 using Luticate2.Auth.Utils.Interfaces;
 
 {
     public class LuObjectConverterDescriptorIdentity : ILuObjectConverterDescriptorIdentity
     {
-        public LambdaExpression GetMemberValueExpression(MemberInfo memberInfo, LuExpressionConverterOptions options)
+        public LambdaExpression GetMemberValueExpression(MemberInfo memberInfo, LuConvertersOptions options)
         {
             var isStatic = false;
             if (memberInfo is FieldInfo fieldInfo)
             return lambda;
         }
 
-        public LambdaExpression GetMethodValueExpression(MethodInfo methodInfo, LuExpressionConverterOptions options)
+        public LambdaExpression GetMethodValueExpression(MethodInfo methodInfo, LuConvertersOptions options)
         {
             var lambdaParams = new List<ParameterExpression>
             {

Luticate2.Auth/Utils/Interfaces/ILuConvertersAllocator.cs

+using System;
+
+namespace Luticate2.Auth.Utils.Interfaces
+{
+    public interface ILuConvertersAllocator
+    {
+        object GetInstance(Type type);
+    }
+}

Luticate2.Auth/Utils/Interfaces/ILuConvertersTypeConverter.cs

+using System;
+
+namespace Luticate2.Auth.Utils.Interfaces
+{
+    public interface ILuConvertersTypeConverter
+    {
+        Type ConvertType(Type typeFrom);
+    }
+}

Luticate2.Auth/Utils/Interfaces/ILuObjectConverter.cs

+using Luticate2.Auth.Utils.Business.Converters;
 using Luticate2.Auth.Utils.Business.ExpressionConverter;
 using Luticate2.Auth.Utils.Dbo.Fields;
 using Luticate2.Auth.Utils.Dbo.Result;
 {
     public interface ILuObjectConverter
     {
-        LuResult<object> Convert(object srcObj, LuPartialFieldsDbo fields, LuExpressionConverterOptions options);
+        LuResult<object> Convert(object srcObj, LuPartialFieldsDbo fields, LuConvertersOptions options);
     }
 
     public interface ILuObjectConverter<TTypeFrom, TTypeTo> : ILuObjectConverter

Luticate2.Auth/Utils/Interfaces/ILuObjectConverterDescriptor.cs

 using System.Linq.Expressions;
 using System.Reflection;
+using Luticate2.Auth.Utils.Business.Converters;
 using Luticate2.Auth.Utils.Business.ExpressionConverter;
 
 namespace Luticate2.Auth.Utils.Interfaces
 {
     public interface ILuObjectConverterDescriptor
     {
-        LambdaExpression GetMemberValueExpression(MemberInfo memberInfo, LuExpressionConverterOptions options);
+        LambdaExpression GetMemberValueExpression(MemberInfo memberInfo, LuConvertersOptions options);
 
-        LambdaExpression GetMethodValueExpression(MethodInfo methodInfo, LuExpressionConverterOptions options);
+        LambdaExpression GetMethodValueExpression(MethodInfo methodInfo, LuConvertersOptions options);
     }
 
     public interface ILuObjectConverterDescriptor<TTypeFrom, TTypeTo> : ILuObjectConverterDescriptor