Passing parameters to predicates

Introduction

Inability to pass parameters to predicates often made me consider writing search functions for custom collections. One day I figured enough is enough. In this example I will demonstrate the workaround to passing parameters to predicates, and reasoning involved. There is no download - the code is tiny. I will use MSDN’s example code for List.TrueForAll as the starting point.

Intermediate step

What if we wanted to reuse the predicate to search not only for dinosaur names that end on “saurus”, but also for those that end on “tor”? Shouldn’t it be easily done?

I only kept the minimum required code from MSDN example. To approximate a more common situation, the code is moved into a class DinoClassification, which hypothetically classifies dinosaurs. The predicate and the variable that it uses are made non-static and also moved into that class.

using System;
using System.Collections.Generic;


public class DinoClassification
{
    private string m_Suffix;

    public void Classify()
    {
        List<string> dinosaurs = new List<string>(new string[] {
            "Compsognathus", "Amargasaurus", "Oviraptor", "Velociraptor",
            "Deinonychus", "Dilophosaurus", "Gallimimus", "Triceratops"});

        m_Suffix = "saurus";
        Console.WriteLine("\nFind(EndsWith {0}): {1}", m_Suffix, 
            dinosaurs.Find(EndsWith));
        m_Suffix = "tor";
        Console.WriteLine("\nFind(EndsWith {0}): {1}", m_Suffix, 
            dinosaurs.Find(EndsWith));
    }

    // Search predicate returns true if a string ends in correct suffix.

    private bool EndsWith(String s)
    {
        if ((s.Length >= m_Suffix.Length) &&
            (s.Substring(s.Length - m_Suffix.Length).ToLower() == 
                    m_Suffix.ToLower()))
        {
            return true;
        }
        else
        {
            return false;
        }
    }
}

public class Example
{
    public static void Main()
    {
        DinoClassification dcl = new DinoClassification();
        dcl.Classify();
    }
}

This works in a single-threaded environment. In multi-threaded application we could have m_Suffix written to from different threads, which would cause havoc. To make this code thread-safe one would need to have the search inside a critical section. This is out of question. Having iteration over a collection of arbitrary size in a critical section is not an option.

There’s another fact that I personally dislike about this implementation. DinoClassification is a dinosaur classification class. It has nothing to do with matching strings that make up a dinosaur name. Member variable m_Suffix and predicate EndsWith do not belong in DinoClassification class.

So, what I really want is:

• Maintain class' thread safety with no effort on my part.
• Move the predicate out of my class.
• Keep it all as simple as possible.

Solution

Why not do just that? Wrap a variable and a predicate together and tuck away into a separate class.

using System;
using System.Collections.Generic;


public class EndsWith
{
    private string m_Suffix;

    // Initializes with suffix we want to match.

    public EndsWith(string Suffix)
    {
        m_Suffix = Suffix;
    }

    // Sets a different suffix to match.

    public string Suffix
    {
        get { return m_Suffix; }
        set { m_Suffix = value; }
    }
    
    // Gets the predicate.  Now it's possible to re-use this predicate with 

    // various suffixes.

    public Predicate<string> Match
    {
        get { return IsMatch; }
    }

    private bool IsMatch(string s)
    {
        if ((s.Length >= m_Suffix.Length) &&
            (s.Substring(s.Length - m_Suffix.Length).ToLower()
                                                 == m_Suffix.ToLower()))
        {
            return true;
        }
        else
        {
            return false;
        }
    }
}


public class DinoClassification
{
    public void Classify()
    {
        List<string> dinosaurs = new List<string>(new string[] {
            "Compsognathus", "Amargasaurus", "Oviraptor", "Velociraptor",
            "Deinonychus", "Dilophosaurus", "Gallimimus", "Triceratops"});

        Console.WriteLine("\nFind(EndsWith): {0}", 
            dinosaurs.Find(new EndsWith("saurus").Match));
        EndsWith predicate = new EndsWith("tor");
        Console.WriteLine("\nFind(EndsWith): {0}", 
            dinosaurs.Find(predicate.Match));
        predicate.Suffix = "hus";
        Console.WriteLine("\nFind(EndsWith): {0}", 
            dinosaurs.Find(predicate.Match));
    }
}



public class Example
{
    public static void Main()
    {
        DinoClassification dcl = new DinoClassification();
        dcl.Classify();
    }
}

EndsWith is a class that wraps the predicate and the variable. The variable can be set either through constructor parameter or Suffix property. Class has two properties. Property Suffix allows setting a new value for predicate to match. The Match property is of type predicate<string>. It returns the “parameterized” predicate used in Find(), Exists(), etc.

What was achieved in this example:

• DinoClassification is thread-safe as long as there is no member variable of type EndsWith.
• DinoClassification is not cluttered with code pieces that belong to utility layer.
• Predicate parameters are passed to constructor and may later be modified through properties of the wrapper class.