Qu'est-ce qu'un rappel et comment est-il implémenté en C #?

En programmation informatique , un rappel est un code exécutable qui est passé en argument à un autre code.

- Wikipédia: Callback (informatique)

C # a des délégués à cet effet. Ils sont très utilisés avec les événements , car un événement peut appeler automatiquement un certain nombre de délégués attachés (gestionnaires d'événements).

Je viens de vous rencontrer,
et c'est fou,
mais voici mon numéro (délégué),
donc si quelque chose se passe (événement),
appelez-moi, peut-être (rappel)?

Un rappel est une fonction qui sera appelée lorsqu'un processus a terminé l'exécution d'une tâche spécifique.

L'utilisation d'un rappel se fait généralement en logique asynchrone.

Pour créer un rappel en C #, vous devez stocker une adresse de fonction dans une variable. Ceci est réalisé en utilisant a delegateou le nouveau lambda semantic Funcor Action.

    public delegate void WorkCompletedCallBack(string result);

    public void DoWork(WorkCompletedCallBack callback)
    {
        callback("Hello world");
    }

    public void Test()
    {
        WorkCompletedCallBack callback = TestCallBack; // Notice that I am referencing a method without its parameter
        DoWork(callback);
    }

    public void TestCallBack(string result)
    {
        Console.WriteLine(result);
    }

Dans aujourd'hui C #, cela pourrait être fait en utilisant lambda comme:

    public void DoWork(Action<string> callback)
    {
        callback("Hello world");
    }

    public void Test()
    {
        DoWork((result) => Console.WriteLine(result));
    }

Définition

Un rappel est un code exécutable qui est passé en argument à un autre code.

la mise en oeuvre

// Parent can Read
public class Parent
{
    public string Read(){ /*reads here*/ };
}

// Child need Info
public class Child
{
    private string information;
    // declare a Delegate
    delegate string GetInfo();
    // use an instance of the declared Delegate
    public GetInfo GetMeInformation;

    public void ObtainInfo()
    {
        // Child will use the Parent capabilities via the Delegate
        information = GetMeInformation();
    }
}

Usage

Parent Peter = new Parent();
Child Johny = new Child();

// Tell Johny from where to obtain info
Johny.GetMeInformation = Peter.Read;

Johny.ObtainInfo(); // here Johny 'asks' Peter to read

Liens

• plus de détails pour C #.

Un rappel est un pointeur de fonction que vous passez à une autre fonction. La fonction que vous appelez «rappellera» (exécutera) l'autre fonction lorsqu'elle sera terminée.

Consultez ce lien.

Si vous faites référence aux rappels ASP.Net:

Dans le modèle par défaut des pages Web ASP.NET, l'utilisateur interagit avec une page et clique sur un bouton ou exécute une autre action qui entraîne une publication. La page et ses contrôles sont recréés, le code de la page s'exécute sur le serveur et une nouvelle version de la page est rendue dans le navigateur. Cependant, dans certaines situations, il est utile d'exécuter le code serveur à partir du client sans effectuer de publication. Si le script client de la page conserve certaines informations d'état (par exemple, les valeurs de variables locales), publier la page et en obtenir une nouvelle copie détruit cet état. En outre, les publications de page introduisent une surcharge de traitement qui peut réduire les performances et forcer l'utilisateur à attendre que la page soit traitée et recréée.

Pour éviter de perdre l'état du client et ne pas entraîner la surcharge de traitement d'un aller-retour de serveur, vous pouvez coder une page Web ASP.NET afin qu'elle puisse effectuer des rappels client. Dans un rappel client, une fonction client-script envoie une demande à une page Web ASP.NET. La page Web exécute une version modifiée de son cycle de vie normal. La page est lancée et ses contrôles et autres membres sont créés, puis une méthode spécialement marquée est appelée. La méthode effectue le traitement que vous avez codé, puis renvoie une valeur au navigateur qui peut être lue par une autre fonction de script client. Tout au long de ce processus, la page est en ligne dans le navigateur.

Source: http://msdn.microsoft.com/en-us/library/ms178208.aspx

Si vous faites référence à des rappels dans le code:

Les rappels sont souvent délégués aux méthodes qui sont appelées lorsque l'opération spécifique est terminée ou effectue une sous-action. Vous les trouverez souvent dans des opérations asynchrones. C'est un principe de programmation que vous pouvez trouver dans presque tous les langages de codage.

Plus d'informations ici: http://msdn.microsoft.com/en-us/library/ms173172.aspx

Dédicace à LightStriker:
exemple de code:

class CallBackExample
{
    public delegate void MyNumber();
    public static void CallMeBack()
    {
        Console.WriteLine("He/She is calling you.  Pick your phone!:)");
        Console.Read();
    }
    public static void MetYourCrush(MyNumber number)
    {
        int j;
        Console.WriteLine("is she/he interested 0/1?:");
        var i = Console.ReadLine();
        if (int.TryParse(i, out j))
        {
            var interested = (j == 0) ? false : true;
            if (interested)//event
            {
                //call his/her number
                number();
            }
            else
            {
                Console.WriteLine("Nothing happened! :(");
                Console.Read();
            }
        }
    }
    static void Main(string[] args)
    {
        MyNumber number = Program.CallMeBack;
        Console.WriteLine("You have just met your crush and given your number");
        MetYourCrush(number);
        Console.Read();
        Console.Read();
    }       
}

Explication du code:

J'ai créé le code pour implémenter l'explication amusante fournie par LightStriker dans l'une des réponses ci-dessus. Nous transmettons le délégué (nombre) à une méthode ( MetYourCrush). Si l'Interested (événement) se produit dans la méthode ( MetYourCrush), il appellera le délégué (numéro) qui détenait la référence de la CallMeBackméthode. Ainsi, la CallMeBackméthode sera appelée. Fondamentalement, nous transmettons un délégué pour appeler la méthode de rappel.

S'il vous plaît laissez-moi savoir si vous avez des questions.

Probablement pas la définition du dictionnaire, mais un rappel fait généralement référence à une fonction, qui est externe à un objet particulier, stockée puis appelée sur un événement spécifique.

Par exemple, lorsqu'un bouton d'interface utilisateur est créé, il stocke une référence à une fonction qui effectue une action. L'action est gérée par une partie différente du code mais lorsque le bouton est enfoncé, le rappel est appelé et cela appelle l'action à effectuer.

C #, plutôt que d'utiliser le terme «rappel», utilise «événements» et «délégués» et vous pouvez en savoir plus sur les délégués ici .

Un rappel vous permet de passer du code exécutable en tant qu'argument à un autre code. En C et C ++, cela est implémenté comme un pointeur de fonction. Dans .NET, vous utiliseriez un délégué pour gérer les pointeurs de fonction.

Quelques utilisations incluent la signalisation d'erreur et le contrôle du fait qu'une fonction agit ou non.

Wikipédia

étapes de travail de rappel:

1) nous devons implémenter l' ICallbackEventHandlerinterface

2) Enregistrez le script client:

 String cbReference = Page.ClientScript.GetCallbackEventReference(this, "arg", "ReceiveServerData", "context");
    String callbackScript = "function UseCallBack(arg, context)" + "{ " + cbReference + ";}";
    Page.ClientScript.RegisterClientScriptBlock(this.GetType(), "UseCallBack", callbackScript, true);

1) à partir de l'appel d'interface utilisateur Onclient, cliquez sur la fonction javascript pour EX: - builpopup(p1,p2,p3...)

var finalfield = p1, p2, p3; UseCallBack(finalfield, ""); données du client transmises au côté serveur à l'aide de UseCallBack

2) public void RaiseCallbackEvent(string eventArgument) Dans eventArgument nous obtenons les données passées // faisons une opération côté serveur et passons à "callbackResult"

3) GetCallbackResult() // en utilisant cette méthode, les données seront transmises au client (fonction ReceiveServerData ())

callbackResult

4) Récupérez les données côté client:, ReceiveServerData(text) dans la réponse du serveur de texte, nous obtiendrons.

Les délégués font la même chose que les rappels basés sur l'interface en C ++ (COM les utilise), bien qu'ils soient beaucoup plus simples à utiliser.

Notez que Microsoft a mis des délégués dans son implémentation Java (J ++) mais que Sun ne les aime pas [java.sun.com] donc ne vous attendez pas à les voir dans la version officielle de Java de si tôt. J'ai piraté un préprocesseur pour vous permettre de les utiliser en C ++, alors ne vous sentez pas exclu si vous ne programmez pas en C # ou sur la plate-forme .NET (c'est-à-dire en C ++ managé ou Visual Basic.NET).

Si vous avez l'habitude de faire fonctionner des pointeurs en C, un délégué est essentiellement une paire de pointeurs réunis en un:

• Un pointeur vers un objet (facultatif)
• Un pointeur vers une méthode de cet objet

Cela signifie qu'un seul délégué transmet toutes les informations nécessaires pour localiser une fonction dans votre programme, qu'il s'agisse d'une méthode statique ou associée à un objet.

Vous les définissez comme ceci en C #:

public delegate void FooCallbackType( int a, int b, int c );

Lorsque vous souhaitez les utiliser, vous rendez délégué la fonction que vous souhaitez appeler:

class CMyClass
{
    public void FunctionToCall( int a, int b, int c )
    {
        // This is the callback
    }

    public void Foo()
    {
        FooCallbackType myDelegate = new FooCallbackType(
            this.FunctionToCall );
        // Now you can pass that to the function
        // that needs to call you back.
    }
}

Si vous voulez qu'un délégué pointe vers une méthode statique, cela a la même apparence:

class CMyClassWithStaticCallback
{
    public static void StaticFunctionToCall( int a, int b, int c )
    {
        // This is the callback
    }

    public static void Foo()
    {
        FooCallbackType myDelegate = new FooCallbackType(
            CMyClass.StaticFunctionToCall );
    }
}

Dans l'ensemble, ils font la même chose que les rappels basés sur l'interface en C ++, mais causent un peu moins de problèmes car vous n'avez pas à vous soucier de nommer vos fonctions ou de créer des objets d'assistance, et vous pouvez créer des délégués à partir de n'importe quelle méthode. Ils sont plus flexibles.