2009-08-13 9 views

Répondre

8

C'est vraiment juste une forme spécifique de combiner deux valeurs Expression<Func<T, T>>. Voici un exemple de le faire:

using System; 
using System.Linq.Expressions; 

public class Test 
{ 
    public static Expression<Func<T, T>> Apply<T> 
     (Expression<Func<T, T>> first, Expression<Func<T, T>> second) 
    { 
     ParameterExpression input = Expression.Parameter(typeof(T), "input"); 
     Expression invokedSecond = Expression.Invoke(second, 
                new Expression[]{input}); 
     Expression invokedFirst = Expression.Invoke(first, 
                new[]{invokedSecond}); 
     return Expression.Lambda<Func<T, T>>(invokedFirst, new[]{input}); 
    } 

    static void Main() 
    { 
     var addAndSquare = Apply<int>(x => x + 1, 
             x => x * x); 

     Console.WriteLine(addAndSquare.Compile()(5)); 
    } 
} 

Vous pouvez écrire ApplySequence en ces termes facilement, si vous vouliez:

public static Expression<Func<IEnumerable<T>, IEnumerable<T>>> 
     ApplySequence<T> 
      (Expression<Func<IEnumerable<T>, IEnumerable<T>>> first, 
      Expression<Func<IEnumerable<T>, IEnumerable<T>>> second) 
    { 
     return Apply(first, second); 
    } 
+0

Qu'est-ce que les « nouveaux [] {} invokedSecond » signifie? Crée-t-il un tableau de type invokedSecond? Ou un tableau d'objets avec un seul élément invoquéSecond? – Kamarey

+0

Il s'agit d'un tableau implicitement typé, typé en fonction des types statiques des éléments - dans ce cas, il est équivalent à 'new Express [] {invokedSecond}'. –

Questions connexes