Passing a type created in Runtime for a statistical method

Question

EDIT

My problem is this.

I need to generate a lambda expression that is of a type that I will only know at the time of execution, IE, the type to be used will be passed in the parameter classType of the controller below. But the type I create in the Runtime method is not compatible with the expression I need to create.

NOTE: The Whereequalsnontyped method recognizes the type of the generated context, but when using typeof() it returns the type 'System.Object'.

Below is the controller calling the method to get the class type dynamically:

 [Route ("{classtype} / {id} / {key}")]
    public string GetObter (int id, string key, string classtype)
    {
        var attach = servico.ObterDinamico (classtype, id, includes);
        return attach.RetrieveFiles (key);
    }
}

Method that creates context from the past type:

public object ObterDinamico(string typeName, int id, string [] includes = null)
    {
        Type tableEntity = Type.GetType ("My_Domain." + TypeName + ", My_Domain");

        IEnumerable <dynamic> dbObject = (IEnumerable <dynamic>)
                            typeof (DbContext) .GetMethod ("Set", Type.EmptyTypes)
                            .MakeGenericMethod (tableEntity)
                            .Invoke (bd, null);
        IQueryable <dynamic> result = dbObject.AsQueryable ();
        if (includes! = null)
            foreach (string i in includes)
                result = result.Include (i);
        return result.WhereEqualsNonTyped ("id", id, typeName);
    }

lambda method that does not recognize the type T in this case, so does not generate the expression as accurate:

public static IQueryable <T> WhereEqualsNonTyped <T> (this IQueryable <T> query, string propertyName, dynamic value, string typeName)
{
    try
    {
        //sem essa instancia do Type para gerar o tipo dinâmico que preciso 
        //o método sempre dá erro assim que chega na linha 
        //MemberExpression
        var type = Type.GetType ("My_Domain." + typeName + ", My_Domain");
        ParameterExpression parameter = Expression.Parameter (type, "type");
        MemberExpression property = Expression.Property (parameter, propertyName);
        BinaryExpression expression = Expression.Equal (property, Expression.Constant (value, value.GetType ()));
        Expression <Func <T, bool >> predicate = Expression.Lambda <Func <T, bool >> (expression, parameter);
        return query.Where (predicate);
    }
    catch (Exception e)
    {
        return query;
    }
}

Currently the error that is generated is:

Parameterexpression of type 'My_domain.my_object' cannot be used to delegate the System.Object type parameter'

Answer 1

PROBLEM SOLVED

I managed to solve my problem in a very simple way, after some extensive researches I saw that my problem was actually to pass a dynamic type generated in Runtime, to a static method. And I was able to solve it through reflection.

Below follows my problem solved:

Controller que chama o método obterDinamico:
        [Route("{classtype}/{id}/{key}")]
        public string GetObter(int id, string key, string classtype)
        {
            var attach = servico.ObterDinamico(classtype, id, includes);
            return attach.RetrieveFiles(key);
        }

The solution of the problem, was carried out in the method to obtain all:

       public object ObterDinamico(string typeName, int id, string[] includes = null)
        {
            Type tableEntity = Type.GetType("My_Domain." + typeName + ", My_Domain");
            IQueryable<dynamic> dbObject = (IQueryable<dynamic>)
                                typeof(DbContext).GetMethod("Set", Type.EmptyTypes)
                                .MakeGenericMethod(tableEntity)
                                .Invoke(bd, null);
            IQueryable<dynamic> result = dbObject.AsQueryable();
//Chamo os metodos que preciso através da reflexão e com isso ele é instanciado com o tipo do objeto que é criado em runtime. Com isso meu problema foi resolvido
            MethodInfo notExcludeMethodInfo = typeof(ReflectionHelper).GetMethod("NaoExcluidos", BindingFlags.Public | BindingFlags.Static).MakeGenericMethod(tableEntity);
            MethodInfo whereEqualsMethodInfo = typeof(ReflectionHelper).GetMethod("WhereEquals", BindingFlags.Public | BindingFlags.Static).MakeGenericMethod(tableEntity);
            if (includes != null)
                foreach (string i in includes)
                    result = result.Include(i);
            result = (IQueryable<dynamic>)notExcludeMethodInfo.Invoke(null, new object[] { result });
            result = (IQueryable<dynamic>)whereEqualsMethodInfo.Invoke(null, new object[] { result, "id", id });
            return result.FirstOrDefault();
        }

One of the methods that are instantiated through reflection:

public static IQueryable<T> WhereEquals<T>(this IQueryable<T> query, string propertyName, dynamic value)
        {
            try
            {
                ParameterExpression parameter = Expression.Parameter(typeof(T), "type");
                MemberExpression property = Expression.Property(parameter, propertyName);
                BinaryExpression expressao = Expression.Equal(property, Expression.Constant(value, value.GetType()));
                Expression<Func<T, bool>> predicate = Expression.Lambda<Func<T, bool>>(expressao, parameter);
                return query.Where(predicate);
            }
            catch (Exception e)
            {
                return query;
            }
        }