Removed unused imports; Added new interfaces for LuConvertersOptions

Luticate2.Auth.ConsoleSample/Program.cs

 using System;
 using Luticate2.Auth.Auth.Business;
 using Luticate2.Auth.Auth.DataAccess;
-using Luticate2.Auth.Auth.DataAccess.Models;
-using Luticate2.Auth.Auth.Dbo;
 using Luticate2.Auth.ConsoleSample.Commands;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.DependencyInjection;

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

             return serviceProvider;
         }
 
-        protected LuConvertersOptions GetConverterOptions()
+        protected ILuExpressionConverterVisitorOptions GetConverterOptions()
         {
             var options = new LuConvertersOptions
             {

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

             return serviceProvider;
         }
 
-        protected LuConvertersOptions GetConverterOptions()
+        protected ILuObjectConverterOptions GetConverterOptions()
         {
             var options = new LuConvertersOptions
             {

Luticate2.Auth.Tests/RandomTests.cs

-using Luticate2.Auth.Utils.Business.ObjectConverter;
-using Xunit;
+using Xunit;
 
 namespace Luticate2.Auth.Tests
 {

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;

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

 using System.Collections.Generic;
 using System.Linq.Expressions;
+using Luticate2.Auth.Utils.Business.ExpressionConverter;
 using Luticate2.Auth.Utils.Interfaces;
 
 namespace Luticate2.Auth.Utils.Business.Converters
 {
-    public class LuConvertersOptions
+    public class LuConvertersOptions : ILuObjectConverterOptions, ILuObjectConverterDescriptorOptions,
+        ILuExpressionConverterVisitorOptions, ILuExpressionParamReplaceVisitorOptions
     {
         public IDictionary<ParameterExpression, Expression> Parameters { get; set; }
 
         public ILuConvertersTypeConverter TypeConverter { get; set; }
 
         public ILuConvertersAllocator Allocator { get; set; }
+
+        public ILuObjectConverterDescriptorOptions DescriptorOptions => this;
+
+        public ILuExpressionParamReplaceVisitorOptions VisitorOptions => this;
     }
 }

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

             ServiceProvider = serviceProvider;
         }
 
-        protected virtual LuConvertersOptions GetOptions()
+        protected virtual ILuObjectConverterOptions GetOptions()
         {
             return new LuConvertersOptions();// TODO
         }

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

 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;
 using Luticate2.Auth.Utils.Exceptions;
 
 namespace Luticate2.Auth.Utils.Business.ExpressionConverter
 {
+    public interface ILuExpressionConverterVisitorOptions
+    {
+        IDictionary<ParameterExpression, Expression> Parameters { get; }
+
+        ILuConvertersTypeConverter TypeConverter { get; }
+
+        ILuObjectConverterDescriptorOptions DescriptorOptions { get; }
+
+        ILuExpressionParamReplaceVisitorOptions VisitorOptions { get; }
+    }
+
     public class LuExpressionConverterVisitor : ExpressionVisitor
     {
-        public LuConvertersOptions Options { get; }
+        public ILuExpressionConverterVisitorOptions Options { get; }
 
         protected IServiceProvider ServiceProvider { get; }
 
-        public LuExpressionConverterVisitor(LuConvertersOptions options, IServiceProvider serviceProvider)
+        public LuExpressionConverterVisitor(ILuExpressionConverterVisitorOptions options, IServiceProvider serviceProvider)
         {
             Options = options;
             ServiceProvider = serviceProvider;
                     $"Could not find converter descriptor for {typeFrom} => {typeTo}");
             }
 
-            var valueExpression = descriptor.GetMemberValueExpression(memberExpression.Member, Options);
+            var valueExpression = descriptor.GetMemberValueExpression(memberExpression.Member, Options.DescriptorOptions);
             if (valueExpression == null)
             {
                 return LuResult<Expression>.Error(LuStatus.InternalError.ToInt(),
                 Options.Parameters.Add(valueExpression.Parameters[0], newExpression);
             }
 
-            var visitor = new LuExpressionParamReplaceVisitor(Options);
+            var visitor = new LuExpressionParamReplaceVisitor(Options.VisitorOptions);
             newExpression = visitor.Visit(valueExpression.Body);
 
             if (newExpression != null)
                     $"Could not find converter descriptor for {typeFrom} => {typeTo}");
             }
 
-            var valueExpression = descriptor.GetMethodValueExpression(methodCallExpression.Method, Options);
+            var valueExpression = descriptor.GetMethodValueExpression(methodCallExpression.Method, Options.DescriptorOptions);
             if (valueExpression == null)
             {
                 return LuResult<Expression>.Error(LuStatus.InternalError.ToInt(),
                 Options.Parameters.Add(valueExpression.Parameters[i + 1], convertedArgument);
             }
             Options.Parameters.Add(valueExpression.Parameters[0], newExpression);
-            var visitor = new LuExpressionParamReplaceVisitor(Options);
+            var visitor = new LuExpressionParamReplaceVisitor(Options.VisitorOptions);
             newExpression = visitor.Visit(valueExpression.Body);
             Options.Parameters.Remove(valueExpression.Parameters[0]);
 

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

+using System.Collections.Generic;
 using System.Linq.Expressions;
 using Luticate2.Auth.Utils.Business.Converters;
 using Luticate2.Auth.Utils.Dbo;
 
 namespace Luticate2.Auth.Utils.Business.ExpressionConverter
 {
+    public interface ILuExpressionParamReplaceVisitorOptions
+    {
+        IDictionary<ParameterExpression, Expression> Parameters { get; }
+    }
+
     public class LuExpressionParamReplaceVisitor : ExpressionVisitor
     {
-        public LuConvertersOptions Options { get; }
+        public ILuExpressionParamReplaceVisitorOptions Options { get; }
 
-        public LuExpressionParamReplaceVisitor(LuConvertersOptions options)
+        public LuExpressionParamReplaceVisitor(ILuExpressionParamReplaceVisitorOptions options)
         {
             Options = options;
         }

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;
 {
     public class LuObjectConverterIdentity : ILuObjectConverterIdentity
     {
-        public LuResult<object> Convert(object srcObj, LuPartialFieldsDbo fields, LuConvertersOptions options)
+        public LuResult<object> Convert(object srcObj, LuPartialFieldsDbo fields, ILuObjectConverterOptions options)
         {
             return LuResult<object>.Ok(srcObj);
         }

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

 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;
 
         protected abstract Type GetListType();
 
-        public LuResult<object> Convert(object srcObj, LuPartialFieldsDbo fields, LuConvertersOptions options)
+        public LuResult<object> Convert(object srcObj, LuPartialFieldsDbo fields, ILuObjectConverterOptions options)
         {
             if (srcObj is IEnumerable enumerable)
             {

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

 using System;
-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;
         }
 
-        public LuResult<object> Convert(object srcObj, LuPartialFieldsDbo fields, LuConvertersOptions options)
+        public LuResult<object> Convert(object srcObj, LuPartialFieldsDbo fields, ILuObjectConverterOptions options)
         {
             // TODO Check if this is correct
             if (srcObj == null)
             {
                 // TODO check if field is included in fields
                 // TODO Handle srcPropExpression == null
-                var srcPropExpression = descriptor.GetMemberValueExpression(memberInfo, options);
+                var srcPropExpression = descriptor.GetMemberValueExpression(memberInfo, options.DescriptorOptions);
                 var srcPropDelegate = srcPropExpression.Compile();
                 var srcProp = srcPropDelegate.DynamicInvoke(srcObj);
                 var srcType = srcProp != null ? srcProp.GetType() : srcPropExpression.ReturnType;

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 LambdaExpression GetMemberValueExpression(MemberInfo memberInfo, LuConvertersOptions options)
+        public LambdaExpression GetMemberValueExpression(MemberInfo memberInfo, ILuObjectConverterDescriptorOptions options)
         {
             if (StaticMemberConverters.ContainsKey(memberInfo))
             {
             return null;
         }
 
-        public LambdaExpression GetMethodValueExpression(MethodInfo methodInfo, LuConvertersOptions options)
+        public LambdaExpression GetMethodValueExpression(MethodInfo methodInfo, ILuObjectConverterDescriptorOptions options)
         {
             if (StaticMethodConverters.ContainsKey(methodInfo))
             {

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;
 
 namespace Luticate2.Auth.Utils.Business.ObjectConverterDescriptor
 {
     public class LuObjectConverterDescriptorIdentity : ILuObjectConverterDescriptorIdentity
     {
-        public LambdaExpression GetMemberValueExpression(MemberInfo memberInfo, LuConvertersOptions options)
+        public LambdaExpression GetMemberValueExpression(MemberInfo memberInfo, ILuObjectConverterDescriptorOptions options)
         {
             var isStatic = false;
             if (memberInfo is FieldInfo fieldInfo)
             return lambda;
         }
 
-        public LambdaExpression GetMethodValueExpression(MethodInfo methodInfo, LuConvertersOptions options)
+        public LambdaExpression GetMethodValueExpression(MethodInfo methodInfo, ILuObjectConverterDescriptorOptions options)
         {
             var lambdaParams = new List<ParameterExpression>
             {

Luticate2.Auth/Utils/Dbo/Fields/LuFieldDbo.cs

 using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Linq.Expressions;
 using Luticate2.Auth.Utils.Business.Fields;
 

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;
 
 namespace Luticate2.Auth.Utils.Interfaces
 {
+    public interface ILuObjectConverterOptions
+    {
+        ILuConvertersTypeConverter TypeConverter { get; }
+
+        ILuConvertersAllocator Allocator { get; }
+
+        ILuObjectConverterDescriptorOptions DescriptorOptions { get; }
+    }
+
     public interface ILuObjectConverter
     {
-        LuResult<object> Convert(object srcObj, LuPartialFieldsDbo fields, LuConvertersOptions options);
+        LuResult<object> Convert(object srcObj, LuPartialFieldsDbo fields, ILuObjectConverterOptions 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 ILuObjectConverterDescriptorOptions
+    {
+        ILuConvertersTypeConverter TypeConverter { get; }
+    }
+
     public interface ILuObjectConverterDescriptor
     {
-        LambdaExpression GetMemberValueExpression(MemberInfo memberInfo, LuConvertersOptions options);
+        LambdaExpression GetMemberValueExpression(MemberInfo memberInfo, ILuObjectConverterDescriptorOptions options);
 
-        LambdaExpression GetMethodValueExpression(MethodInfo methodInfo, LuConvertersOptions options);
+        LambdaExpression GetMethodValueExpression(MethodInfo methodInfo, ILuObjectConverterDescriptorOptions options);
     }
 
     public interface ILuObjectConverterDescriptor<TTypeFrom, TTypeTo> : ILuObjectConverterDescriptor