将参数传递给方法并分配给 Func 类型<bool></bool>

Question

I currently have a method like that resembles this

 public static bool test(string str);

I would like to assign this method to this type

 Func<bool> callback

I am trying to do this (which is incorrect)

callback = test("Str");

The above is incorrect as C# things i am calling a method. How can I tell it to call that method with the parameter Str? in C++ we can do this

std::function<...,..,"str">

How do we do something similar in C#?

Answer 1

If your goal is to invoke the callback always using the same string argument (and not a different argument each time), you can declare it like:

Func<bool> callback = () => test("Str");
var result = callback();

But if you are intending to pass a different string value each time, then you need a Func<string, bool> :

Func<string, bool> callback = s => test(s);
var result = callback("Str");

Answer 2

you should declare the function as:

Func<string, bool> callback

to indicate the method it references consumes a string and returns a bool .

then at a later point you can do:

callback = s => test(s);

or inline:

Func<string, bool> callback = s => test(s);

Answer 3

Let me see if I know what you're getting at. In C++ we have 'function pointers' and they are declared with a particular signature. To make the equivalent of that in C# use the delegate keyword.

Here's a quick functional code example:

    class DelegateExample
    {
        // A delegate is a prototype for a function signature.
        // Similar to a function pointer in C++.
        delegate bool MyDelegate(string[] strings);

        // A method that has that signature.
        bool ListStrings(string[] strings)
        {
            foreach (var item in strings)
            {
                Console.WriteLine(item);
            }
            return strings.Length > 0; // ... for example
        }

        // Different method, same signature.
        bool Join(string[] strings)
        {
            Console.WriteLine(string.Join(", ", strings));
            return strings.Length > 0; // ... for example
        }

        public void TryIt()
        {
            string[] testData = { "Apple", "Orange", "Grape" };

            // Think of this as a list of function pointers...
            List<MyDelegate> functions = new List<MyDelegate>();

            functions.Add(ListStrings); // This one points to the ListStrings method
            functions.Add(Join);        // This one points to the Join method

            foreach (var function in functions)
            {
                bool returnVal = function(testData);
                Console.WriteLine("The method returned " + returnVal + Environment.NewLine);
            }
        }
    }

You can run the sample in a console app like so:

class Program
{
    static void Main(string[] args)
    {
        new DelegateExample().TryIt();
        Console.ReadKey();
    }
}

Which gives this output:

Apple
Orange
Grape
The method returned True

Apple, Orange, Grape
The method returned True

Hope this is helpful!