Cette page vous a-t-elle été utile ?
Votre avis sur ce contenu est important. N'hésitez pas à nous faire part de vos commentaires.
Vous avez d'autres commentaires ?
1500 caractères restants
Exporter (0) Imprimer
Développer tout

ClientScriptManager.GetCallbackEventReference, méthode (String, String, String, String, String, Boolean)

Obtient la référence à une fonction cliente qui, lorsqu'elle est appelée, entraîne un rappel d'événements serveur par le client. La fonction cliente de cette méthode surchargée inclut une cible, un argument, un script client, un contexte, un gestionnaire d'erreurs et une valeur booléenne spécifiés.

Espace de noms: System.Web.UI
Assembly : System.Web (dans system.web.dll)

public string GetCallbackEventReference (
	string target,
	string argument,
	string clientCallback,
	string context,
	string clientErrorCallback,
	bool useAsync
)
public String GetCallbackEventReference (
	String target, 
	String argument, 
	String clientCallback, 
	String context, 
	String clientErrorCallback, 
	boolean useAsync
)
public function GetCallbackEventReference (
	target : String, 
	argument : String, 
	clientCallback : String, 
	context : String, 
	clientErrorCallback : String, 
	useAsync : boolean
) : String
Non applicable.

Paramètres

target

Nom d'un Control serveur qui gère le rappel client. Le contrôle doit implémenter l'interface ICallbackEventHandler et fournir une méthode RaiseCallbackEvent.

argument

Argument passé du script client au serveur

méthode RaiseCallbackEvent.

clientCallback

Nom du gestionnaire d'événements client qui reçoit le résultat de l'événement serveur réussi.

context

Script client qui est évalué sur le client avant l'initialisation du rappel. Le résultat du script est repassé au gestionnaire d'événements client.

clientErrorCallback

Nom du gestionnaire d'événements client qui reçoit le résultat lorsqu'une erreur se produit au niveau du gestionnaire d'événements serveur.

useAsync

true pour exécuter le rappel de manière asynchrone ; false pour l'exécuter de manière synchrone.

Valeur de retour

Nom d'une fonction cliente qui appelle le rappel client.

Cette surcharge de la méthode GetCallbackEventReference accepte un paramètre de type chaîne target au lieu d'un paramètre Control. Utilisez cette surcharge lorsque vous souhaitez que le rappel revienne vers autre chose qu'une chaîne qui contient le UniqueID du contrôle.

De plus, cette surcharge de la méthode GetCallbackEventReference requiert un useAsync et un paramètre clientErrorCallback. Le paramètre useAsync permet d'exécuter de manière asynchrone le rappel client en attribuant la valeur true. Les versions de surcharge de cette méthode qui ne requièrent pas le paramètre useAsync affectent par défaut la valeur false. Le paramètre clientErrorCallback permet de définir le nom de la fonction cliente qui est appelée si le gestionnaire serveur (la méthode RaiseCallbackEvent) retourne une erreur. Les versions de surcharge de cette méthode qui ne requièrent pas le paramètre clientErrorCallback affectent la valeur Null.

Pour plus d'informations sur cette méthode, consultez les notes sur la méthode de surcharge GetCallbackEventReference.

L'exemple de code suivant montre comment utiliser deux surcharges de la méthode GetCallbackEventReference dans un scénario de rappel client qui incrémente des entiers.

Deux mécanismes de rappel sont indiqués ; la différence entre les deux tient dans l'utilisation du paramètre context. Une fonction de rappel client ReceiveServerData1 est fournie au moyen du paramètre context. Par opposition, la fonction de rappel client ReceiveServerData2 est définie dans un bloc <script> sur la page. Une méthode RaiseCallbackEvent constitue le gestionnaire serveur qui incrémente la valeur qui lui est passée et la méthode GetCallbackResult retourne la valeur incrémentée sous forme de chaîne. Si la méthode RaiseCallbackEvent retourne une erreur, la fonction cliente ProcessCallBackError est appelée.

<%@ Page Language="C#" %>
<%@ Implements Interface="System.Web.UI.ICallbackEventHandler" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<script runat="server">
    
    public int cbCount = 0;
    
    // Define method that processes the callbacks on server.
    public void RaiseCallbackEvent(String eventArgument)
    {
        cbCount = Convert.ToInt32(eventArgument) + 1;
    }

    // Define method that returns callback result.
    public string GetCallbackResult()
    {
        return cbCount.ToString();
    }

    protected void Page_Load(object sender, EventArgs e)
    {
        // Define a StringBuilder to hold messages to output.
        StringBuilder sb = new StringBuilder();

        // Check if this is a postback.
        sb.Append("No page postbacks have occurred.");
        if (Page.IsPostBack)
        {
            sb.Append("A page postback has occurred.");
        }

        // Write out any messages.
        MyLabel.Text = sb.ToString();

        // Get a ClientScriptManager reference from the Page class.
        ClientScriptManager cs = Page.ClientScript;

        // Define one of the callback script's context.
        // The callback script will be defined in a script block on the page.
        StringBuilder context1 = new StringBuilder();
        context1.Append("function ReceiveServerData1(arg, context)");
        context1.Append("{");
        context1.Append("Message1.innerText =  arg;");
        context1.Append("value1 = arg;");
        context1.Append("}");

        // Define callback references.
        String cbReference1 = cs.GetCallbackEventReference(this, "arg", 
            "ReceiveServerData1", context1.ToString());
        String cbReference2 = cs.GetCallbackEventReference("'" + 
            Page.UniqueID + "'", "arg", "ReceiveServerData2", "", 
            "ProcessCallBackError", false);
        String callbackScript1 = "function CallTheServer1(arg, context) {" + 
            cbReference1 + "; }";
        String callbackScript2 = "function CallTheServer2(arg, context) {" + 
            cbReference2 + "; }";

        // Register script blocks will perform call to the server.
        cs.RegisterClientScriptBlock(this.GetType(), "CallTheServer1", 
            callbackScript1, true);
        cs.RegisterClientScriptBlock(this.GetType(), "CallTheServer2", 
            callbackScript2, true);

    }
</script>

<script type="text/javascript">
var value1 = 0;
var value2 = 0;
function ReceiveServerData2(arg, context)
{
    Message2.innerText = arg;
    value2 = arg;
}
function ProcessCallBackError(arg, context)
{
    Message2.innerText = 'An error has occurred.';
}
</script>

<html xmlns="http://www.w3.org/1999/xhtml" >
<head id="Head1" runat="server">
    <title>ClientScriptManager Example</title>
</head>
<body>
    <form id="Form1" 
          runat="server">
    <div>
      Callback 1 result: <span id="Message1">0</span>
      <br />
      Callback 2 result: <span id="Message2">0</span>
      <br /> <br />
      <input type="button" 
             value="ClientCallBack1" 
             onclick="CallTheServer1(value1, alert('Increment value'))"/>    
      <input type="button" 
             value="ClientCallBack2" 
             onclick="CallTheServer2(value2, alert('Increment value'))"/>
      <br /> <br />
      <asp:Label id="MyLabel" 
                 runat="server"></asp:Label>
    </div>
    </form>
</body>
</html>

Windows 98, Windows Server 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile pour Pocket PC, Windows Mobile pour Smartphone, Windows Server 2003, Windows XP Édition Media Center, Windows XP Professionnel Édition x64, Windows XP SP2, Windows XP Starter Edition

Microsoft .NET Framework 3.0 est pris en charge sur Windows Vista, Microsoft Windows XP SP2 et Windows Server 2003 SP1.

.NET Framework

Prise en charge dans : 3.0, 2.0

Ajouts de la communauté

AJOUTER
Afficher:
© 2015 Microsoft