Est-il possible d'envoyer une méthode d'objet à une fonction?

Question

Je me demande s'il est possible (et quelle serait la syntaxe) d'envoyer la méthode d'un objet à une fonction.

Exemple:

Object "myObject" has two methods "method1" and "method2" 

Je voudrais avoir une fonction le long des lignes de:

public bool myFunc(var methodOnObject) 
{ 
    [code here] 
    var returnVal = [run methodOnObject here] 
    [code here] 
    return returnVal; 
} 

Alors que dans une autre fonction que je pouvais faire quelque chose comme

public void overallFunction() 
{ 
    var myObject = new ObjectItem(); 
    var method1Success = myFunc(myObject.method1); 
    var method2Success = myFunc(myObject.method2); 
} 

Answer 1

Existe-t-il vraiment un besoin de délégués explicites? Peut-être que cette approche pourrait vous aider:

private class MyObject 
{ 
    public bool Method1() { return true; } // Your own logic here 
    public bool Method2() { return false; } // Your own logic here 
} 

private static bool MyFunction(Func<bool> methodOnObject) 
{ 
    bool returnValue = methodOnObject(); 
    return returnValue; 
}  

private static void OverallFunction() 
{ 
    MyObject myObject = new MyObject(); 

    bool method1Success = MyFunction(myObject.Method1); 
    bool method2Success = MyFunction(myObject.Method2); 
} 

Answer 2

Oui , en utilisant les délégués.

Voici un exemple ..

delegate string myDel(int s); 
public class Program 
{ 
    static string Func(myDel f) 
    { 
     return f(2); 
    } 

    public static void Main() 
    { 
     Test obj = new Test(); 
     myDel d = obj.func; 
     Console.WriteLine(Func(d)); 
    } 
} 
class Test 
{ 
    public string func(int s) 
    { 
     return s.ToString(); 
    } 
} 

Answer 3

Oui, vous devez utiliser un délégué. Les délégués sont assez analogues aux pointeurs de fonction en C/C++.

Vous devez d'abord déclarer la signature du délégué. Dire que j'ai cette fonction:

private int DoSomething(string data) 
{ 
    return -1; 
} 

La déclaration de délégué serait ...

public delegate int MyDelegate(string data); 

Vous pouvez ensuite déclarer myFunc de cette façon ..

public bool myFunc(MyDelegate methodOnObject) 
{ 
    [code here] 
    int returnValue = methodOnObject("foo"); 
    [code here] 
    return returnValue; 
} 

Vous pouvez alors l'appeler de l'une des deux manières suivantes:

myFunc(new MyDelegate(DoSomething)); 

Ou, en C# 3.0 et versions ultérieures, vous pouvez utiliser le raccourci de ...

myFunc(DoSomething); 

(Il enveloppe juste la fonction fournie dans le constructeur par défaut pour ce délégué automatiquement. Les appels sont fonctionnellement identiques).

Si vous ne se soucient pas de créer effectivement un délégué ou la mise en œuvre de la fonction réelle des expressions simples, ce qui suit travaillera en C# 3.0 ainsi:

public bool myFunc(Func<string, int> expr) 
{ 
    [code here] 
    int returnValue = methodOnObject("foo"); 
    [code here] 
    return returnValue; 
} 

Ce qui pourrait alors être appelé comme ceci:

myFunc(s => return -1);