Domanda
Prima che qualcuno gridi la risposta, ti preghiamo di leggere la domanda.
Qual è lo scopo del metodo in ExpressionVisitor di .NET 4.0:
public static ReadOnlyCollection<T> Visit<T>(ReadOnlyCollection<T> nodes, Func<T, T> elementVisitor)
La mia prima ipotesi sullo scopo di questo metodo era che avrebbe visitato ogni nodo in ogni albero specificato dal parametro dei nodes e riscritto l'albero usando il risultato della funzione elementVisitor .
Questo non sembra essere il caso. In realtà questo metodo sembra fare un po 'più di niente, a meno che non manchi qualcosa qui, che sospetto fortemente di essere ...
Ho provato a utilizzare questo metodo nel mio codice e quando le cose non hanno funzionato come previsto, ho riflettuto sul metodo e ho trovato:
public static ReadOnlyCollection<T> Visit<T>(ReadOnlyCollection<T> nodes, Func<T, T> elementVisitor)
{
T[] list = null;
int index = 0;
int count = nodes.Count;
while (index < count)
{
T objA = elementVisitor(nodes[index]);
if (list != null)
{
list[index] = objA;
}
else if (!object.ReferenceEquals(objA, nodes[index]))
{
list = new T[count];
for (int i = 0; i < index; i++)
{
list[i] = nodes[i];
}
list[index] = objA;
}
index++;
}
if (list == null)
{
return nodes;
}
return new TrueReadOnlyCollection<T>(list);
}
Quindi, dove qualcuno dovrebbe effettivamente usare questo metodo? Cosa mi manca qui?
Grazie.
Risposta accettata
Mi sembra un metodo comodo per applicare una funzione di trasformazione aribrizionale a un albero di espressioni e restituire l'albero trasformato risultante o l'albero originale se non vi sono cambiamenti.
Non riesco a vedere come questo sia diverso da un pattern che un visitatore di espressioni standard, tranne che per l'utilizzo di un tipo di visitatore, utilizza una funzione.
Per quanto riguarda l'utilizzo:
Expression<Func<int, int, int>> addLambdaExpression= (a, b) => a + b;
// Change add to subtract
Func<Expression, Expression> changeToSubtract = e =>
{
if (e is BinaryExpression)
{
return Expression.Subtract((e as BinaryExpression).Left,
(e as BinaryExpression).Right);
}
else
{
return e;
}
};
var nodes = new Expression[] { addLambdaExpression.Body }.ToList().AsReadOnly();
var subtractExpression = ExpressionVisitor.Visit(nodes, changeToSubtract);
Non spieghi come ti aspettavi che si comportasse e perché quindi pensi che faccia poco più di niente.
Autorizzato sotto: CC-BY-SA with attribution
Non affiliato con Stack Overflow