Predicate Delegate in C#

One built-in generic type delegate is the Predicate delegate in C#. The predicate delegate is defined under the System namespace. It works with those methods that have a set of criteria and determines if the parameter that has been supplied fulfils or fails to meet the requirements. With a single input, this delegate returns a result that can be either true or false.

Syntax:

It has the following syntax:

public: This keyword indicates that the delegate can be accessed from any outside class or assembly in which it is included. It also indicates that any code that has access to the contained namespace or assembly can use the delegate.
delegate: This keyword indicates that a delegate type is being declared. A type that represents references to methods with a certain parameter list and return type is called a delegate.
bool: It describes the delegate's return type. In this case, it is bool, meaning that the delegate will provide a boolean value (true or false).
Predicate: The declaration of the delegate type is indicated by this name. The Predicate delegate type in .NET is frequently used to describe a method that checks to see whether an object meets a certain condition.
<in P>: The generic type parameter P for the delegate is specified in this part. The keyword before P denotes the contravariant nature of the P-type parameter. It indicates that you can pass a type that is derived from P, or even P itself, as an argument to the delegate in this case.
(P obj): The parameter list for the delegate is represented by (P obj). The delegate is only required to accept a single type P parameter called obj. A method that takes an argument of type P would be provided when using this delegate.

Common Use Cases

Several use cases of the Predicate Delegate in C# are as follows:

Filtering: Predicates are frequently used with methods like Find, FindAll, Exists, etc. to filter elements based on certain criteria.
Validation: Before processing data, predicates can be used to check it against certain requirements.
Searching: They are useful for searching through collections or arrays to find elements that match a particular condition.
Predicates can be passed as parameters to methods that take delegates, such as List methods, LINQ extension methods (Where, Any, All, etc.), and more.
They can also be assigned to delegate variables and used for method group conversions.

Example 1:

Let us take an example to illustrate the Predicate Delegates in C#.

using System;
using System.Collections.Generic;
class Javatpoint
{
    static void Main(string[] args)
    {
        // Create an integers list.
        List<int> elements = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,12 };
        // Use a named method with a Predicate delegate.
        List<int> Even_Elements = elements.FindAll(IsEven);
        Console.WriteLine("The Even Elements are:");
        PrintList(Even_Elements);
        // Use the anonymous method of Predicate delegate.
        List<int> Odd_Elements = elements.FindAll(delegate (int num) { return num % 2 != 0; });
        Console.WriteLine("\nThe Odd Elements are:");
        PrintList(Odd_Elements);
        //Utilise a lambda expression as a predicate delegate.
        List<int> Multiples_Of_Four = elements.FindAll(num => num % 4 == 0);
        Console.WriteLine("\nThe Multiples of Four are:");
        PrintList(Multiples_Of_Four);
    }
    // Method to check if a number is even
    static bool IsEven(int q)
    {
        return q % 2 == 0;
    }
    // Method to print elements of a list
    static void PrintList(List<int> list)
    {
        foreach (int q in list)
        {
            Console.Write(q + " ");
        }
        Console.WriteLine();
    }
}

Output:

The Even Elements are:
2 4 6 8 10 12 
The Odd Elements are:
1 3 5 7 9 11 
The Multiples of Four are:
4 8 12

Explanation:

Overall, this code demonstrates the versatility of Predicate delegates in C#. It supports named methods, anonymous methods, and lambda expressions to set filtering criteria. The predicate delegate enhances code reusability and readability, making it easier to filter elements from a collection using custom criteria.

Example 2:

Let us take another example to illustrate the Predicate Delegates in C#.

using System; 
class Javatpoint 
{ 
static bool Uppermethod(string str_1)
{
    return str_1.Equals(str_1.ToUpper());
}
static void Main(string[] args)
{
    Predicate<string> isUpper = Uppermethod;
    bool ans = isUpper("HOW ARE U!!");
    Console.WriteLine(ans);
    }
}

Output:

True

Conclusion:

In conclusion, the program shows how to determine whether a given string is in uppercase by using delegates and method group conversion. This example demonstrates how methods with corresponding signatures may be represented by delegates, enabling flexible and adaptable method invocation.

Next TopicStringBuilder.Chars[] Property in C#

← prev next →