ERREUR La méthode statique nécessite une instance nulle, la méthode non statique une instance non nulle

c#-4.0 expression-trees lambda linq static-methods

Question

J'essaie de créer un arbre d'expression. J'ai besoin de lire les données d'une table de données et de vérifier ses colonnes. Les colonnes à vérifier ainsi que le nombre de colonnes à vérifier sont uniquement connus au moment de l'exécution. Les noms de colonne me sont donnés sous forme de tableau de chaînes et chaque colonne contient une liste de chaînes à vérifier. J'ai essayé des exemples d'arbres d'expression, comme celui ci-dessous.

Ici, je rencontre une erreur.

La méthode statique nécessite une instance nulle, la méthode non statique une instance non nulle. Nom du paramètre: instance

à la ligne

inner = Expression.Call (rowexp, mi, colexp);

Aidez-moi gentiment !!!

IQueryable<DataRow> queryableData = CapacityTable
    .AsEnumerable()
    .AsQueryable()
    .Where(row2 => values.Contains(row2.Field<string>("Head1").ToString()) 
                && values.Contains(row2.Field<string>("Head2").ToString()));

MethodInfo mi = typeof(DataRowExtensions).GetMethod(
     "Field", 
      new Type[] { typeof(DataRow),typeof(string) });

mi = mi.MakeGenericMethod(typeof(string));

ParameterExpression rowexp = Expression.Parameter(typeof(DataRow), "row");
ParameterExpression valuesexp = Expression.Parameter(typeof(List<string>), "values");
ParameterExpression fexp = Expression.Parameter(typeof(List<string>), "types");
Expression inner, outer, predicateBody = null;

foreach (var col in types)
{
    // DataRow row = CapacityTable.Rows[1];

    ParameterExpression colexp = Expression.Parameter(typeof(string), "col");
    //  Expression left = Expression.Call(pe, typeof(string).GetMethod("ToLower", System.Type.EmptyTypes));

    inner = Expression.Call(rowexp,mi, colexp);
    outer = Expression.Call(valuesexp, typeof(List<string>).GetMethod("Contains"), inner);
    predicateBody = Expression.And(predicateBody,outer);
}

MethodCallExpression whereCallExpression = Expression.Call(
    typeof(Queryable),
    "Where",
    new Type[] { queryableData.ElementType },
    queryableData.Expression,
    Expression.Lambda<Func<DataRow,bool>>(predicateBody, new ParameterExpression[] { rowexp }));

Réponse acceptée

Cela signifie que l'appel de méthode que vous essayez de représenter est statique, mais que vous lui donnez une expression cible. C'est comme essayer d'appeler:

Thread t = new Thread(...);
// Invalid!
t.Sleep(1000);

Vous essayez en quelque sorte de faire cela sous forme d'arbre d'expression, ce qui n'est pas autorisé non plus.

Il semble que cela se produise pour la méthode d'extension Field sur DataRowExtensions - la "cible" de la méthode d'extension doit donc être exprimée en tant que premier argument de l'appel, car vous souhaitez réellement appeler:

DataRowExtensions.Field<T>(row, col);

Alors tu veux:

inner = Expression.Call(mi, rowexp, colexp);

Cela appellera cette surcharge qui est le moyen d'appeler une méthode statique avec deux arguments.



Sous licence: CC-BY-SA with attribution
Non affilié à Stack Overflow
Sous licence: CC-BY-SA with attribution
Non affilié à Stack Overflow