Func<> avec un nombre indéterminé de paramètres

Considérer le pseudo-code suivant:

    TResult Foo<TResult>(Func<T1, T2,...,Tn, TResult> f, params object[] args)
    {
        TResult result = f(args);
        return result;
    }

La fonction accepte Func<> avec un nombre indéterminé de paramètres génériques et une liste des arguments correspondants. Est-il possible de l'écrire en C#? Comment définir et appeler Foo? Comment puis-je passer args à f?

Malheureusement pas possible 🙁 Vous pouvez le faire via Delegate et l'utilisation de la réflexion, mais je suis sûr que c'est pas ce que vous voulez.

OriginalL'auteur user2341923 | 2014-04-03

.net c#clr functional-programming generics

Ce n'est pas possible. Au mieux, vous pourriez avoir un délégué qui prend un nombre variable d'arguments, et puis avoir délégué à analyser les arguments

TResult Foo<TResult>(Func<object[], TResult> f, params object[] args)
{
    TResult result = f(args);
    return result;
}

Foo<int>(args =>
{
    var name = args[0] as string;
    var age = (int) args[1];

    //...

    return age;
}, arg1, arg2, arg3);

OriginalL'auteur dcastro

9

Vous pouvez utiliser Delegate avec DynamicInvoke.

Avec ça, vous n'avez pas besoin de gérer avec object[] dans f.
```
TResult Foo<TResult>(Delegate f, params object[] args)
{
    var result = f.DynamicInvoke(args);
    return (TResult)Convert.ChangeType(result, typeof(TResult));
}
```
Utilisation:
```
Func<string, int, bool, bool> f = (name, age, active) =>
{
    if (name == "Jon" && age == 40 && active)
    {
        return true;
    }
    return false;
}; 

Foo<bool>(f,"Jon", 40, true);
```
J'ai créé un violon montrant quelques exemples: https://dotnetfiddle.net/LdmOqo

Remarque:

Si vous souhaitez utiliser un method group, vous devez utiliser un explicit casting pour Func:
```
public static bool Method(string name, int age)
{
    ...
}
var method = (Func<string, int, bool>)Method;
Foo<bool>(method, "Jon", 40);
```
Violon: https://dotnetfiddle.net/3ZPLsY

N'est-ce fonctionne réellement? Le DynamicInvoke refléter le Tableau comme délimité par des virgules des paramètres dans les méthodes d'exécution?
Oui @GoldBishop. DynamicInvoke est exactement ce que fait. Dans ce violon je vous montre quelques exemples. Vérifier la doc msdn DynamicInvoke pour plus d'informations.
hmmmm...le mal qui peut être fait avec une telle connaissance 🙂
Bon point @yoyo. Pour utiliser cette fonction avec la méthode de groupe, vous devez utiliser explicit casting. J'ai créé un autre violon montrant comment vous pouvez faire ceci: dotnetfiddle.net/qVlt47 je vais mettre à jour mon awnser l'expliquer. Merci pour les commentaires!
Merci pour la mise à jour, et le violon (dotNetFiddle est grand!) J'ai essayé de trouver un moyen de manipulation arbitraire de paramètres sans avoir à indiquer les types de paramètres sur le site d'appel, mais j'ai décidé de trouver une autre façon de résoudre mon problème. (BTW, Method("yoyo", 22) certainement renvoie faux! 😉

OriginalL'auteur Renan Araújo

Dans certains cas, vous pouvez être en mesure de sortir avec un truc comme ceci:

public static class MyClass
{
    private static T CommonWorkMethod<T>(Func<T> wishMultipleArgsFunc)
    {
        //... do common preparation
        T returnValue = wishMultipleArgsFunc();
        //... do common cleanup
        return returnValue;
    }

    public static int DoCommonWorkNoParams() => CommonWorkMethod<int>(ProduceIntWithNoParams);
    public static long DoCommonWorkWithLong(long p1) => CommonWorkMethod<long>(() => ProcessOneLong(p1));
    public static string DoCommonWorkWith2Params(int p1, long p2) => CommonWorkMethod<string>(() => ConvertToCollatedString(p1, p2));

    private static int ProduceIntWithNoParams() { return 5; }
}

OriginalL'auteur DDRider62

0

Vous pouvez essayer quelque chose de semblable à ce que j'ai posté ici: https://stackoverflow.com/a/47556051/4681344

Elle permettra de disposer d'un nombre quelconque d'arguments, et applique leurs types.
```
public delegate T ParamsAction<T>(params object[] args);

TResult Foo<TResult>(ParamsAction<TResult> f)
{
    TResult result = f();
    return TResult;
}
```
de l'appeler, tout simplement...
```
Foo(args => MethodToCallback("Bar", 123));
```
OriginalL'auteur Bryan Clark

Vous devez vous connecter pour publier un commentaire.