C#将方法作为参数传递

Question

I'm working with an C API in C#. In C Methods are passed as parameters and I'm trying to accomplish the same thing in C#.

in I would call the functions the following way:

 LL_SetStatusCb(OnStatusRcv);
 LL_SetScanCb(scanCb);
 LL_Scan();

Note that the used methods are defined in the following way:

void OnStatusRcv(ll_status_t status)
void scanCb(ll_scan_result_t *result)

In C# the methods are defined in the same way but I don't know how I can pass those methods.

Answer 1

C# equivalent of function pointers are delegates. You can use Func and Action to pass methods as parameters. Func delegate represents method which takes N arguments and returns value, Action delegate represents void method.

Consider this

void (* myFunction)(int parameter) 

in C# would be

Action<int> 

Answer 2

Please try this code:

create ll_scan_result_t and ll_status_t classes.

class Program
{
    delegate void ActionRef<T>(ref T item);

    static void Main(string[] args)
    {
        ll_status_t _status = new ll_status_t();

        LL_SetStatusCb(_status, OnStatusRcv);

        ll_scan_result_t _scan = new ll_scan_result_t();

        LL_SetScanCb(ref _scan);
    }

    static void LL_SetScanCb(ref ll_scan_result_t status, ActionRef<ll_scan_result_t> getCachedValue)
    {
        //... do something
    }

    static void LL_SetStatusCb(ll_status_t result, Action<ll_status_t> getCachedValue)
    {
        //... do something
    }

    static void OnStatusRcv(ref ll_scan_result_t sresult)
    {
        //... do something
    }

    static void scanCb(ll_status_t s)
    {
        //... do something
    }
}

Answer 3

Use the Func Delegate like below

public class myClass
{

    public bool TestMethod(string input)
    {
        return true;
    }
    public bool Method1(Func<string, bool> methodName)
    {
        return true;
    }

    public void newMthod()
    {
        Method1(TestMethod);
    }
}

Answer 4

In C#, the equivalent to C/C++ function pointers are delegates . A delegate is a type that represents references to methods with a particular parameter list and return type. When you instantiate a delegate, you can associate its instance with any method that has a compatible signature and return type. You can call the method through the delegate instance.

Here's an example. First, declare a delegate:

public delegate void Del(string message);

Now, Del is a delegate type which can be used to call to any method that returns void and accepts an argument of type string . Now, let's create some method matching the signature and return type of Del :

public static void DelegateMethod(string message)
{
    Console.WriteLine(message);
}

Now, let's create an instance of Del and associate it with DelegateMethod , like this:

Del handler = DelegateMethod;

If you want to call DelegateMethod , you can do it by:

handler("Hello World");

Notice that since Del is a type, you can do something like this:

public static void SomeMethod(Del callback, string callbackParams)
{
    callback(callbackParams);
}

Which can be used as:

SomeMethod(handler, "Hello World");

With that said, there are othes ways of working with delegates. You can use Func and Action delegates. Func is a delegate that points to a method that accepts one or more arguments and returns a value, that is, it doesn't return void . Action is a delegate that points to a method which in turn accepts one or more arguments but returns no value (returns void ). In other words, you should use Action when your delegate points to a method that returns void .

Here's an example of using an Action delegate:

static void Main(string[] args)
{
    Action<string> action = new Action<string>(Display);
    action("Hello!!!");
    Console.Read(); //Prevents from closing the command line right away.
}

static void Display(string message)
{
    Console.WriteLine(message);
}

Therefore, something like

void (* funcPtr)(int) = &someFuncWithAnIntArg;
(*funcPtr)(10); 

Is equivalent in C# to

Action<int> funcPtr = new Action<int>(someFuncWithAnIntArg);
funcPtr(10);

And now for a Func delegate:

static void Main(string[] args)
{
    Func<int, double> func = new Func<int, double>(CalculateHra);
    Console.WriteLine(func(50000));
    Console.Read();
}

static double CalculateHra(int basic)
{
    return (double)(basic * .4);
}

The syntax for a Func delegate accepting an argument and returning a value is like this Func<TArgument, TOutput> where TArgument is the type of the argument and TOutput is the type of returned value. There are many more types of Func (browse the left tree index) and Action (also browse the left tree index) delegates.

And last, but not least, we have the Predicate delegates which is typically used to search items in a collection or a set of data. Let's define some boilerplate code to explain:

class Customer
{
    public int Id { get; set; }
    public string FirstName { get; set; }
}

Then, let's try it in:

static void Main(string[] args)
{
   List<Customer> customers = new List<Customer>();
   customers.Add(new Customer { Id = 1, FirstName = "Stack" });
   customers.Add(new Customer { Id = 2, FirstName = "Overflow" });

   Predicate<Customer> pred = x => x.Id == 1;
   Customer customer = customers.Find(pred);
   Console.WriteLine(customer.FirstName);
   Console.Read();
}

The last code snippet will print "Stack". What happened is that the Predicate delegate named prep was used as a search criteria to search in the list customers . Basically, this delegate was run on every element x of the list, and when x.Id == 1 it returns true , false otherwise. The x element where the predicate returned true is returned as the result of the Find method.