Passing a predicate as a parameter c#

Question

I recently did an assessment from a company that had a case where they wanted to set up a predicate as an input parameter to a method. Have little to no experience with this I've been researching it on my own. The code looks like:

using System;

public interface IBird
{
    Egg Lay();
}

public class Chicken : IBird
{
    public Chicken()
    {
    }

    public void EggLay()
    {
    }

    public Egg Lay()
    {
        return new Egg();
    }
}

public class Egg
{
    public Egg(Func<IBird> createBird)
    {
        throw new NotImplementedException("Waiting to be implemented.");
    }

    public IBird Hatch()
    {
        throw new NotImplementedException("Waiting to be implemented.");
    }
}

public class Program
{
    public static void Main(string[] args)
    {
//      var chicken1 = new Chicken();
//      var egg = chicken1.Lay();
//      var childChicken = egg.Hatch();
    }
}

My question is what is the Egg function expecting and why?

I've already seen this answer and this answer and this answer but it's not making any sense still. It's academic at this point but I really want to understand.

The answers you linked are pretty good, what exactly is the confusion? — BradleyDotNET, Mar 15 '19 at 17:36
What would I pass to the Egg function? I just don't understand what it's expecting and why it's expecting it. When using the example in the Main method as values what does the egg method need to create a "chicken" egg properly? — Memnoch The Coder, Mar 15 '19 at 17:41
As an aside, `Func` *isn't* a predicate. A predicate would be something like `Func` or `Predicate`. — Jon Skeet, Mar 15 '19 at 17:42
How much do you understand about delegates in general? It's hard to know how to answer this question at the moment as we don't know how far back to go, so to speak. — Jon Skeet, Mar 15 '19 at 17:42
Don't really understand delegates to be honest so a lot of the explanations I'm finding are a bit over my head. — Memnoch The Coder, Mar 15 '19 at 17:45
A [Delegate](https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/delegates/) is essentially a function pointer. — Igor, Mar 15 '19 at 17:45
Ok, so in the example above the Egg method is expecting a function pointer of some type. But is it expecting like a lambda expression? I can see that it's expecting an expression that has a return type of IBird? Input value of IBird? — Memnoch The Coder, Mar 15 '19 at 17:51

Olivier Jacot-Descombes · Accepted Answer · 2019-07-25T20:26:29.877

public Egg(Func<IBird> createBird) is not a function, it's the constructor of the Egg class. Since the Egg class must Hatch birds, it needs to create birds. Func<IBird> is a delegate, i.e., a value representing a reference to a method. In this specific case it is representing a factory method. A predicate would be a method or delegate returning a Boolean. Through this parameter you can pass any method creating IBirds. Since the IBird interface does not specify an explicit implementation of a bird, you could initialize Egg with different methods creating different bird types. Some requiring constructor parameters, some not.

You would implement Egg like this

public class Egg
{
    private readonly Func<IBird> _createBird;

    public Egg(Func<IBird> createBird)
    {
        _createBird = createBird; // No "()". createBird is not called, just assigned.
    }

    public IBird Hatch()
    {
        return _createBird(); // Here createBird is called, therefore the "()".
    }
}

Now, the Hatch method can create birds, without having the knowledge about how or which type of bird to create, through the intermediate of the _createBird delegate.

How would you create an egg? Well, first you need some bird implementation e.g.:

public class BlackBird : IBird
{
    ... your implementation goes here
}

Then you need a method creating and returning a IBird. E.g.:

IBird CreateBlackBird()
{
    return new BlackBird();
}

You can then create an egg with

var egg = new Egg(CreateBlackBird); // No "()". CreateBlackBird is not called but referenced.
IBird newBird = egg.Hatch();

Make sure to pass the method without parameter list, i.e. without parentheses, because you don't want to call the CreateBlackBird method at this point, you want to pass it over to the constructor, where it is stored in the private field _createBird to be used later.

A lambda expression creates an anonymous delegate on the fly:

var egg = new Egg(() => new BlackBird());

() => new BlackBird() is a lambda expression. It is equivalent to the CreateBlackBird method. The return type is not specified and is inferred from the parameter type of the Egg constructor. It has no name. Only the parameter braces are remaining from the method header. => replaces the return keyword.

After having implemented an additional bird class with a color as constructor parameter, you can write

var egg = new Egg(() => new ColoredBird(Color.Blue));

See also:

score 0 · Answer 2 · answered May 30 '19 at 10:14

Thanks for this example. You can implement the singleton pattern so that the bird can hatch only once by modifying the Egg class as following:

    public class Egg
{
    private readonly Func<IBird> _createBird;
    private IBird _Bird = null;

    public Egg(Func<IBird> createBird)
    {
        _createBird = createBird;
    }

    public IBird Hatch()
    {
        if (_Bird == null)
        {
            _Bird = _createBird();
        }

        return _Bird;
    }
}

score 0 · Answer 3 · answered Aug 05 '19 at 05:02

You can implement the singleton pattern so that the bird can hatch only once by modifying the Egg class as following.

public interface IBird
    {
        Egg Lay();
    }
    public class Egg
    {
        private readonly Func<IBird> _createBird;
        private bool _hatched;

        public Egg(Func<IBird> createBird)
        {
            _createBird = createBird;
        }

        public IBird Hatch()
        {
            if (_hatched)
                Console.WriteLine("Egg are already hatched");
            _hatched = true;
            Console.WriteLine("Egg are hatched now;");
            Console.ReadKey();
            return _createBird();
        }
    }

    public class Chicken : IBird
    {
        public Egg Lay()
        {
            var egg = new Egg(() => new Chicken());
            return egg;
        }
    }

    public class Program
    {
        public static void Main(string[] args)
        {
            var chicken1 = new Chicken();
            var egg = chicken1.Lay();
            var childChicken = egg.Hatch();
        }
    }

Passing a predicate as a parameter c#

3 Answers3