C#•11mo ago•

15 replies

Creating a method that takes a generic method and its variadic parameters as arguments and call it i

I need a way to pass generic static methods and its argument to another method, and the static method inside this another method.

In C++, I can easily achieve this with variadic templates and

std::forward

std::forward

#include <utility>
#include <cstdio>

template <typename Func, typename... Args>
void actual_call_func(Func func, Args &&...args) {
    func(std::forward<Args>(args)...);
}

int main() {
    auto func = std::printf;
    constexpr const char* param_0 = "%d + %d = %d";
    int param_1 = 3;
    int param_2 = 4;
    int param_3 = 3 + 4;

    actual_call_func(func, param_0, param_1, param_2, param_3);
}

#include <utility>
#include <cstdio>

template <typename Func, typename... Args>
void actual_call_func(Func func, Args &&...args) {
    func(std::forward<Args>(args)...);
}

int main() {
    auto func = std::printf;
    constexpr const char* param_0 = "%d + %d = %d";
    int param_1 = 3;
    int param_2 = 4;
    int param_3 = 3 + 4;

    actual_call_func(func, param_0, param_1, param_2, param_3);
}

But I don't know how to do this easily in C#;

Previously I just captured all the required arguments into a lambda, which calls the static method inside of it, and passed it as an single

Action

Action

// Let's just pass this to the actual call function
Action call = () => { Console.WriteLine(param0, param1); };

// Let's just pass this to the actual call function
Action call = () => { Console.WriteLine(param0, param1); };

But this breaks when I have non-capturable arguments such as

Span<T>

Span<T>

.
And I don't want to use

params object[]?

params object[]?

to box the arguments.

The only way I can think of is declaring the

ActualCallFunc

ActualCallFunc

one by one:

void ActualCallFunc(Action func);
void ActualCallFunc<T>(Action<T> func, T param0);
void ActualCallFunc<T0, T1>(Action<T0, T1> func, T0 param0, T1 param1);
void ActualCallFunc<T0, T1, T2>(Action<T0, T1, T2> func, T0 param0, T1 param1, T2 param2);
...

void ActualCallFunc(Action func);
void ActualCallFunc<T>(Action<T> func, T param0);
void ActualCallFunc<T0, T1>(Action<T0, T1> func, T0 param0, T1 param1);
void ActualCallFunc<T0, T1, T2>(Action<T0, T1, T2> func, T0 param0, T1 param1, T2 param2);
...

But not only this is cumbersome, it would not work if sometimes the parameter needs to use

ref

ref

.

Is there any nice way to solve this like in C++?

Creating a method that takes a generic method and its variadic parameters as arguments and call it i

I need a way to pass generic static methods and its argument to another method, and the static method inside this another method.

In C++, I can easily achieve this with variadic templates and

std::forward

std::forward

#include <utility>
#include <cstdio>

template <typename Func, typename... Args>
void actual_call_func(Func func, Args &&...args) {
    func(std::forward<Args>(args)...);
}

int main() {
    auto func = std::printf;
    constexpr const char* param_0 = "%d + %d = %d";
    int param_1 = 3;
    int param_2 = 4;
    int param_3 = 3 + 4;

    actual_call_func(func, param_0, param_1, param_2, param_3);
}

#include <utility>
#include <cstdio>

template <typename Func, typename... Args>
void actual_call_func(Func func, Args &&...args) {
    func(std::forward<Args>(args)...);
}

int main() {
    auto func = std::printf;
    constexpr const char* param_0 = "%d + %d = %d";
    int param_1 = 3;
    int param_2 = 4;
    int param_3 = 3 + 4;

    actual_call_func(func, param_0, param_1, param_2, param_3);
}

But I don't know how to do this easily in C#;

Previously I just captured all the required arguments into a lambda, which calls the static method inside of it, and passed it as an single

Action

Action

// Let's just pass this to the actual call function
Action call = () => { Console.WriteLine(param0, param1); };

// Let's just pass this to the actual call function
Action call = () => { Console.WriteLine(param0, param1); };

But this breaks when I have non-capturable arguments such as

Span<T>

Span<T>

.
And I don't want to use

params object[]?

params object[]?

to box the arguments.

The only way I can think of is declaring the

ActualCallFunc

ActualCallFunc

one by one:

void ActualCallFunc(Action func);
void ActualCallFunc<T>(Action<T> func, T param0);
void ActualCallFunc<T0, T1>(Action<T0, T1> func, T0 param0, T1 param1);
void ActualCallFunc<T0, T1, T2>(Action<T0, T1, T2> func, T0 param0, T1 param1, T2 param2);
...

void ActualCallFunc(Action func);
void ActualCallFunc<T>(Action<T> func, T param0);
void ActualCallFunc<T0, T1>(Action<T0, T1> func, T0 param0, T1 param1);
void ActualCallFunc<T0, T1, T2>(Action<T0, T1, T2> func, T0 param0, T1 param1, T2 param2);
...

But not only this is cumbersome, it would not work if sometimes the parameter needs to use

ref

ref

.

Is there any nice way to solve this like in C++?

Creating a method that takes a generic method and its variadic parameters as arguments and call it i

Similar Threads

Creating a method that takes a generic method and its variadic parameters as arguments and call it i

Similar Threads

Similar Threads

Similar Threads