Assegnazione negli alberi delle espressioni .NET 3.5
-
03-07-2019 - |
Domanda
È possibile codificare un compito in un albero delle espressioni?
Soluzione
No, non ci credo.
Certamente il compilatore C # non lo consente quando converte un'espressione lambda:
int x;
Expression<Func<int,int>> foo = (x=y); // Assign to x and return value
Questo produce l'errore:
CS0832: An expression tree may not contain an assignment operator
Altri suggerimenti
Dovresti riuscire a farlo con la libreria .NET 4.0. importando Microsoft.Scripting.Core.dll nel tuo progetto .NET 3.5.
Sto usando DLR 0.9 - Potrebbero esserci dei cambiamenti su Expession.Block ed Expression.Scope nella versione 1.0 (Puoi vedere i riferimenti da http://www.codeplex.com/dlr/Thread/View.aspx?ThreadId=43234 )
Il seguente esempio è quello di mostrarti.
using System;
using System.Collections.Generic;
using Microsoft.Scripting.Ast;
using Microsoft.Linq.Expressions;
using System.Reflection;
namespace dlr_sample
{
class Program
{
static void Main(string[] args)
{
List<Expression> statements = new List<Expression>();
ParameterExpression x = Expression.Variable(typeof(int), "r");
ParameterExpression y = Expression.Variable(typeof(int), "y");
statements.Add(
Expression.Assign(
x,
Expression.Constant(1)
)
);
statements.Add(
Expression.Assign(
y,
x
)
);
MethodInfo cw = typeof(Console).GetMethod("WriteLine", new Type[] { typeof(int) });
statements.Add(
Expression.Call(
cw,
y
)
);
LambdaExpression lambda = Expression.Lambda(Expression.Scope(Expression.Block(statements), x, y));
lambda.Compile().DynamicInvoke();
Console.ReadLine();
}
}
}
Il mio metodo di estensione per fare esattamente questo:
/// <summary>
/// Provides extensions for converting lambda functions into assignment actions
/// </summary>
public static class ExpressionExtenstions
{
/// <summary>
/// Converts a field/property retrieve expression into a field/property assign expression
/// </summary>
/// <typeparam name="TInstance">The type of the instance.</typeparam>
/// <typeparam name="TProp">The type of the prop.</typeparam>
/// <param name="fieldGetter">The field getter.</param>
/// <returns></returns>
public static Expression<Action<TInstance, TProp>> ToFieldAssignExpression<TInstance, TProp>
(
this Expression<Func<TInstance, TProp>> fieldGetter
)
{
if (fieldGetter == null)
throw new ArgumentNullException("fieldGetter");
if (fieldGetter.Parameters.Count != 1 || !(fieldGetter.Body is MemberExpression))
throw new ArgumentException(
@"Input expression must be a single parameter field getter, e.g. g => g._fieldToSet or function(g) g._fieldToSet");
var parms = new[]
{
fieldGetter.Parameters[0],
Expression.Parameter(typeof (TProp), "value")
};
Expression body = Expression.Call(AssignmentHelper<TProp>.MethodInfoSetValue,
new[] {fieldGetter.Body, parms[1]});
return Expression.Lambda<Action<TInstance, TProp>>(body, parms);
}
public static Action<TInstance, TProp> ToFieldAssignment<TInstance, TProp>
(
this Expression<Func<TInstance, TProp>> fieldGetter
)
{
return fieldGetter.ToFieldAssignExpression().Compile();
}
#region Nested type: AssignmentHelper
private class AssignmentHelper<T>
{
internal static readonly MethodInfo MethodInfoSetValue =
typeof (AssignmentHelper<T>).GetMethod("SetValue", BindingFlags.NonPublic | BindingFlags.Static);
private static void SetValue(ref T target, T value)
{
target = value;
}
}
#endregion
}
Come Jon Skeet e TraumaPony hanno già detto, Expression.Assign
non è disponibile prima di .NET 4. Ecco un altro esempio concreto di come aggirare questo bit mancante:
public static class AssignmentExpression
{
public static Expression Create(Expression left, Expression right)
{
return
Expression.Call(
null,
typeof(AssignmentExpression)
.GetMethod("AssignTo", BindingFlags.NonPublic | BindingFlags.Static)
.MakeGenericMethod(left.Type),
left,
right);
}
private static void AssignTo<T>(ref T left, T right) // note the 'ref', which is
{ // important when assigning
left = right; // to value types!
}
}
Quindi chiama semplicemente AssignmentExpression.Create ()
al posto di Expression.Assign ()
.
Probabilmente potresti aggirarlo accanto agli alberi delle espressioni seguenti. Chiama una funzione lambda, dove un argomento è il valore dell'assegnatario.