began LuObjectConverter

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

@@ -47,12 +47,15 @@
               <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="LuExpressionUtils.cs" t="Include" />
+            <e p="ObjectConverter" t="Include">
+              <e p="LuObjectConverterPoco.cs" t="Include" />
+            </e>
             <e p="ObjectConverterDescriptor" t="Include">
               <e p="LuObjectConverterDescriptor.cs" t="Include" />
               <e p="LuObjectConverterDescriptorDbSet.cs" t="Include" />
@@ -74,6 +77,10 @@
                 <e p="LuSerializerContext.cs" t="Include" />
               </e>
             </e>
+            <e p="Utils" t="Include">
+              <e p="LuCoreExtension.cs" t="Include" />
+              <e p="LuExpressionUtils.cs" t="Include" />
+            </e>
           </e>
           <e p="Dbo" t="Include">
             <e p="Fields" t="Include">
@@ -102,6 +109,7 @@
           </e>
           <e p="Interfaces" t="Include">
             <e p="ILuCrud.cs" t="Include" />
+            <e p="ILuObjectConverter.cs" t="Include" />
             <e p="ILuObjectConverterDescriptor.cs" t="Include" />
             <e p="ILuPartialObjectCopier.cs" t="Include" />
           </e>
@@ -134,17 +142,23 @@
       </e>
       <e p="Luticate2.Auth.Tests" t="IncludeRecursive">
         <e p="Business" t="Include">
+          <e p="ExpressionConverter" t="Include">
+            <e p="ExpressionConverterTests.cs" t="Include" />
+            <e p="Objects.cs" t="Include" />
+          </e>
           <e p="Fields" t="Include">
             <e p="LuFieldDboTests.cs" t="Include" />
           </e>
-          <e p="LuExpressionUtilsTests.cs" t="Include" />
           <e p="ObjectConverter" t="Include">
-            <e p="ObjectConverterTests.cs" t="Include" />
+            <e p="ObjectConverter.cs" t="Include" />
             <e p="Objects.cs" t="Include" />
           </e>
           <e p="Pagination" t="Include">
             <e p="LuFilterTests.cs" t="Include" />
           </e>
+          <e p="Utils" t="Include">
+            <e p="LuExpressionUtilsTests.cs" t="Include" />
+          </e>
         </e>
         <e p="Luticate2.Auth.Tests.csproj" t="IncludeRecursive" />
         <e p="RandomTests.cs" t="Include" />

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

@@ -0,0 +1,231 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using Luticate2.Auth.Utils.Business.ExpressionConverter;
+using Luticate2.Auth.Utils.Business.ObjectConverterDescriptor;
+using Luticate2.Auth.Utils.Interfaces;
+using Microsoft.Extensions.DependencyInjection;
+using Xunit;
+
+namespace Luticate2.Auth.Tests.Business.ExpressionConverter
+{
+    public class ExpressionConverterTests
+    {
+
+        protected IServiceProvider GetServiceProvider()
+        {
+            var typeILuObjectConverterDescriptor = typeof(ILuObjectConverterDescriptor<,>);
+            var typeILuObjectConverterDescriptorEnumerable =
+                typeILuObjectConverterDescriptor.MakeGenericType(typeof(Enumerable), typeof(Enumerable));
+
+            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>();
+
+            var serviceProvider = services.BuildServiceProvider();
+            return serviceProvider;
+        }
+
+        protected LuExpressionConverterOptions GetConverterOptions()
+        {
+            var options = new LuExpressionConverterOptions
+            {
+                Parameters = new Dictionary<ParameterExpression, Expression>(),
+                Types = new Dictionary<Type, Type>
+                {
+                    {typeof(TestDbo1), typeof(TestModel1)},
+                    {typeof(TestDbo2), typeof(TestModel2)}
+                }
+            };
+            return options;
+        }
+
+        protected LuExpressionConverterVisitor GetConverter()
+        {
+            return new LuExpressionConverterVisitor(GetConverterOptions(), GetServiceProvider());
+        }
+
+        [Fact]
+        public void TestSimpleProperty1()
+        {
+            Expression<Func<TestDbo2, Guid>> expDbo = (x => x.TestDbo1.Id);
+            Expression<Func<TestModel2, Guid>> expModel = (Param_0 => Param_0.test_model1.id);
+            var converter = GetConverter();
+            var result = converter.Visit(expDbo);
+            Assert.Equal(expModel.ToString(), result?.ToString());
+        }
+
+        [Fact]
+        public void TestSimpleProperty2()
+        {
+            Expression<Func<TestDbo2, bool>> expDbo = (x => x.TestDbo1.Id == Guid.Empty);
+            Expression<Func<TestModel2, bool>> expModel = (Param_0 => Param_0.test_model1.id == Guid.Empty);
+            var converter = GetConverter();
+            var result = converter.Visit(expDbo);
+            Assert.Equal(expModel.ToString(), result?.ToString());
+        }
+
+        [Fact]
+        public void TestSimpleProperty3()
+        {
+            Expression<Func<TestDbo2, bool>> expDbo = (x => x.TestDbo1.Name.Length == 2);
+            Expression<Func<TestModel2, bool>> expModel = (Param_0 => Param_0.test_model1.name.Length == 2);
+            var converter = GetConverter();
+            var result = converter.Visit(expDbo);
+            Assert.Equal(expModel.ToString(), result?.ToString());
+        }
+
+        [Fact]
+        public void TestStaticProperty1()
+        {
+            Expression<Func<TestDbo2, bool>> expDbo = (x => (x.TestDbo1.Name == "42") == StaticDbo.StaticField);
+            Expression<Func<TestModel2, bool>> expModel = (Param_0 => (Param_0.test_model1.name == "42") == StaticDbo.StaticField);
+            var converter = GetConverter();
+            var result = converter.Visit(expDbo);
+            Assert.Equal(expModel.ToString(), result?.ToString());
+        }
+
+        [Fact]
+        public void TestStaticProperty2()
+        {
+            Expression<Func<TestDbo2, bool>> expDbo = (x => (x.TestDbo1.Name == "42") == StaticDbo.StaticProperty);
+            Expression<Func<TestModel2, bool>> expModel = (Param_0 => (Param_0.test_model1.name == "42") == StaticDbo.StaticProperty);
+            var converter = GetConverter();
+            var result = converter.Visit(expDbo);
+            Assert.Equal(expModel.ToString(), result?.ToString());
+        }
+
+        [Fact]
+        public void TestVirtualProperty1()
+        {
+            Expression<Func<TestDbo2, string>> expDbo = (x => x.NameVirtual);
+            Expression<Func<TestModel2, string>> expModel = (Param_0 => Param_0.name + " " + Param_0.name);
+            var converter = GetConverter();
+            var result = converter.Visit(expDbo);
+            Assert.Equal(expModel.ToString(), result?.ToString());
+        }
+
+        [Fact]
+        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);
+            var converter = GetConverter();
+            var result = converter.Visit(expDbo);
+            Assert.Equal(expModel.ToString(), result?.ToString());
+        }
+
+        [Fact]
+        public void TestStaticValue1()
+        {
+            Expression<Func<TestDbo2, int>> expDbo = (x => 0);
+            Expression<Func<TestModel2, int>> expModel = (Param_0 => 0);
+            var converter = GetConverter();
+            var result = converter.Visit(expDbo);
+            Assert.Equal(expModel.ToString(), result?.ToString());
+        }
+
+        [Fact]
+        public void TestStaticValue2()
+        {
+            Expression<Func<TestDbo2, TestDbo2>> expDbo = (x => x);
+            Expression<Func<TestModel2, TestModel2>> expModel = (Param_0 => Param_0);
+            var converter = GetConverter();
+            var result = converter.Visit(expDbo);
+            Assert.Equal(expModel.ToString(), result?.ToString());
+        }
+
+        [Fact]
+        public void TestStaticValue3()
+        {
+            Expression<Func<TestDbo2, bool>> expDbo = (x => StaticDbo.StaticField);
+            Expression<Func<TestModel2, bool>> expModel = (Param_0 => StaticDbo.StaticField);
+            var converter = GetConverter();
+            var result = converter.Visit(expDbo);
+            Assert.Equal(expModel.ToString(), result?.ToString());
+        }
+
+        [Fact]
+        public void TestComplexExpression1()
+        {
+            Expression<Func<TestDbo2, int>> expDbo = (x => (x.Name + " " + x.Name).Length);
+            Expression<Func<TestModel2, int>> expModel = (Param_0 => (Param_0.name + " " + Param_0.name).Length);
+            var converter = GetConverter();
+            var result = converter.Visit(expDbo);
+            Assert.Equal(expModel.ToString(), result?.ToString());
+        }
+
+        [Fact]
+        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);
+            var converter = GetConverter();
+            var result = converter.Visit(expDbo);
+            Assert.Equal(expModel.ToString(), result?.ToString());
+        }
+
+        [Fact]
+        public void TestSimpleMethodSimpleArg1()
+        {
+            Expression<Func<TestDbo2, bool>> expDbo = (x => x.Name.Contains("s"));
+            Expression<Func<TestModel2, bool>> expModel = (Param_0 => Param_0.name.Contains("s"));
+            var converter = GetConverter();
+            var result = converter.Visit(expDbo);
+            Assert.Equal(expModel.ToString(), result?.ToString());
+        }
+
+        [Fact]
+        public void TestSimpleMethodSimpleArg2()
+        {
+            Expression<Func<TestDbo2, bool>> expDbo = (x => x.TestDbo1.Name.Contains("s"));
+            Expression<Func<TestModel2, bool>> expModel = (Param_0 => Param_0.test_model1.name.Contains("s"));
+            var converter = GetConverter();
+            var result = converter.Visit(expDbo);
+            Assert.Equal(expModel.ToString(), result?.ToString());
+        }
+
+        [Fact]
+        public void TestSimpleMethodSimpleArg3()
+        {
+            Expression<Func<TestDbo2, string>> expDbo = (x => x.TestDbo1.ToString());
+            Expression<Func<TestModel2, string>> expModel = (Param_0 => Param_0.test_model1.id + ": " + Param_0.test_model1.name);
+            var converter = GetConverter();
+            var result = converter.Visit(expDbo);
+            Assert.Equal(expModel.ToString(), result?.ToString());
+        }
+
+        [Fact]
+        public void TestSimpleMethodAdvArg1()
+        {
+            Expression<Func<TestDbo2, bool>> expDbo = (x => x.TestDbo1.Name.Contains(x.Name));
+            Expression<Func<TestModel2, bool>> expModel = (Param_0 => Param_0.test_model1.name.Contains(Param_0.name));
+            var converter = GetConverter();
+            var result = converter.Visit(expDbo);
+            Assert.Equal(expModel.ToString(), result?.ToString());
+        }
+
+        [Fact]
+        public void TestAdvMethodSimpleArg1()
+        {
+            Expression<Func<TestDbo1, bool>> expDbo = (x => x.TestDbo2s.Any());
+            Expression<Func<TestModel1, bool>> expModel = (Param_0 => Param_0.test_model2.Any());
+            var converter = GetConverter();
+            var result = converter.Visit(expDbo);
+            Assert.Equal(expModel.ToString(), result?.ToString());
+        }
+
+        [Fact]
+        public void TestAdvMethodAdvArg1()
+        {
+            Expression<Func<TestDbo1, bool>> expDbo = (x => x.TestDbo2s.Any(y => y.Name.Contains(x.Name + "s")));
+            Expression<Func<TestModel1, bool>> expModel = (Param_0 => Param_0.test_model2.Any(Param_1 => Param_1.name.Contains(Param_0.name + "s")));
+            var converter = GetConverter();
+            var result = converter.Visit(expDbo);
+            Assert.Equal(expModel.ToString(), result?.ToString());
+        }
+    }
+}

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

@@ -0,0 +1,91 @@
+using System;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+using Luticate2.Auth.Utils.Business.ObjectConverterDescriptor;
+
+namespace Luticate2.Auth.Tests.Business.ExpressionConverter
+{
+    public static class StaticDbo
+    {
+        public static bool StaticField;
+
+        public static bool StaticProperty { get; set; }
+    }
+
+    public class TestDbo1
+    {
+        public Guid Id { get; set; }
+
+        public string Name { get; set; }
+
+        public IList<TestDbo2> TestDbo2s { get; set; }
+
+        public string ToString()
+        {
+            throw new NotImplementedException();
+        }
+    }
+
+    public class TestDbo2
+    {
+        public Guid Id { get; set; }
+
+        public string Name { get; set; }
+
+        public string NameVirtual { get; set; }
+
+        public TestDbo1 TestDbo1 { get; set; }
+
+        public TestDbo2 Parent { get; set; }
+
+        public TestModel1 Unused { get; set; }
+    }
+
+    public class TestModel1
+    {
+        public Guid id { get; set; }
+
+        public string name { get; set; }
+
+        public ICollection<TestModel2> test_model2 { get; set; }
+    }
+
+    public class TestModel2
+    {
+        public Guid id { get; set; }
+
+        public string name { get; set; }
+
+        public Guid test_model1_id { get; set; }
+
+        public TestModel1 test_model1 { get; set; }
+
+        public TestModel2 parent { get; set; }
+    }
+
+    public class LuOcdTest1 : LuObjectConverterDescriptor<TestDbo1, 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);
+            AddStaticMethodConverter(
+                (Expression<Func<TestDbo1, string>>)(x => x.ToString()),
+                (Expression<Func<TestModel1, string>>)(x => x.id + ": " + x.name)
+            );
+        }
+    }
+
+    public class LuOcdTest2 : LuObjectConverterDescriptor<TestDbo2, TestModel2>
+    {
+        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);
+        }
+    }
+}

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

@@ -3,7 +3,12 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
 using Luticate2.Auth.Utils.Business.ExpressionConverter;
+using Luticate2.Auth.Utils.Business.Fields;
+using Luticate2.Auth.Utils.Business.ObjectConverter;
 using Luticate2.Auth.Utils.Business.ObjectConverterDescriptor;
+using Luticate2.Auth.Utils.Dbo;
+using Luticate2.Auth.Utils.Dbo.Fields;
+using Luticate2.Auth.Utils.Dbo.Result;
 using Luticate2.Auth.Utils.Interfaces;
 using Microsoft.Extensions.DependencyInjection;
 using Xunit;
@@ -12,7 +17,6 @@ namespace Luticate2.Auth.Tests.Business.ObjectConverter
 {
     public class ObjectConverterTests
     {
-
         protected IServiceProvider GetServiceProvider()
         {
             var typeILuObjectConverterDescriptor = typeof(ILuObjectConverterDescriptor<,>);
@@ -25,6 +29,11 @@ namespace Luticate2.Auth.Tests.Business.ObjectConverter
             services.AddSingleton<ILuObjectConverterDescriptor<TestDbo1, TestModel1>, LuOcdTest1>();
             services.AddSingleton<ILuObjectConverterDescriptor<TestDbo2, TestModel2>, LuOcdTest2>();
 
+
+            services.AddSingleton<ILuObjectConverterIdentity, LuObjectConverterIdentity>();
+            services.AddSingleton<ILuObjectConverter<TestModel1, TestDbo1>, LuObjectConverterPoco<TestModel1, TestDbo1>>();
+            services.AddSingleton<ILuObjectConverter<TestModel2, TestDbo2>, LuObjectConverterPoco<TestModel2, TestDbo2>>();
+
             var serviceProvider = services.BuildServiceProvider();
             return serviceProvider;
         }
@@ -38,194 +47,42 @@ namespace Luticate2.Auth.Tests.Business.ObjectConverter
                 {
                     {typeof(TestDbo1), typeof(TestModel1)},
                     {typeof(TestDbo2), typeof(TestModel2)}
+                },
+                Allocator = type =>
+                {
+                    return Activator.CreateInstance(type);
                 }
             };
             return options;
         }
 
-        protected LuExpressionConverterVisitor GetConverter()
-        {
-            return new LuExpressionConverterVisitor(GetConverterOptions(), GetServiceProvider());
-        }
-
-        [Fact]
-        public void TestSimpleProperty1()
-        {
-            Expression<Func<TestDbo2, Guid>> expDbo = (x => x.TestDbo1.Id);
-            Expression<Func<TestModel2, Guid>> expModel = (Param_0 => Param_0.test_model1.id);
-            var converter = GetConverter();
-            var result = converter.Visit(expDbo);
-            Assert.Equal(expModel.ToString(), result?.ToString());
-        }
-
-        [Fact]
-        public void TestSimpleProperty2()
-        {
-            Expression<Func<TestDbo2, bool>> expDbo = (x => x.TestDbo1.Id == Guid.Empty);
-            Expression<Func<TestModel2, bool>> expModel = (Param_0 => Param_0.test_model1.id == Guid.Empty);
-            var converter = GetConverter();
-            var result = converter.Visit(expDbo);
-            Assert.Equal(expModel.ToString(), result?.ToString());
-        }
-
-        [Fact]
-        public void TestSimpleProperty3()
-        {
-            Expression<Func<TestDbo2, bool>> expDbo = (x => x.TestDbo1.Name.Length == 2);
-            Expression<Func<TestModel2, bool>> expModel = (Param_0 => Param_0.test_model1.name.Length == 2);
-            var converter = GetConverter();
-            var result = converter.Visit(expDbo);
-            Assert.Equal(expModel.ToString(), result?.ToString());
-        }
-
-        [Fact]
-        public void TestStaticProperty1()
-        {
-            Expression<Func<TestDbo2, bool>> expDbo = (x => (x.TestDbo1.Name == "42") == StaticDbo.StaticField);
-            Expression<Func<TestModel2, bool>> expModel = (Param_0 => (Param_0.test_model1.name == "42") == StaticDbo.StaticField);
-            var converter = GetConverter();
-            var result = converter.Visit(expDbo);
-            Assert.Equal(expModel.ToString(), result?.ToString());
-        }
-
-        [Fact]
-        public void TestStaticProperty2()
-        {
-            Expression<Func<TestDbo2, bool>> expDbo = (x => (x.TestDbo1.Name == "42") == StaticDbo.StaticProperty);
-            Expression<Func<TestModel2, bool>> expModel = (Param_0 => (Param_0.test_model1.name == "42") == StaticDbo.StaticProperty);
-            var converter = GetConverter();
-            var result = converter.Visit(expDbo);
-            Assert.Equal(expModel.ToString(), result?.ToString());
-        }
-
-        [Fact]
-        public void TestVirtualProperty1()
-        {
-            Expression<Func<TestDbo2, string>> expDbo = (x => x.NameVirtual);
-            Expression<Func<TestModel2, string>> expModel = (Param_0 => Param_0.name + " " + Param_0.name);
-            var converter = GetConverter();
-            var result = converter.Visit(expDbo);
-            Assert.Equal(expModel.ToString(), result?.ToString());
-        }
-
-        [Fact]
-        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);
-            var converter = GetConverter();
-            var result = converter.Visit(expDbo);
-            Assert.Equal(expModel.ToString(), result?.ToString());
-        }
-
         [Fact]
-        public void TestStaticValue1()
+        void Test1()
         {
-            Expression<Func<TestDbo2, int>> expDbo = (x => 0);
-            Expression<Func<TestModel2, int>> expModel = (Param_0 => 0);
-            var converter = GetConverter();
-            var result = converter.Visit(expDbo);
-            Assert.Equal(expModel.ToString(), result?.ToString());
-        }
-
-        [Fact]
-        public void TestStaticValue2()
-        {
-            Expression<Func<TestDbo2, TestDbo2>> expDbo = (x => x);
-            Expression<Func<TestModel2, TestModel2>> expModel = (Param_0 => Param_0);
-            var converter = GetConverter();
-            var result = converter.Visit(expDbo);
-            Assert.Equal(expModel.ToString(), result?.ToString());
-        }
-
-        [Fact]
-        public void TestStaticValue3()
-        {
-            Expression<Func<TestDbo2, bool>> expDbo = (x => StaticDbo.StaticField);
-            Expression<Func<TestModel2, bool>> expModel = (Param_0 => StaticDbo.StaticField);
-            var converter = GetConverter();
-            var result = converter.Visit(expDbo);
-            Assert.Equal(expModel.ToString(), result?.ToString());
-        }
-
-        [Fact]
-        public void TestComplexExpression1()
-        {
-            Expression<Func<TestDbo2, int>> expDbo = (x => (x.Name + " " + x.Name).Length);
-            Expression<Func<TestModel2, int>> expModel = (Param_0 => (Param_0.name + " " + Param_0.name).Length);
-            var converter = GetConverter();
-            var result = converter.Visit(expDbo);
-            Assert.Equal(expModel.ToString(), result?.ToString());
-        }
-
-        [Fact]
-        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);
-            var converter = GetConverter();
-            var result = converter.Visit(expDbo);
-            Assert.Equal(expModel.ToString(), result?.ToString());
-        }
-
-        [Fact]
-        public void TestSimpleMethodSimpleArg1()
-        {
-            Expression<Func<TestDbo2, bool>> expDbo = (x => x.Name.Contains("s"));
-            Expression<Func<TestModel2, bool>> expModel = (Param_0 => Param_0.name.Contains("s"));
-            var converter = GetConverter();
-            var result = converter.Visit(expDbo);
-            Assert.Equal(expModel.ToString(), result?.ToString());
-        }
-
-        [Fact]
-        public void TestSimpleMethodSimpleArg2()
-        {
-            Expression<Func<TestDbo2, bool>> expDbo = (x => x.TestDbo1.Name.Contains("s"));
-            Expression<Func<TestModel2, bool>> expModel = (Param_0 => Param_0.test_model1.name.Contains("s"));
-            var converter = GetConverter();
-            var result = converter.Visit(expDbo);
-            Assert.Equal(expModel.ToString(), result?.ToString());
-        }
-
-        [Fact]
-        public void TestSimpleMethodSimpleArg3()
-        {
-            Expression<Func<TestDbo2, string>> expDbo = (x => x.TestDbo1.ToString());
-            Expression<Func<TestModel2, string>> expModel = (Param_0 => Param_0.test_model1.id + ": " + Param_0.test_model1.name);
-            var converter = GetConverter();
-            var result = converter.Visit(expDbo);
-            Assert.Equal(expModel.ToString(), result?.ToString());
-        }
-
-        [Fact]
-        public void TestSimpleMethodAdvArg1()
-        {
-            Expression<Func<TestDbo2, bool>> expDbo = (x => x.TestDbo1.Name.Contains(x.Name));
-            Expression<Func<TestModel2, bool>> expModel = (Param_0 => Param_0.test_model1.name.Contains(Param_0.name));
-            var converter = GetConverter();
-            var result = converter.Visit(expDbo);
-            Assert.Equal(expModel.ToString(), result?.ToString());
-        }
-
-        [Fact]
-        public void TestAdvMethodSimpleArg1()
-        {
-            Expression<Func<TestDbo1, bool>> expDbo = (x => x.TestDbo2s.Any());
-            Expression<Func<TestModel1, bool>> expModel = (Param_0 => Param_0.test_model2.Any());
-            var converter = GetConverter();
-            var result = converter.Visit(expDbo);
-            Assert.Equal(expModel.ToString(), result?.ToString());
-        }
-
-        [Fact]
-        public void TestAdvMethodAdvArg1()
-        {
-            Expression<Func<TestDbo1, bool>> expDbo = (x => x.TestDbo2s.Any(y => y.Name.Contains(x.Name + "s")));
-            Expression<Func<TestModel1, bool>> expModel = (Param_0 => Param_0.test_model2.Any(Param_1 => Param_1.name.Contains(Param_0.name + "s")));
-            var converter = GetConverter();
-            var result = converter.Visit(expDbo);
-            Assert.Equal(expModel.ToString(), result?.ToString());
+            var serviceProvider = GetServiceProvider();
+            var converter = serviceProvider.GetService<ILuObjectConverter<TestModel1, TestDbo1>>();
+            var model = new TestModel1
+            {
+                id = Guid.NewGuid(),
+                name = "Test.",
+                test_model2 = new List<TestModel2>
+                {
+                    new TestModel2
+                    {
+                        id = Guid.NewGuid(),
+                        name = "bla",
+                        parent = null,
+                        test_model1 = null,
+                        test_model1_id = Guid.Empty
+                    }
+                }
+            };
+            var result = converter.Convert(model, LuPartialFieldsParser.Parse("*").Data, GetConverterOptions());
+            Assert.Equal(LuStatus.Success.ToInt(), result.Status);
+            var dbo = result.Data as TestDbo1;
+            Assert.NotNull(dbo);
+            Assert.Equal(model.id, dbo.Id);
+            Assert.Equal(model.name, dbo.Name);
         }
     }
 }

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

@@ -18,7 +18,7 @@ namespace Luticate2.Auth.Tests.Business.ObjectConverter
 
         public string Name { get; set; }
 
-        public IList<TestDbo2> TestDbo2s { get; set; }
+//        public IList<TestDbo2> TestDbo2s { get; set; } // TODO
 
         public string ToString()
         {
@@ -69,7 +69,7 @@ namespace Luticate2.Auth.Tests.Business.ObjectConverter
         {
             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.TestDbo2s, y => y.test_model2, PropertyType.Object); // TODO
             AddStaticMethodConverter(
                 (Expression<Func<TestDbo1, string>>)(x => x.ToString()),
                 (Expression<Func<TestModel1, string>>)(x => x.id + ": " + x.name)

Luticate2.Auth.Tests/Business/LuExpressionUtilsTests.cs → Luticate2.Auth.Tests/Business/Utils/LuExpressionUtilsTests.cs

@@ -1,10 +1,10 @@
 using System;
 using System.Linq;
 using System.Linq.Expressions;
-using Luticate2.Auth.Utils.Business;
+using Luticate2.Auth.Utils.Business.Utils;
 using Xunit;
 
-namespace Luticate2.Auth.Tests.Business
+namespace Luticate2.Auth.Tests.Business.Utils
 {
     public class TestDbo1
     {

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

@@ -9,5 +9,7 @@ namespace Luticate2.Auth.Utils.Business.ExpressionConverter
         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

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
+using Luticate2.Auth.Utils.Business.Utils;
 using Luticate2.Auth.Utils.Dbo;
 using Luticate2.Auth.Utils.Dbo.Result;
 using Luticate2.Auth.Utils.Exceptions;
@@ -70,7 +71,7 @@ namespace Luticate2.Auth.Utils.Business.ExpressionConverter
                     $"Could not find converter descriptor for {typeFrom} => {typeTo}");
             }
 
-            var valueExpression = descriptor.GetMemberValueExpression(memberExpression.Member, Options.Types);
+            var valueExpression = descriptor.GetMemberValueExpression(memberExpression.Member, Options);
             if (valueExpression == null)
             {
                 return LuResult<Expression>.Error(LuStatus.InternalError.ToInt(),
@@ -88,8 +89,7 @@ namespace Luticate2.Auth.Utils.Business.ExpressionConverter
             }
 
             var visitor = new LuExpressionParamReplaceVisitor(Options);
-            var replacedExpression = visitor.Visit(valueExpression.Body);
-            newExpression = LuExpressionUtils.GetFromConvert(replacedExpression);
+            newExpression = visitor.Visit(valueExpression.Body);
 
             if (newExpression != null)
             {
@@ -109,7 +109,7 @@ namespace Luticate2.Auth.Utils.Business.ExpressionConverter
                     $"Could not find converter descriptor for {typeFrom} => {typeTo}");
             }
 
-            var valueExpression = descriptor.GetMethodValueExpression(methodCallExpression.Method, Options.Types);
+            var valueExpression = descriptor.GetMethodValueExpression(methodCallExpression.Method, Options);
             if (valueExpression == null)
             {
                 return LuResult<Expression>.Error(LuStatus.InternalError.ToInt(),
@@ -134,8 +134,7 @@ namespace Luticate2.Auth.Utils.Business.ExpressionConverter
             }
             Options.Parameters.Add(valueExpression.Parameters[0], newExpression);
             var visitor = new LuExpressionParamReplaceVisitor(Options);
-            var replacedExpression = visitor.Visit(valueExpression.Body);
-            newExpression = LuExpressionUtils.GetFromConvert(replacedExpression);
+            newExpression = visitor.Visit(valueExpression.Body);
             Options.Parameters.Remove(valueExpression.Parameters[0]);
 
             return LuResult<Expression>.Ok(newExpression);

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

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

Luticate2.Auth/Utils/Business/Fields/LuFieldsExtensions.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
 using System.Text.RegularExpressions;
+using Luticate2.Auth.Utils.Business.Utils;
 using Luticate2.Auth.Utils.Dbo.Fields;
 
 namespace Luticate2.Auth.Utils.Business.Fields

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

@@ -0,0 +1,68 @@
+using System;
+using Luticate2.Auth.Utils.Business.ExpressionConverter;
+using Luticate2.Auth.Utils.Business.Utils;
+using Luticate2.Auth.Utils.Dbo.Fields;
+using Luticate2.Auth.Utils.Dbo.Result;
+using Luticate2.Auth.Utils.Interfaces;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Luticate2.Auth.Utils.Business.ObjectConverter
+{
+    public class LuObjectConverterPoco<TTypeFrom, TTypeTo> : ILuObjectConverter<TTypeFrom, TTypeTo>
+    {
+        protected IServiceProvider ServiceProvider { get; }
+
+        public LuObjectConverterPoco(IServiceProvider serviceProvider)
+        {
+            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)
+        {
+            // TODO Check if this is correct
+            if (srcObj == null)
+            {
+                return LuResult<object>.Ok(default(TTypeTo));
+            }
+            // TODO Handle descriptor == null
+            var descriptor = ServiceProvider.GetService<ILuObjectConverterDescriptor<TTypeTo, TTypeFrom>>();
+            var typeTo = typeof(TTypeTo);
+            var dstObj = options.Allocator(typeTo);
+
+            foreach (var memberInfo in typeTo.GetProperties())
+            {
+                // TODO check if field is included in fields
+                // TODO Handle valueExpression == 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)
+                {
+                    return dstProp;
+                }
+                var result = LuExpressionUtils.SetValueFromMember(memberInfo, dstObj, dstProp.Data);
+                if (!result)
+                {
+                    return result.To<object>();
+                }
+            }
+
+            return LuResult<object>.Ok(dstObj);
+        }
+    }
+}

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

@@ -3,6 +3,8 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
 using System.Reflection;
+using Luticate2.Auth.Utils.Business.ExpressionConverter;
+using Luticate2.Auth.Utils.Business.Utils;
 using Luticate2.Auth.Utils.Interfaces;
 
 namespace Luticate2.Auth.Utils.Business.ObjectConverterDescriptor
@@ -41,7 +43,7 @@ namespace Luticate2.Auth.Utils.Business.ObjectConverterDescriptor
             var memberInfo = LuExpressionUtils.GetSingleMemberFromExpression(memberFrom);
             StaticMemberConverters.Add(memberInfo, new LuObjectConverterDescriptorMemberInfo
             {
-                ValueExpression = valueExpression,
+                ValueExpression = LuExpressionUtils.GetFromConvert(valueExpression),
                 PropertyType = propertyType
             });
         }
@@ -52,7 +54,7 @@ namespace Luticate2.Auth.Utils.Business.ObjectConverterDescriptor
             var methodInfo = LuExpressionUtils.GetSingleMethodFromExpression(methodFrom);
             StaticMethodConverters.Add(methodInfo, new LuObjectConverterDescriptorMethodInfo
             {
-                ValueExpression = valueExpression
+                ValueExpression = LuExpressionUtils.GetFromConvert(valueExpression)
             });
         }
 
@@ -79,7 +81,8 @@ namespace Luticate2.Auth.Utils.Business.ObjectConverterDescriptor
                     var methodParams = templateMethodInfo.GetParameters().Select(x => Expression.Parameter(x.ParameterType)).ToList();
                     lambdaParams.AddRange(methodParams);
                     var methodCallExpression = Expression.Call(templateMethodInfo.IsStatic ? null : lambdaParams[0], templateMethodInfo, methodParams);
-                    var lambda = Expression.Lambda(methodCallExpression, lambdaParams);
+                    var body = LuExpressionUtils.GetFromConvert(methodCallExpression);
+                    var lambda = Expression.Lambda(body, lambdaParams);
 
                     return new LuObjectConverterDescriptorMethodInfo
                     {
@@ -89,7 +92,7 @@ namespace Luticate2.Auth.Utils.Business.ObjectConverterDescriptor
             );
         }
 
-        public LambdaExpression GetMemberValueExpression(MemberInfo memberInfo, IDictionary<Type, Type> types)
+        public LambdaExpression GetMemberValueExpression(MemberInfo memberInfo, LuExpressionConverterOptions options)
         {
             if (StaticMemberConverters.ContainsKey(memberInfo))
             {
@@ -99,7 +102,7 @@ namespace Luticate2.Auth.Utils.Business.ObjectConverterDescriptor
             return null;
         }
 
-        public LambdaExpression GetMethodValueExpression(MethodInfo methodInfo, IDictionary<Type, Type> types)
+        public LambdaExpression GetMethodValueExpression(MethodInfo methodInfo, LuExpressionConverterOptions options)
         {
             if (StaticMethodConverters.ContainsKey(methodInfo))
             {
@@ -109,7 +112,7 @@ namespace Luticate2.Auth.Utils.Business.ObjectConverterDescriptor
             var genericMethodInfo = methodInfo.GetGenericMethodDefinition();
             if (DynamicMethodConverters.ContainsKey(genericMethodInfo))
             {
-                var result = DynamicMethodConverters[genericMethodInfo](methodInfo, types);
+                var result = DynamicMethodConverters[genericMethodInfo](methodInfo, options.Types);
                 if (result != null)
                 {
                     return result.ValueExpression;

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

@@ -1,15 +1,15 @@
-using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
 using System.Reflection;
+using Luticate2.Auth.Utils.Business.ExpressionConverter;
 using Luticate2.Auth.Utils.Interfaces;
 
 namespace Luticate2.Auth.Utils.Business.ObjectConverterDescriptor
 {
     public class LuObjectConverterDescriptorIdentity : ILuObjectConverterDescriptorIdentity
     {
-        public LambdaExpression GetMemberValueExpression(MemberInfo memberInfo, IDictionary<Type, Type> types)
+        public LambdaExpression GetMemberValueExpression(MemberInfo memberInfo, LuExpressionConverterOptions options)
         {
             var isStatic = false;
             if (memberInfo is FieldInfo fieldInfo)
@@ -26,7 +26,7 @@ namespace Luticate2.Auth.Utils.Business.ObjectConverterDescriptor
             return lambda;
         }
 
-        public LambdaExpression GetMethodValueExpression(MethodInfo methodInfo, IDictionary<Type, Type> types)
+        public LambdaExpression GetMethodValueExpression(MethodInfo methodInfo, LuExpressionConverterOptions options)
         {
             var lambdaParams = new List<ParameterExpression>
             {

Luticate2.Auth/Utils/Business/PartialObjectCopier/LuPartialObjectCopier.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Linq.Expressions;
 using Luticate2.Auth.Utils.Business.Fields;
+using Luticate2.Auth.Utils.Business.Utils;
 using Luticate2.Auth.Utils.Dbo;
 using Luticate2.Auth.Utils.Dbo.Fields;
 using Luticate2.Auth.Utils.Dbo.PartialObjectCopier;

Luticate2.Auth/Utils/Business/Utils/LuCoreExtension.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Reflection;
+
+namespace Luticate2.Auth.Utils.Business.Utils
+{
+    public static class LuCoreExtension
+    {
+        public static Type GetUnderlyingType(this MemberInfo member)
+        {
+            switch (member.MemberType)
+            {
+                case MemberTypes.Event:
+                    return ((EventInfo)member).EventHandlerType;
+                case MemberTypes.Field:
+                    return ((FieldInfo)member).FieldType;
+                case MemberTypes.Method:
+                    return ((MethodInfo)member).ReturnType;
+                case MemberTypes.Property:
+                    return ((PropertyInfo)member).PropertyType;
+                default:
+                    throw new ArgumentException
+                    (
+                        "Input MemberInfo must be if type EventInfo, FieldInfo, MethodInfo, or PropertyInfo"
+                    );
+            }
+        }
+    }
+}

Luticate2.Auth/Utils/Business/LuExpressionUtils.cs → Luticate2.Auth/Utils/Business/Utils/LuExpressionUtils.cs

@@ -6,62 +6,73 @@ using System.Reflection;
 using Luticate2.Auth.Utils.Dbo;
 using Luticate2.Auth.Utils.Dbo.Result;
 
-namespace Luticate2.Auth.Utils.Business
+namespace Luticate2.Auth.Utils.Business.Utils
 {
     public static class LuExpressionUtils
     {
         public static Expression GetFromConvert(Expression exp)
         {
-            Expression e = exp;
             if (exp is LambdaExpression lambdaExpression)
             {
-                e = lambdaExpression.Body;
+                return GetFromConvert(lambdaExpression);
             }
 
-            Expression operand;
-            if ((e.NodeType == ExpressionType.Convert ||
-                 e.NodeType == ExpressionType.ConvertChecked)
-                && e is UnaryExpression)
+            if ((exp.NodeType == ExpressionType.Convert ||
+                 exp.NodeType == ExpressionType.ConvertChecked)
+                && exp is UnaryExpression)
             {
-                operand = ((UnaryExpression) e).Operand;
+                return ((UnaryExpression) exp).Operand;
             }
             else
             {
-                operand = e;
+                return exp;
             }
-            return operand;
+        }
+
+        public static LambdaExpression GetFromConvert(LambdaExpression exp)
+        {
+            var body = GetFromConvert(exp.Body);
+            var lambda = Expression.Lambda(body, exp.Parameters);
+
+            return lambda;
         }
 
         public static Expression<Func<TType1, TType3>> AddConvert<TType1, TType2, TType3>(Expression<Func<TType1, TType2>> exp)
         {
-            var converted = Expression.Convert(exp, typeof(object));
+            var converted = Expression.Convert(exp.Body, typeof(TType3));
             var expLambda = Expression.Lambda<Func<TType1, TType3>>(converted, exp.Parameters);
             return expLambda;
         }
 
         public static LuResult<TProperty> SetValueFromExpression<TDbo, TProperty>(Expression<Func<TDbo, TProperty>> property,
-            TDbo dboTo, TProperty value)
+            TDbo dstObj, TProperty value)
         {
             var memberInfo = GetSingleMemberFromExpression(property);
             if (memberInfo != null)
             {
-                switch (memberInfo.MemberType)
-                {
-                    case MemberTypes.Field:
-                        ((FieldInfo) memberInfo).SetValue(dboTo, value);
-                        return LuResult<TProperty>.Ok(value);
-                    case MemberTypes.Property:
-                        ((PropertyInfo) memberInfo).SetValue(dboTo, value);
-                        return LuResult<TProperty>.Ok(value);
-                    default:
-                        return LuResult<TProperty>.Error(LuStatus.InternalError.ToInt(),
-                            $"Bad MemberType: {memberInfo.MemberType}");
-                }
+                return SetValueFromMember(memberInfo, dstObj, value);
             }
 
             return LuResult<TProperty>.Error(LuStatus.InternalError.ToInt(), "Bad member expression");
         }
 
+        public static LuResult<TProperty> SetValueFromMember<TDbo, TProperty>(MemberInfo memberInfo,
+            TDbo dstObj, TProperty value)
+        {
+            switch (memberInfo.MemberType)
+            {
+                case MemberTypes.Field:
+                    ((FieldInfo) memberInfo).SetValue(dstObj, value);
+                    return LuResult<TProperty>.Ok(value);
+                case MemberTypes.Property:
+                    ((PropertyInfo) memberInfo).SetValue(dstObj, value);
+                    return LuResult<TProperty>.Ok(value);
+                default:
+                    return LuResult<TProperty>.Error(LuStatus.InternalError.ToInt(),
+                        $"Bad MemberType: {memberInfo.MemberType}");
+            }
+        }
+
         public static LuResult<TProperty> GetValueFromExpression<TDbo, TProperty>(Expression<Func<TDbo, TProperty>> property,
             TDbo dboTo)
         {
@@ -88,7 +99,7 @@ namespace Luticate2.Auth.Utils.Business
 
         public static MemberInfo GetSingleMemberFromExpression(LambdaExpression property)
         {
-            if (GetFromConvert(property) is MemberExpression memberExpression &&
+            if (GetFromConvert(property.Body) is MemberExpression memberExpression &&
                 (memberExpression.Expression == property.Parameters.First() ||
                  (memberExpression.Expression == null && memberExpression.Member.DeclaringType == property.Parameters.First().Type)))
             {
@@ -100,7 +111,7 @@ namespace Luticate2.Auth.Utils.Business
         public static MethodInfo GetSingleMethodFromExpression(LambdaExpression method)
         {
             // TODO check if something like methodCallExpression.Method.DeclaringType == method.Parameters.First().Type is usefull/required (static/extension methods)
-            if (GetFromConvert(method) is MethodCallExpression methodCallExpression &&
+            if (GetFromConvert(method.Body) is MethodCallExpression methodCallExpression &&
                 (methodCallExpression.Object == method.Parameters.First() || methodCallExpression.Object == null))
             {
                 return methodCallExpression.Method;

Luticate2.Auth/Utils/Interfaces/ILuObjectConverter.cs

@@ -0,0 +1,19 @@
+using Luticate2.Auth.Utils.Business.ExpressionConverter;
+using Luticate2.Auth.Utils.Dbo.Fields;
+using Luticate2.Auth.Utils.Dbo.Result;
+
+namespace Luticate2.Auth.Utils.Interfaces
+{
+    public interface ILuObjectConverter
+    {
+        LuResult<object> Convert(object srcObj, LuPartialFieldsDbo fields, LuExpressionConverterOptions options);
+    }
+
+    public interface ILuObjectConverter<TTypeFrom, TTypeTo> : ILuObjectConverter
+    {
+    }
+
+    public interface ILuObjectConverterIdentity : ILuObjectConverter
+    {
+    }
+}

Luticate2.Auth/Utils/Interfaces/ILuObjectConverterDescriptor.cs

@@ -1,15 +1,14 @@
-using System;
-using System.Collections.Generic;
 using System.Linq.Expressions;
 using System.Reflection;
+using Luticate2.Auth.Utils.Business.ExpressionConverter;
 
 namespace Luticate2.Auth.Utils.Interfaces
 {
     public interface ILuObjectConverterDescriptor
     {
-        LambdaExpression GetMemberValueExpression(MemberInfo memberInfo, IDictionary<Type, Type> types);
+        LambdaExpression GetMemberValueExpression(MemberInfo memberInfo, LuExpressionConverterOptions options);
 
-        LambdaExpression GetMethodValueExpression(MethodInfo methodInfo, IDictionary<Type, Type> types);
+        LambdaExpression GetMethodValueExpression(MethodInfo methodInfo, LuExpressionConverterOptions options);
     }
 
     public interface ILuObjectConverterDescriptor<TTypeFrom, TTypeTo> : ILuObjectConverterDescriptor