CODEWITHSUNDEEP
c#delegates
Curtis
Curtis

Reputation: 1189

How do you declare a Predicate Delegate inline?

So I have an object which has some fields, doesn't really matter what. I have a generic list of these objects.

List<MyObject> myObjects = new List<MyObject>();
myObjects.Add(myObject1);
myObjects.Add(myObject2);
myObjects.Add(myObject3);

So I want to remove objects from my list based on some criteria. For instance, myObject.X >= 10. I would like to use the RemoveAll(Predicate<T> match) method for to do this.

I know I can define a delegate which can be passed into RemoveAll, but I would like to know how to define this inline with an anonymous delegate, instead of creating a bunch of delegate functions which are only used in once place.

Upvotes: 43

Views: 34698

Answers (4)

Erik van Brakel
Erik van Brakel

Reputation: 23840

There's two options, an explicit delegate or a delegate disguised as a lamba construct:

explicit delegate

myObjects.RemoveAll(delegate (MyObject m) { return m.X >= 10; });

lambda

myObjects.RemoveAll(m => m.X >= 10);

Performance wise both are equal. As a matter of fact, both language constructs generate the same IL when compiled. This is because C# 3.0 is basically an extension on C# 2.0, so it compiles to C# 2.0 constructs

Upvotes: 58

Nayas Subramanian
Nayas Subramanian

Reputation: 2379

Predicate is a delegate which takes an param and returns a boolean.

We can do the same in following ways

1) Using inline Lambda expression

RemoveAll(p=> p.x > 2);

2) Using anonymous function

RemoveAll(delegate(myObject obj){

  return obj.x >=10;
})

3) Using Predicate delegate

Predicate<myObject> matches = new Predicate<myObject>(IsEmployeeIsValid);
RemoveAll(matches);

Predicate<Foo> matches = delegate(Foo o){ return o.X >= 20; });
RemoveAll(matches);

3) Declaring a delegate explicitily and pointing to a function

public delegate bool IsInValidEmployee (Employee emp);

IsInValidEmployee invalidEmployeeDelegate = new IsInValidEmployee(IsEmployeeInValid);
myObjects.RemoveAll(myObject=>invalidEmployeeDelegate(myObject);

// Actual function

public static bool IsEmployeeInValid(Employee emp)
{
    if (emp.Id > 0 )
        return true;
    else
        return false;
}

Upvotes: 2

Mark Cidade
Mark Cidade

Reputation: 100027

  //C# 2.0
  RemoveAll(delegate(Foo o){ return o.X >= 10; });

or

  //C# 3.0
  RemoveAll(o => o.X >= 10);

or

  Predicate<Foo> matches = delegate(Foo o){ return o.X >= 10; });
  //or Predicate<Foo> matches = o => o.X >= 10;
  RemoveAll(matches);

Upvotes: 11

Mark Brackett
Mark Brackett

Reputation: 85665

The lambda C# 3.0 way:

myObjects.RemoveAll(m => m.x >= 10);

The anonymous delegate C# 2.0 way:

myObjects.RemoveAll(delegate (MyObject m) {
   return m.x >= 10;
});

And, for the VB guys, the VB 9.0 lambda way:

myObjects.RemoveAll(Function(m) m.x >= 10)

Unfortunately, VB doesn't support an anonymous delegate.

Upvotes: 15

Related Questions