Appel d'une fonction à l'aide de la réflexion qui a un “params” paramètre (MethodBase)

J'ai MethodBases pour les deux fonctions:

public static int Add(params int[] parameters) { /* ... */ }
public static int Add(int a, int b) { /* ... */ }

J'ai une fonction qui s'appelle le MethodBases via une classe que j'ai fait:

MethodBase Method;
object Target;
public object call(params object[] input)
{
    return Method.Invoke(Target, input);
}

Maintenant, si je AddTwoMethod.call(5, 4); il fonctionne très bien.

Si j'ai cependant l'utilisation AddMethod.call(5, 4); il retourne:

Exception Non Gérée: System.De la réflexion.TargetParameterCountException: paramètres ne correspondent pas à la signature

Est-il possible de faire en sorte que les deux appels fonctionnent très bien sans avoir besoin d'manuellement en mettant les arguments dans un tableau pour le params int[]?

OriginalL'auteur Blam | 2011-06-26

c#mono parameters reflection

Vous pourriez modifier votre call méthode pour détecter le paramètre params et de convertir le reste de l'entrée dans un nouveau tableau. De cette façon, votre méthode pourrait agir à peu près la même que la logique C# s'applique à l'appel de méthode.

Quelque chose que j'ai rapidement construit pour vous (sachez que j'ai testé cette méthode dans une jolie manière limitée, donc il y aura peut-être des erreurs encore):

public object call(params object[] input)
{
    ParameterInfo[] parameters = Method.GetParameters();
    bool hasParams = false;
    if (parameters.Length > 0)
        hasParams = parameters[parameters.Length - 1].GetCustomAttributes(typeof(ParamArrayAttribute), false).Length > 0;

    if (hasParams)
    {
        int lastParamPosition = parameters.Length - 1;

        object[] realParams = new object[parameters.Length];
        for (int i = 0; i < lastParamPosition; i++)
            realParams[i] = input[i];

        Type paramsType = parameters[lastParamPosition].ParameterType.GetElementType();
        Array extra = Array.CreateInstance(paramsType, input.Length - lastParamPosition);
        for (int i = 0; i < extra.Length; i++)
            extra.SetValue(input[i + lastParamPosition], i);

        realParams[lastParamPosition] = extra;

        input = realParams;
    }

    return Method.Invoke(Target, input);
}

Sachez que j'ai testé cette méthode dans une jolie manière limitée, donc il y aura peut-être des erreurs encore.

Grand merci, Ne pense pas au sujet d'obtenir les attributs personnalisés et les tests pour les params comme ça!
Vous pouvez le faire de la manière que vous étiez en train avec la réflexion. Voir ma réponse pour une autre façon de plus en plus semblables à ce que vous essayiez. Personnellement, je pense que cette solution est trop compliqué pour ce que vous voulez.
Le call méthode peut être résolu avec un liner. J'ai trouver ce que vous proposez beaucoup trop compliqué et complètement inutile. Voir ma réponse pour plus d'info.
incroyable réponse!

OriginalL'auteur Jan-Peter Vos

6

En supposant que nous avons l'exemple suivant, la classe:
```
public class Test
{
    public static int Add(int i1, int i2)
    {
        return i1 + i2;
    }

    public static int Add(params int[] ints)
    {
        int sum = 0;
        foreach (int i in ints)
            sum += i;

        return sum;
    }
}
```
Pour obtenir le MethodInfo objets pour chaque surcharge de la statique Add méthode, vous devez effectuer les opérations suivantes:
```
 MethodInfo Add2Ints = typeof(Test).GetMethod("Add",  new Type[] { typeof(int), typeof(int) });
 MethodInfo AddParamsInts = typeof(Test).GetMethod("Add", new Type[] { typeof(int[]) });
```
Afin d'appeler l'une des deux méthodes, symply passer les arguments avec le type exact prévu par la surcharge vous appelez:
```
 Add2Ints.Invoke(null, new object[] { 1, 2 });
 AddParamsInts.Invoke(null, new object[] { new int[] { 1, 2 } });
```
Noter que le code suivant ne fonctionnera pas:
```
 AddParamsInts.Invoke(null, new object[] { 1, 2 }); 
```
parce que la signature de AddParmsInt est vraiment (int[]) et bien que le compilateur, par courtoisie, permet vous appelez cette méthode comme (int, int) sous le capot ce qui se passe réellement est que l'appel est converti pour vous sur le site d'appel à l'équivalent (int[]) appel. Par la réflexion, vous n'avez pas le compilateur "aide" si vous avez besoin de passer le exacte argument type est défini par la signature de la méthode.

Avec tout ce que dit, votre call méthode doit être comme suit:
```
 public object call(params object[] input)
 {
     return AddParamsInts.Invoke(null /*static*/, new object[] { input.Cast<int>().ToArray() });
 }
```
Notez que vous ne pouvez pas directement jeté un object[] tableau à une int[] tableau: int[] ints = (int[])input. Casting référence tapé tableaux à valeur de type des tableaux n'est pas autorisé.

Également important de noter que la définition de surcharges de la Add méthode sont inutiles, car ils se chevauchent. Considérer uniquement à l'aide de la params surcharge ou, dans le cas où vous voulez vous assurer qu'au moins deux arguments sont nécessaires afin d'évaluer une plus, surchargez la manière suivante:
```
 public int Add(int i1, int i2) { }
 public int Add(int i1, int i2, params int[] args) { }
```
Je comprends comment la réflexion œuvres, je me demandais si il était possible d'avoir un appel de méthode qui pourrait fonctionner comme la réponse que j'ai marqué correcte. Comme votre appel de méthode, mais pas spécifiquement pour params int[] fonctions, l'autre appel de méthode fonctionne réellement pour n'importe quelle fonction de la méthode. Dire que j'ai créer un Print(String Format, params object[] vars) fonction de sa méthode peut appeler ça correctement avec PrintMethod.call("A+B: {0}, A-B: {1}", A+B, A-B);
Ok, compris. Difficile de gleen que de vous r'original question de bien ;).

OriginalL'auteur InBetween
4

Vous devez envelopper les arguments dans un tableau, mais le compilateur se confondre, donc, vous avez besoin pour l'aider un peu:

Par exemple:
```
AddMethod.call((object) new int[] {5, 4 });
```
Cela conduit à un Système.ArgumentException: impossible de convertir des paramètres à essayer d'invoquer.
Oups: essayez int[] à la place.

OriginalL'auteur leppie

Vous devez vous connecter pour publier un commentaire.