C# pointeur de fonction?

je sais que c'est très vieux, mais, par exemple, quelque chose comme un pointeur de fonction en C# sera comme ceci:

class Temp 
{
   public void DoSomething() {}
   public void DoSomethingElse() {}
   public void DoSomethingWithAString(string myString) {}
   public bool GetANewCat(string name) { return true; }
}

...et puis dans votre main ou à l'endroit que:

var temp = new Temp();
Action myPointer = null, myPointer2 = null;
myPointer = temp.DoSomething;
myPointer2 = temp.DoSomethingElse;

puis appeler la fonction originale,

myPointer();
myPointer2();

si vous avez des arguments à vos méthodes, alors c'est aussi simple que d'ajouter des arguments génériques à votre Action:

Action<string> doItWithAString = null;
doItWithAString = temp.DoSomethingWithAString;

doItWithAString("help me");

Ou si vous avez besoin de retourner une valeur:

Func<string, bool> getACat = null;
getACat = temp.GetANewCat;

var gotIt = getACat("help me");

EDIT: j'ai mal lu votre question et je n'ai pas vu le peu sur le fait de vouloir faire une déclaration avec la manipulation de la mémoire brute. Je crains que ce ne soit pas recommandé parce que, comme le dit Raymond Chen, le GC déplace des trucs en mémoire (d'où le mot-clé "épinglé" dans C#). Vous pouvez probablement le faire avec réflexion, mais votre question suggère que vous n'avez pas une bonne compréhension du CLR. Bref, revenons à ma réponse non pertinente (où je pensais que tu voulais juste des informations sur la façon d'utiliser les délégués):

C# n'est pas un langage de script ;)

de toute façon, C# (et le CLR) a des "indicateurs de fonction" - sauf qu'ils sont appelés "délégués" et sont fortement dactylographiés, ce qui signifie que vous devez définir la signature de la fonction en plus de la fonction que vous voulez appeler.

Dans votre cas, vous auriez quelque chose comme ceci:

public static void Main(String[] args) {

    Function1();

}

// This is the "type" of the function pointer, known as a "delegate" in .NET.
// An instance of this delegate can point to any function that has the same signature (in this case, any function/method that returns void and accepts a single String argument).
public delegate void FooBarDelegate(String x); 


public static void Function1() {

    // Create a delegate to Function2
    FooBarDelegate functionPointer = new FooBarDelegate( Function2 );

    // call it
    functionPointer("bla");
}

public static void Function2(String x) {

    Console.WriteLine(x);
}

public string myFunction(string name)
{
    return "Hello " + name;
}

public string functionPointerExample(Func<string,string> myFunction)
{
    myFunction("Theron");
}

Func func functionName.. utilisez ceci pour faire circuler les méthodes. Cela n'a aucun sens dans ce contexte, mais c'est essentiellement comme cela que vous l'utiliseriez

j'avais le souhaitez, il est utile

class Program
{

    static void Main(string[] args)
    {
        TestPointer test = new TestPointer();
        test.function1();
    }
}
class TestPointer
{
    private delegate void fPointer(); // point to every functions that it has void as return value and with no input parameter
    public void function1()
    {
        fPointer point = new fPointer(function2);
        point();
    }
    private void function2()
    {
        Console.WriteLine("Bla");
    }
}

réécriture une méthode ne peut pas être faite directement à partir du code géré, cependant l'api de profilage .net non gérée peut être utilisée pour faire cela. Voir article msdn par exemple sur la façon de l'utiliser.