What is a "Predicate delegate"

[Jeff S.]

I was recently advised:
<< Use List<struct> and Find() using different Predicate delegates for your
different search needs.>>

What is "Predicate delegate" as used in the above recommendation?

Thanks.

[Jon Skeet [C# MVP]]

Jeff S. <[e-mail]> wrote:

I was recently advised:
<< Use List<struct> and Find() using different Predicate delegates for your
different search needs.>>

What is "Predicate delegate" as used in the above recommendation?

It's an implementation of the generic System.Predicate<T> delegate.

See http://msdn2.microsoft.com/en-us/lib...bz(VS.80).aspx for
details...

--
Jon Skeet - <sk***@pobox.com>
http://www.pobox.com/~skeet Blog: http://www.msmvps.com/jon.skeet
If replying to the group, please do not mail me too

[Pipo]

http://msdn2.microsoft.com/en-us/lib...bz(VS.80).aspx

"Jeff S." <[e-mail]> wrote in message
news:um**************@TK2MSFTNGP12.phx.gbl...

I was recently advised:
<< Use List<struct> and Find() using different Predicate delegates for
your different search needs.>>

What is "Predicate delegate" as used in the above recommendation?

Thanks.

[Kevin Spencer]

A delegate is like a function pointer. A Predicate delegate is a very cool
use of Delegates which is used with various Generic Lists, Arrays and
Collections. Since a Generic List does not specify a data type, that is, the
data type of the items in the List is set with a type parameter, how would
one write a Find() function for a Generic List? Since nothing is known about
the data type being searched for, one cannot know what sort of condition is
used to discriminate between one item and another.

The Predicate delegate is a Generic method which takes an object of type T
as a parameter. It returns true or false, indicating whether or not the
object of type T satisfies the condition it tests. The Predicate delegate is
assigned the same type as the List when the List type parameter is passed to
the instance of the Generic List created. The author of the code knows what
the data type is, and can write a method that works with the type passed to
test it and see whether it is whatever the author wants it to be. The Find()
method uses the Predicate delegate method created to test each item in the
List, and returns the first item in the List for which the Predicate
delegate returns true.

As an example, let's say that we have a Generic List of type Int32:

private List<int> Numbers = new List<int>();

You want to find the first item in the List that is less than 5. So, you
create your method:

private static bool IsLessThanFive(int i)
{
return (i < 5);
}

So, now you call the Find() method:

int result = Numbers.Find(new Predicate<int>(IsLessThanFive);

The IsLessThanFive Predicate delegate is called for each item in the list,
passing that item as the parameter, until one of the calls returns true.
That is the number that is assigned to result.

--
HTH,

Kevin Spencer
Microsoft MVP
Professional Numbskull

Show me your certification without works,
and I'll show my certification
*by* my works.
"Jeff S." <[e-mail]> wrote in message
news:um**************@TK2MSFTNGP12.phx.gbl...

I was recently advised:
<< Use List<struct> and Find() using different Predicate delegates for
your different search needs.>>

What is "Predicate delegate" as used in the above recommendation?

Thanks.

[William Stacey [MVP]]

A predicate is just a method that returns true or false. In the case of
List<T>, you can pass it a delegate that is your code block to return true
or false.
You can do the same thing yourself without predicates. For example here is
a collection that uses both to give you a basic idea:

public class Customers

{

private List<Person> list;

public Customers()

{

list = new List<Person>();

}

// Prior to List<T>, you would do something like this. Can still do.

public Person FindName(string name)

{

lock (list)

{

foreach (Person p in list)

{

if (p.Name == name)

return p;

}

return null;

}

}

// Passing delegate to List.Find() in 2.0.

public Person FindName2(string name)

{

lock (list)

{

// Find will enumerate the list and eval the predicate for each
item and return first item that returns true.

return list.Find(delegate(Person p)

{

return p.Name == name;

});

}

}

}

public class Person

{

public string Name;

public int Age;

}
Both methods return same result, You can decide if predicates are helpful
or not.

--
William Stacey [MVP]

"Jeff S." <[e-mail]> wrote in message
news:um**************@TK2MSFTNGP12.phx.gbl...
|I was recently advised:
| << Use List<struct> and Find() using different Predicate delegates for
your
| different search needs.>>
|
| What is "Predicate delegate" as used in the above recommendation?
|
| Thanks.
|
|

[William Stacey [MVP]]

Added another method to round out the example. Find3() takes a delegate we defined. This is how you might do the same thing before Predicate<T>.

public delegate bool PersonDel(Person p);

public class Customers

{

private List<Person> list;

public Customers()

{

list = new List<Person>();

}

public void Add(Person p)

{

if (p == null)

throw new ArgumentNullException("p");

lock (list)

{

list.Add(p);

}

}

// Prior to List<T>, you would do something like this. Can still do.

public Person Find(string name)

{

lock (list)

{

foreach (Person p in list)

{

if (p.Name == name)

return p;

}

return null;

}

}

// Passing delegate to List.Find() in 2.0.

public Person Find2(string name)

{

lock (list)

{

// Find will enumerate the list and eval the predicate for each item and return first item that returns true.

return list.Find(delegate(Person p)

{

return p.Name == name;

});

}

}

// Using your own delegate type to simulate what Predicate<T> does for you.

public Person Find3(PersonDel del)

{

lock (list)

{

foreach (Person p in list)

{

if ( del(p))

return p;

}

return null;

}

}

public static void Test()

{

Customers c = new Customers();

c.Add(new Person("Amy", 30));

c.Add(new Person("Joe", 35));

Person p = c.Find("Amy");

Console.WriteLine(p.ToString());

p = c.Find2("Joe");

Console.WriteLine(p.ToString());

p = c.Find3(delegate(Person person)

{

return person.Name == "Amy";

});

Console.WriteLine(p.ToString());

}

}

public class Person

{

public string Name;

public int Age;

public Person(string name, int age)

{

this.Name = name;

this.Age = age;

}

public override string ToString()

{

return Name + ", " + Age;

}

}
--
William Stacey [MVP]

[Brian Gideon]

Kevin,

Excellent description. In addition you can use anonymous methods and
delegate inference to write it all in one line of code.

int result = Numbers.Find(delegate(int i) { return i < 5; });

Brian

Kevin Spencer wrote:

A delegate is like a function pointer. A Predicate delegate is a very cool
use of Delegates which is used with various Generic Lists, Arrays and
Collections. Since a Generic List does not specify a data type, that is, the
data type of the items in the List is set with a type parameter, how would
one write a Find() function for a Generic List? Since nothing is known about
the data type being searched for, one cannot know what sort of condition is
used to discriminate between one item and another.

The Predicate delegate is a Generic method which takes an object of type T
as a parameter. It returns true or false, indicating whether or not the
object of type T satisfies the condition it tests. The Predicate delegate is
assigned the same type as the List when the List type parameter is passed to
the instance of the Generic List created. The author of the code knows what
the data type is, and can write a method that works with the type passed to
test it and see whether it is whatever the author wants it to be. The Find()
method uses the Predicate delegate method created to test each item in the
List, and returns the first item in the List for which the Predicate
delegate returns true.

As an example, let's say that we have a Generic List of type Int32:

private List<int> Numbers = new List<int>();

You want to find the first item in the List that is less than 5. So, you
create your method:

private static bool IsLessThanFive(int i)
{
return (i < 5);
}

So, now you call the Find() method:

int result = Numbers.Find(new Predicate<int>(IsLessThanFive);

The IsLessThanFive Predicate delegate is called for each item in the list,
passing that item as the parameter, until one of the calls returns true.
That is the number that is assigned to result.

--
HTH,

Kevin Spencer
Microsoft MVP
Professional Numbskull

Show me your certification without works,
and I'll show my certification
*by* my works.
"Jeff S." <[e-mail]> wrote in message
news:um**************@TK2MSFTNGP12.phx.gbl...

I was recently advised:
<< Use List<struct> and Find() using different Predicate delegates for
your different search needs.>>

What is "Predicate delegate" as used in the above recommendation?

Thanks.

[Jeff S.]

Thank you so much! (William and Kevin)...

-Jeff


"William Stacey [MVP]" <wi************@gmail.com> wrote in message news:Ow**************@TK2MSFTNGP09.phx.gbl...
Added another method to round out the example. Find3() takes a delegate we defined. This is how you might do the same thing before Predicate<T>.

public delegate bool PersonDel(Person p);

public class Customers

{

private List<Person> list;

public Customers()

{

list = new List<Person>();

}

public void Add(Person p)

{

if (p == null)

throw new ArgumentNullException("p");

lock (list)

{

list.Add(p);

}

}

// Prior to List<T>, you would do something like this. Can still do.

public Person Find(string name)

{

lock (list)

{

foreach (Person p in list)

{

if (p.Name == name)

return p;

}

return null;

}

}

// Passing delegate to List.Find() in 2.0.

public Person Find2(string name)

{

lock (list)

{

// Find will enumerate the list and eval the predicate for each item and return first item that returns true.

return list.Find(delegate(Person p)

{

return p.Name == name;

});

}

}

// Using your own delegate type to simulate what Predicate<T> does for you.

public Person Find3(PersonDel del)

{

lock (list)

{

foreach (Person p in list)

{

if ( del(p))

return p;

}

return null;

}

}

public static void Test()

{

Customers c = new Customers();

c.Add(new Person("Amy", 30));

c.Add(new Person("Joe", 35));

Person p = c.Find("Amy");

Console.WriteLine(p.ToString());

p = c.Find2("Joe");

Console.WriteLine(p.ToString());

p = c.Find3(delegate(Person person)

{

return person.Name == "Amy";

});

Console.WriteLine(p.ToString());

}

}

public class Person

{

public string Name;

public int Age;

public Person(string name, int age)

{

this.Name = name;

this.Age = age;

}

public override string ToString()

{

return Name + ", " + Age;

}

}
--
William Stacey [MVP]

[Kevin Spencer]

Good point, Brian!

--
HTH,

Kevin Spencer
Microsoft MVP
Professional Numbskull

Show me your certification without works,
and I'll show my certification
*by* my works.

"Brian Gideon" <br*********@yahoo.com> wrote in message
news:11**********************@u72g2000cwu.googlegr oups.com...

Kevin,

Excellent description. In addition you can use anonymous methods and
delegate inference to write it all in one line of code.

int result = Numbers.Find(delegate(int i) { return i < 5; });

Brian

Kevin Spencer wrote:

A delegate is like a function pointer. A Predicate delegate is a very
cool
use of Delegates which is used with various Generic Lists, Arrays and
Collections. Since a Generic List does not specify a data type, that is,
the
data type of the items in the List is set with a type parameter, how
would
one write a Find() function for a Generic List? Since nothing is known
about
the data type being searched for, one cannot know what sort of condition
is
used to discriminate between one item and another.

The Predicate delegate is a Generic method which takes an object of type
T
as a parameter. It returns true or false, indicating whether or not the
object of type T satisfies the condition it tests. The Predicate delegate
is
assigned the same type as the List when the List type parameter is passed
to
the instance of the Generic List created. The author of the code knows
what
the data type is, and can write a method that works with the type passed
to
test it and see whether it is whatever the author wants it to be. The
Find()
method uses the Predicate delegate method created to test each item in
the
List, and returns the first item in the List for which the Predicate
delegate returns true.

As an example, let's say that we have a Generic List of type Int32:

private List<int> Numbers = new List<int>();

You want to find the first item in the List that is less than 5. So, you
create your method:

private static bool IsLessThanFive(int i)
{
return (i < 5);
}

So, now you call the Find() method:

int result = Numbers.Find(new Predicate<int>(IsLessThanFive);

The IsLessThanFive Predicate delegate is called for each item in the
list,
passing that item as the parameter, until one of the calls returns true.
That is the number that is assigned to result.

--
HTH,

Kevin Spencer
Microsoft MVP
Professional Numbskull

Show me your certification without works,
and I'll show my certification
*by* my works.
"Jeff S." <[e-mail]> wrote in message
news:um**************@TK2MSFTNGP12.phx.gbl...

>I was recently advised:
> << Use List<struct> and Find() using different Predicate delegates for
> your different search needs.>>
>
> What is "Predicate delegate" as used in the above recommendation?
>
> Thanks.
>