¿Hay alguna manera de negar un predicado?

Question

quiero hacer algo como esto:

List<SomeClass> list1 = ... 
List<SomeClass> list2 = ... 
Predicate<SomeClass> condition = ... 

... 

list2.RemoveAll (!condition); 

... 

list2.AddRange (list1.FindAll (condition)); 

Sin embargo, esto da lugar a un error de compilación, como ! no se puede aplicar a Predicate<SomeClass>. ¿Hay alguna manera de hacer esto?

Answer 1

Se podría utilizar una expresión lambda para definir un inplace delegado anónima que es el resultado de negar el resultado del predicado:

list.RemoveAll(x => !condition(x));  

Otra opción:

static Predicate<T> Negate<T>(Predicate<T> predicate) { 
    return x => !predicate(x); 
} 

Uso:

// list is List<T> some T 
// predicate is Predicate<T> some T 
list.RemoveAll(Negate(predicate)); 

La razón por la cual list.RemoveAll(!condition) no funciona es que hay no se ha definido el operador ! en los delegados. Es por eso que debe definir un nuevo delegado en términos de condition como se muestra arriba.

Answer 2

Esto es realmente posible, pero tal vez en una forma ligeramente diferente a la que está acostumbrado. En .NET, las expresiones lambda pueden interpretarse como delegados O como expression trees. Es relativamente sencillo realizar una operación NOT en un árbol de expresiones.

Aquí es una muestra utilizando su código como punto de partida:

namespace Sample 
{ 
    using System; 
    using System.Collections.Generic; 
    using System.Linq.Expressions; 

    internal class ExpressionSample 
    { 
     private static Expression<TDelegate> Negate<TDelegate>(Expression<TDelegate> expression) 
     { 
      return Expression.Lambda<TDelegate>(Expression.Not(expression.Body), expression.Parameters); 
     } 

     private static void Main() 
     { 
      // Match any string of length 2 or more characters 
      Expression<Predicate<string>> expression = (s) => s.Length > 1; 

      // Logical negation, i.e. match string of length 1 or fewer characters 
      Expression<Predicate<string>> negatedExpression = ExpressionSample.Negate(expression); 

      // Compile expressions to predicates 
      Predicate<string> predicate = expression.Compile(); 
      Predicate<string> negativePredicate = negatedExpression.Compile(); 

      List<string> list1 = new List<string> { string.Empty, "an item", "x", "another item" }; 
      List<string> list2 = new List<string> { "yet another item", "still another item", "y", string.Empty }; 

      list2.RemoveAll(negativePredicate); 
      list2.AddRange(list1.FindAll(predicate)); 

      list2.ForEach((s) => Console.WriteLine(s)); 
     } 
    } 
}