ERRORE Il metodo statico richiede un'istanza nulla, il metodo non statico richiede un'istanza diversa da null

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

Domanda

Sto cercando di creare un albero delle espressioni. Ho bisogno di leggere i dati da una tabella di dati e controllarne le colonne. Le colonne da controllare e anche il numero di colonne da controllare sono noti solo in fase di esecuzione. I nomi delle colonne mi sono dati come array di stringhe e ogni colonna ha un elenco di stringhe da controllare. Ho provato degli alberi di espressione di esempio, come quello qui sotto.

Qui sto incontrando un errore.

Il metodo statico richiede un'istanza nulla, il metodo non statico richiede un'istanza diversa da null. Nome del parametro: istanza

alla linea

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

Gentilmente aiutatemi !!!

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 }));

Risposta accettata

Significa che la chiamata al metodo che stai cercando di rappresentare è statica, ma stai dando un'espressione target. È come cercare di chiamare:

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

Stai cercando di farlo in forma di albero delle espressioni, cosa che non è consentita neanche.

Sembra che questo stia accadendo per il metodo di estensione Field su DataRowExtensions - quindi la "destinazione" del metodo di estensione deve essere espressa come primo argomento della chiamata, perché in realtà vuoi chiamare:

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

Quindi tu vuoi:

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

Questo chiamerà questo overload che è il modo di chiamare un metodo statico con due argomenti.



Autorizzato sotto: CC-BY-SA with attribution
Non affiliato con Stack Overflow
È legale questo KB? Sì, impara il perché
Autorizzato sotto: CC-BY-SA with attribution
Non affiliato con Stack Overflow
È legale questo KB? Sì, impara il perché