Frage

Bedenken Sie:

var propertyinfo = typeof(Customer).GetProperty(sortExpressionStr);
Type orderType = propertyinfo.PropertyType;

jetzt möchte ich erklären

Func<int,orderType>

Ich weiß, dass es nicht direkt möglich ist, da ordertype zur Laufzeit ist, aber gibt es einen Workaround?

Genau das möchte ich tun:

var propertyinfo = typeof(T).GetProperty(sortExpressionStr);
Type orderType = propertyinfo.PropertyType;

var param = Expression.Parameter(typeof(T), "x");
var sortExpression = (Expression.Lambda<Func<T, orderType>>
   (Expression.Convert(Expression.Property(param, sortExpressionStr), typeof(orderType)), param));

all das, weil ich konvertieren will:

Expression<Func<T,object>> to Expression<Func<T,orderType>>

oder wenn es nicht möglich ist, dann möchte ich es von der ersten Stelle mit dem richtigen Typ erstellen, der Fall ist wie folgt:

Ich bin innerhalb einer Methode, die einen type(Customer) und einen Eigenschaftsnamen des Typs, den ich von ihm bestellen möchte, Ich möchte einen Orderby erstellen, um es an Orderby (hier) zu übergeben.

Akzeptierte Antwort

linqClass.OrderBy(GetSortExpression(sortstr));


public static Expression<Func<T,object>> GetSortExpression<T>(string sortExpressionStr)
    {
        var param = Expression.Parameter(typeof(T), "x");
        var sortExpression = Expression.Lambda<Func<T, object>>(Expression.Property(param, sortExpressionStr), param);
        return sortExpression;
    }

das funktionierte mein Problem war, dass ich extra Parameter Typeof (Object) und orderby übergeben habe, um mir zu sagen, dass es nicht nach Objekttyp sortiert werden kann. Danke allen

Danke dtb Ich werde überprüfen, ob Ihre Antwort auch funktioniert, und ich werde es akzeptieren, wenn es funktioniert, wenn nicht, werde ich thsi eins akzeptieren.


Beliebte Antwort

Sie können dies tun, indem Sie eine offene generische Typdefinition verwenden und dann den spezifischen Typ daraus machen:

typeof(Func<,>).MakeGenericType(typeof(int), orderType);

Was Sie jedoch versuchen (Aufruf von Lambda<TDelegate> ), ist nicht direkt möglich. Sie müssen Lambda ohne einen Typparameter aufrufen:

var propertyinfo = typeof(T).GetProperty(sortExpressionStr);
Type orderType = propertyinfo.PropertyType;

var param = Expression.Parameter(typeof(T), "x");
var sortExpression = Expression.Lambda(
        Expression.Convert(Expression.Property(param, sortExpressionStr),
                           orderType), 
        param));

Dies wird den richtigen Func<,> für Sie hinter den Kulissen schaffen. Wenn Sie den Ausdruck kompilieren und den Delegaten verwenden möchten, können Sie dies nur dynamisch mit tun

sortExpression.Compile().DynamicInvoke(param);

Wenn Sie die Methode Queryable auf Queryable OrderBy Queryable , werden die Dinge ein wenig komplizierter:

var propertyInfo = typeof(T).GetProperty(sortExpressionStr);
Type orderType = propertyInfo.PropertyType;

// first find the OrderBy method with no types specified
MethodInfo method = typeof(Queryable).GetMethods()
  .Where(m => m.Name == "OrderBy" && m.GetParameters().Length == 2)
  .Single();
// then make the right version by supplying the right types
MethodInfo concreteMethod = method.MakeGenericMethod(typeof(T), orderType);

var param = Expression.Parameter(typeof(T), "x");

// the key selector for the OrderBy method
Expression orderBy =
    Expression.Lambda(
        Expression.Property(orderParam, propertyInfo),
        orderParam);

// how to use:
var sequence = new T[0].AsQueryable(); // sample IQueryable

// because no types are known in advance, we need to call Invoke 
// through relection here
IQueryable result = (IQueryable) concreteMethod.Invoke(
                                   null, // = static
                                   new object[] { sequence, orderBy });


Lizenziert unter: CC-BY-SA with attribution
Nicht verbunden mit Stack Overflow
Ist diese KB legal? Ja, lerne warum
Lizenziert unter: CC-BY-SA with attribution
Nicht verbunden mit Stack Overflow
Ist diese KB legal? Ja, lerne warum