Comment convertir un délégué en objet en C#?

Question

J'utilise la classe de réflexion pour invoquer certaines méthodes qui sont sur l'autre dll. Et l'un des paramètres des méthodes est le type de délégué.

Et je veux invoquer cette méthode en utilisant la réflexion. Donc, j'ai besoin de passer les paramètres de la fonction en tant que tableau d'objets, mais je n'ai rien trouvé à propos de comment convertir un délégué en objet.

Merci à l'avance

Answer 1

Un délégué est un objet. Créez simplement le délégué attendu comme vous le feriez normalement, et transmettez-le dans le tableau de paramètres. Voici un exemple assez artificiel:

class Mathematician { 
    public delegate int MathMethod(int a, int b); 

    public int DoMaths(int a, int b, MathMethod mathMethod) { 
     return mathMethod(a, b); 
    } 
} 

[Test] 
public void Test() { 
    var math = new Mathematician(); 
    Mathematician.MathMethod addition = (a, b) => a + b; 
    var method = typeof(Mathematician).GetMethod("DoMaths"); 
    var result = method.Invoke(math, new object[] { 1, 2, addition }); 
    Assert.AreEqual(3, result); 
} 

Answer 2

Les instances de délégués sont des objets, de sorte que ce code fonctionne (style C# 3):

Predicate<int> p = (i)=> i >= 42; 

Object[] arrayOfObject = new object[] { p }; 

Hope it helps!

Cédric

Answer 3

Voici un exemple:

class Program 
{ 
    public delegate void TestDel(); 

    public static void ToInvoke(TestDel testDel) 
    { 
     testDel(); 
    } 

    public static void Test() 
    { 
     Console.WriteLine("hello world"); 
    } 

    static void Main(string[] args) 
    { 
     TestDel testDel = Program.Test; 
     typeof(Program).InvokeMember(
      "ToInvoke", 
      BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Static, 
      null, 
      null, 
      new object[] { testDel }); 
    } 
} 

Answer 4

Je ne sais pas si je comprends bien votre question, mais vous pouvez créer un objet délégué d'une méthode comme ceci:

public class Test 
{ 
    public static void Method() {} 
} 

Ensuite, vous créez un objet délégué comme celui-ci:

Delegate myDelegate = new Delegate(Test.Method); 

Answer 5

Je pense que ce blog:

C# Reflection - Dealing with Remote Objects

répond à votre question tout à fait.

Answer 6

vous pouvez voir un délégué en tant que type de variable "fonction". le délégué décrit les paramètres et renvoie la valeur pour une fonction correspondante.

delegate void Foo(int a); // here a new delegate obj type Foo has been declared 

l'exemple ci-dessus permet d'utiliser « Foo » en tant que type de données, le seul objet autorisé qui peut être associé à une variable de type Foo type de données est un procédé avec la même signature ainsi:

void MyFunction(int x);  

Foo D = MyFunction; // this is OK 

void MyOtherFunction(string x); 

Foo D = MyOtherFunction; // will yield an error since not same signature. 

une fois que vous avez attribué une méthode à un délégué, vous pouvez appeler la méthode par le délégué:

int n = 1; 
D(n);  // or D.Invoke(n);