Dans programmation informatique , un rappel est code exécutable qui est transmis en tant que argument à un autre code.
C # a délégués à cette fin. Ils sont fortement utilisés avec événements , puisqu'un événement peut automatiquement appeler un certain nombre de délégués attachés (gestionnaires d'événements).
Je viens de te rencontrer,
Et c'est fou,
Mais voici mon numéro (délégué),
Donc, si quelque chose se produit (événement),
Appelez-moi, peut-être (rappel)?
Un rappel est une fonction qui sera appelée lorsqu'un processus aura terminé l'exécution d'une tâche spécifique.
L'utilisation d'un rappel est 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 un delegate ou la nouvelle sémantique lambda Func ou 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 C # aujourd'hui, 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 transmis en tant qu'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 transmettez à une autre fonction. La fonction que vous appelez "callback" (exécutera) l'autre fonction une fois celle-ci terminée.
Découvrez this link.
Si vous vous référez aux rappels ASP.Net:
Dans le modèle par défaut pour les pages Web ASP.NET, l'utilisateur interagit avec une page et clique sur un bouton ou exécute une autre action entraînant 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 restituée au navigateur. Toutefois, dans certaines situations, il est utile d'exécuter le code serveur à partir du client sans effectuer de publication (postback). Si le script client de la page conserve des informations d'état (par exemple, les valeurs de variables locales), publier la page et en obtenir une nouvelle copie détruit cet état. De plus, les publications de page introduisent une surcharge de traitement susceptible de réduire les performances et d'obliger 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 serveur, vous pouvez coder une page Web ASP.NET afin qu'elle puisse effectuer des rappels de client. Dans un rappel client, une fonction de script client 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 invoquée. La méthode effectue le traitement que vous avez codé, puis renvoie au navigateur une valeur pouvant être lue par une autre fonction de script client. Tout au long de ce processus, la page est en direct 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 des délégués de méthodes qui sont appelées lorsque l'opération spécifique est terminée ou exécute une sous-action. Vous les trouverez souvent dans les 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 la réponse ci-dessus. Nous passons delegate (number) à une méthode (MetYourCrush). Si l'événement intéressé se produit dans la méthode (MetYourCrush), le délégué (numéro) qui contenait la référence de la méthode CallMeBack sera alors appelé. Ainsi, la méthode CallMeBack sera appelée. Fondamentalement, nous passons 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 autre partie du code, mais lorsque vous appuyez sur le bouton, le rappel est appelé, ce qui appelle l'action à effectuer.
C #, plutôt que d'utiliser le terme "callback", utilise "événements" et "délégués" pour en savoir plus sur les délégués ici .
Les délégués font la même chose que les rappels basés sur une interface en C++ (que COM utilise ceux-ci), 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 apprécie pas [Java.Sun.com], ne vous attendez donc pas à les voir dans la version officielle de Java dans peu de temps. 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 êtes habitué à utiliser des pointeurs en C, un délégué est essentiellement une paire de pointeurs réunis en un seul:
- Un pointeur sur un objet (facultatif)
- Un pointeur sur 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 );
Quand vous voulez les utiliser, vous faites déléguer la fonction que vous voulez 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 faire en sorte qu'un délégué pointe vers une méthode statique, le résultat est identique:
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 une 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 utilitaires, et vous pouvez faire des délégués avec n'importe quelle méthode. Ils sont plus flexibles.
rappel des étapes de travail:
1) nous devons implémenter ICallbackEventHandler Interface
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'interface utilisateur Onclient cliquez sur appelez la fonction javascript pour EX: - builpopup(p1,p2,p3...)
var finalfield = p1, p2, p3; UseCallBack(finalfield, ""); données du client transmises au serveur à l'aide de UseCallBack
2) public void RaiseCallbackEvent(string eventArgument) Dans eventArgument, nous obtenons les données transmises // effectuons une opération côté serveur et les transmettons à "callbackResult"
3) GetCallbackResult() // en utilisant cette méthode, les données seront transmises au côté client (fonction ReceiveServerData ())
callbackResult
4) Récupérer les données côté client: ReceiveServerData(text), en réponse au serveur de texte, nous l’avons.
Un rappel vous permet de transmettre du code exécutable en tant qu'argument à un autre code. En C et C++, cela est implémenté comme un pointeur de fonction. En .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 fonctionnement ou non d'une fonction.