Utilisation de services Web dans ASP.NET AJAX
Mise à jour : novembre 2007
Cette rubrique décrit comment accéder à des services Web à partir d'un script client dans des pages Web ASP.NET AJAX. Les services peuvent être des services personnalisés que vous créez ou des services d'application intégrés. Les services d'application sont fournis dans le cadre d'ASP.NET AJAX et incluent les services d'authentification, de rôle et de profil.
Les services Web personnalisés peuvent se présenter sous la forme de services Web ASP.NET (services .asmx) ou de services Windows Communication Foundation (WCF) (services .svc).
Cette rubrique contient les informations suivantes :
Scénarios
Contexte
Exemples
Ressources supplémentaires
Référence de classe
Nouveautés
Scénarios
Vous utilisez WCF et ASP.NET dans les cas suivants :
Si vous avez déjà créé des services WCF, vous pouvez ajouter des points de terminaison pour permettre au script de pages Web AJAX d'accéder aux services. Pour plus d'informations, consultez Exposition de services WCF au script client.
Si vous avez déjà créé des services Web ASP.NET (.asmx), vous pouvez les modifier pour permettre au script de pages Web AJAX d'accéder au même service. Pour plus d'informations, consultez Exposition de services Web au script client.
Si vous souhaitez créer un service Web personnalisé accessible à partir de pages Web ASP.NET AJAX, vous pouvez l'implémenter en tant que service WCF ou Web ASP.NET (fichier .asmx).
Vous pouvez utiliser les services d'application ASP.NET intégrés pour accéder aux informations d'authentification, de rôle et de profil des utilisateurs à partir d'un script client exécuté dans une page Web AJAX. Pour plus d'informations, consultez Utilisation de l'authentification par formulaire avec ASP.NET AJAX.
Contexte
ASP.NET vous permet de créer des services Web accessibles à partir d'un script client de pages Web. Les pages communiquent avec le serveur par une couche de communication de service Web qui utilise la technologie AJAX pour appeler des services Web. Les données sont échangées de façon asynchrone entre le client et le serveur, en général au format JSON.
Communication client-serveur pour les clients AJAX
Dans les pages Web AJAX, le navigateur envoie une première demande au serveur pour la page, puis envoie des demandes asynchrones aux services Web pour les données. Les éléments de communication du client se présentent sous la forme de classes proxy téléchargées depuis le serveur et la bibliothèque principale de scripts clients. Les éléments de communication du serveur sont des gestionnaires et des services personnalisés. L'illustration suivante montre les éléments impliqués dans la communication entre le client et le serveur.
Communication serveur-client
.png)
Architecture client AJAX
Les navigateurs appellent des méthodes de service Web à l'aide de classes proxy. Une classe proxy est un script généré automatiquement par le serveur et téléchargé dans le navigateur lors du chargement de la page. La classe proxy fournit un objet client qui représente les méthodes exposées d'un service Web.
Pour appeler une méthode de service Web, le script client appelle les méthodes correspondantes de la classe proxy. Les appels sont effectués de manière asynchrone, via l'objet XMLHTTP.
La couche de communication de service Web contient les types de scripts de la bibliothèque qui permettent aux classes proxy d'appeler des services. Pour plus d'informations, consultez les classes contenues dans l'espace de noms Sys.Net.
Le code des classes proxy et de la couche de communication de service Web principale masque la complexité du code XMLHTTP ainsi que les différences entre navigateurs. Cela permet de simplifier le script client requis pour appeler le service Web.
Une demande de service Web peut être envisagée de deux manières différentes :
Appel de services Web à l'aide du verbe HTTP POST. Une demande POST possède un corps qui contient les données que le navigateur envoie au serveur. Elle n'a pas de limitation de taille. Par conséquent, vous pouvez utiliser une demande POST lorsque la taille des données dépasse la limitation de taille intrinsèque à une demande GET. Le client sérialise la demande au format JSON et l'envoie en tant que données POST au serveur. Le serveur désérialise les données JSON en types .NET Framework et émet l'appel du service Web. Pendant la réponse, le serveur sérialise les valeurs de retour et les renvoie au client, qui les désérialise en objets JavaScript en vue de leur traitement.
Appel de services Web à l'aide du verbe HTTP GET. Cette méthode fonctionne comme une demande POST, mais avec les différences suivantes :
Le client utilise une chaîne de requête pour envoyer les paramètres au serveur.
Une demande GET peut appeler uniquement une méthode de service Web configurée à l'aide de l'attribut ScriptMethodAttribute.
La taille des données est limitée à la longueur d'URL autorisée par le navigateur.
.gif "Remarque")
Remarque :Évitez les demandes GET pour les appels de méthode qui modifient des données sur le serveur ou qui exposent des informations critiques. Dans les demandes GET, le message est codé par le navigateur dans l'URL, ce qui en fait une proie facile pour les falsifications de données. Pour les demandes GET et POST, suivez les recommandations de sécurité pour la protection de vos données sensibles.
L'illustration suivante présente l'architecture client ASP.NET AJAX.
Architecture client AJAX
.png)
Les éléments de l'architecture client incluent la couche de communication de service Web dans la bibliothèque principale et les classes proxy téléchargées pour les services utilisés dans la page. Les différents éléments présentés dans l'illustration sont les suivants :
Classes proxy de service personnalisé. Il s'agit d'un script client généré automatiquement par le serveur et téléchargé dans le navigateur. Les classes proxy fournissent un objet pour chaque service WCF ou ASMX utilisé dans la page. (Autrement dit, elles fournissent un objet pour chaque élément de l'élément ServiceReferences du contrôle ScriptManager dans la page.) L'appel d'une méthode proxy dans un script client crée une demande asynchrone de la méthode de service Web correspondante sur le serveur.
Classe proxy d'authentification. La classe proxy AuthenticationService est générée par le service d'application d'authentification du serveur. Elle permet à l'utilisateur d'ouvrir ou de fermer une session via JavaScript dans le navigateur, sans avoir à faire un aller-retour jusqu'au serveur.
Classe proxy de rôle. La classe proxy RoleService est générée par le service d'application de rôle du serveur. Elle vous permet de regrouper des utilisateurs et de traiter chaque de groupe comme une unité via JavaScript, sans avoir à faire d'allers-retours jusqu'au serveur. Cela peut s'avérer utile pour autoriser ou refuser l'accès aux ressources sur le serveur.
Classe proxy de profil. La classe ProfileService est générée par le service d'application de profil du serveur. Elle permet au client d'accéder aux informations de profil de l'utilisateur actuel via JavaScript, sans avoir à faire d'allers-retours jusqu'au serveur.
Classe proxy de méthodes de page. Ce type de classe fournit l'infrastructure de script permettant au script client d'appeler des méthodes statiques dans une page ASP.NET, comme s'il s'agissait de méthodes de service Web. Pour plus d'informations, consultez Appel de services Web à partir du script client.
Couche de communication de service Web. Il s'agit de la bibliothèque qui contient les types de script client. Ces types permettent au navigateur (client) de communiquer avec les services sur le serveur. Ils protègent également les applications clientes des complexités inhérentes à l'établissement et à la maintenance d'une communication asynchrone entre le client et le serveur. Ils encapsulent l'objet XMLHTTP du navigateur qui fournit la fonction asynchrone et permettent aux applications clientes d'être indépendantes du navigateur. Les éléments suivants représentent les éléments principaux de la couche de communication de service Web :
WebRequest. Cet élément fournit les fonctionnalités de script client nécessaires à toute demande Web. Pour plus d'informations, consultez la classe WebRequest.
WebRequestManager. Cet élément gère le flux des demandes Web émises par l'objet WebRequest à l'objet exécuteur associé. Pour plus d'informations, consultez la classe WebRequestManager.
XmlHttpExecutor. Cet élément effectue des demandes de réseau asynchrones à l'aide du support XMLHTTP du navigateur. Pour plus d'informations, consultez la classe XmlHttpExecutor.
Sérialisation JSON. Cet élément sérialise des objets JavaScript au format JSON. La désérialisation est disponible avec la fonction JavaScript eval. Pour plus d'informations, consultez la classe JavaScriptSerializer.
Le format de sérialisation par défaut est JSON, mais certaines méthodes individuelles dans les services Web et dans les pages Web ASP.NET peuvent retourner d'autres formats, tels que XML. Le format de sérialisation d'une méthode peut être spécifié avec les attributs. Par exemple, pour un service ASMX, vous pouvez définir l'attribut ScriptMethodAttribute de sorte à ce qu'une méthode de service Web retourne des données XML, comme indiqué dans l'exemple suivant :
[ScriptMethod(ResponseFormat.Xml)]
<ScriptMethod(ResponseFormat.Xml)>
Architecture serveur AJAX
L'illustration suivante présente l'architecture serveur AJAX, qui inclut les éléments permettant de communiquer avec les applications clientes.
Architecture serveur AJAX
.png)
Les éléments de l'architecture serveur incluent la couche de communication de service Web ainsi qu'un gestionnaire HTTP et des classes de sérialisation, des services personnalisés, des méthodes de page et des services d'application. Les différents éléments présentés dans l'illustration sont les suivants :
Services Web personnalisés. Ces services fournissent les fonctionnalités de service que vous implémentez et retournent la réponse appropriée au client. Les services Web personnalisés peuvent être des services ASP.NET ou WCF. La couche de communication de service Web génère automatiquement des classes proxy de script client qui peuvent être appelées de façon asynchrone à partir d'un script client.
Méthodes de page. Ce composant permet à une méthode dans une page ASP.NET d'être appelée comme une méthode de service Web. Les méthodes de page doivent être définies dans la page qui effectue l'appel de la méthode de page.
Service d'authentification. Le service d'authentification génère une classe proxy d'authentification qui permet à l'utilisateur d'ouvrir ou de fermer une session via du code JavaScript client. Ce service d'application est toujours disponible et vous n'avez donc pas à l'instancier. Pour plus d'informations, consultez Utilisation de l'authentification par formulaire avec ASP.NET AJAX.
Service de rôle. Le service de rôle génère une classe proxy de rôle qui permet au code JavaScript client d'accéder aux informations de rôle de l'utilisateur actuellement authentifié. Ce service d'application est toujours disponible et vous n'avez donc pas à l'instancier. Pour plus d'informations, consultez Utilisation d'informations de rôle avec ASP.NET AJAX.
Service de profil. Le service de profil génère une classe proxy de profil qui permet au code JavaScript client d'obtenir et de définir des propriétés de profil pour l'utilisateur associé à la demande actuelle. Ce service d'application est toujours disponible et vous n'avez donc pas à l'instancier. Pour plus d'informations, consultez Utilisation d'informations de profil avec ASP.NET AJAX.
Sérialisation JSON. Le composant serveur de sérialisation JSON permet une sérialisation et une désérialisation personnalisables de types .NET Framework communs vers et depuis le format JSON. Pour plus d'informations, consultez JavaScriptSerializer.
Sérialisation XML. La couche de communication de service Web prend en charge la sérialisation XML pour les demandes SOAP aux services Web et pour le retour de types XML à partir d'une demande JSON à un service Web.
Exemples
Les exemples suivants indiquent comment appeler des services ASP.NET et WCF à partir d'un script client. Des exemples d'appels de services d'application à partir de script client sont fournis dans d'autres sections de cette documentation. Les liens associés sont indiqués plus loin dans cette rubrique.
Appel de méthodes de service Web dans AJAX
.NET Framework vous permet d'appeler, de façon asynchrone, des méthodes de services Web ASP.NET (.asmx) à partir du navigateur, à l'aide du script client. La page peut appeler des méthodes serveur sans publication et sans actualiser la page entière, car seules des données sont transférées entre le navigateur et le serveur.
L'exemple suivant montre comment exposer une méthode de service Web dans une page Web ASP.NET.
<%@ Page Language="VB" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head id="Head1" >
<style type="text/css">
body { font: 11pt Trebuchet MS;
font-color: #000000;
padding-top: 72px;
text-align: center }
.text { font: 8pt Trebuchet MS }
</style>
<title>Simple Web Service</title>
<script type="text/javascript">
// This function calls the Web Service method.
function GetServerTime()
{
Samples.AspNet.ServerTime.GetServerTime(OnSucceeded);
}
// This is the callback function that
// processes the Web Service return value.
function OnSucceeded(result)
{
var RsltElem = document.getElementById("Results");
RsltElem.innerHTML = result;
}
</script>
</head>
<body>
<form id="Form1" >
<asp:ScriptManager ID="scriptManager">
<Services>
<asp:ServiceReference path="ServerTime.asmx" />
</Services>
</asp:ScriptManager>
<div>
<h2>Server Time</h2>
<p>Calling a service that returns the current server time.</p>
<input id="EchoButton" type="button"
value="GetTime" onclick="GetServerTime()" />
</div>
</form>
<hr/>
<div>
<span id="Results"></span>
</div>
</body>
</html>
<%@ Page Language="C#" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head id="Head1" >
<style type="text/css">
body { font: 11pt Trebuchet MS;
font-color: #000000;
padding-top: 72px;
text-align: center }
.text { font: 8pt Trebuchet MS }
</style>
<title>Simple Web Service</title>
<script type="text/javascript">
// This function calls the Web Service method.
function GetServerTime()
{
Samples.AspNet.ServerTime.GetServerTime(OnSucceeded);
}
// This is the callback function that
// processes the Web Service return value.
function OnSucceeded(result)
{
var RsltElem = document.getElementById("Results");
RsltElem.innerHTML = result;
}
</script>
</head>
<body>
<form id="Form1" >
<asp:ScriptManager ID="scriptManager">
<Services>
<asp:ServiceReference path="ServerTime.asmx" />
</Services>
</asp:ScriptManager>
<div>
<h2>Server Time</h2>
<p>Calling a service that returns the current server time.</p>
<input id="EchoButton" type="button"
value="GetTime" onclick="GetServerTime()" />
</div>
</form>
<hr/>
<div>
<span id="Results"></span>
</div>
</body>
</html>
L'exemple suivant présente une page Web et le service Web associé appelé par le script de la page.
<%@ WebService Language="VB" Class="Samples.AspNet.ServerTime" %>
Imports System.Web
Imports System.Web.Services
Imports System.Xml
Imports System.Web.Services.Protocols
Imports System.Web.Script.Services
Namespace Samples.AspNet
<WebService(Namespace:="http://tempuri.org/")> _
<WebServiceBinding(ConformsTo:=WsiProfiles.BasicProfile1_1)> _
<ScriptService()> _
Public Class ServerTime
Inherits System.Web.Services.WebService
<WebMethod()> _
Public Function GetServerTime() As String
Return String.Format("The current time is {0}.", _
DateTime.Now)
End Function
End Class
End Namespace
<%@ WebService Language="C#" Class="Samples.AspNet.ServerTime" %>
using System;
using System.Web;
using System.Web.Services;
using System.Xml;
using System.Web.Services.Protocols;
using System.Web.Script.Services;
namespace Samples.AspNet
{
[WebService(Namespace = "http://tempuri.org/")]
[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
[ScriptService]
public class ServerTime : System.Web.Services.WebService
{
[WebMethod]
public string GetServerTime()
{
return String.Format("The server time is {0}.",
DateTime.Now);
}
}
}
Requêtes HTTP à partir d'un client AJAX
L'exemple précédent montre comment appeler des services Web à partir d'un script client en appelant les classes proxy générées automatiquement pour le service Web. Vous pouvez également effectuer des appels de services Web de niveau inférieur à partir d'un script client. Appliquez cette procédure si vous devez gérer la couche de communication ou examiner les données envoyées vers ou depuis le serveur. Pour appeler des services Web avec cette procédure, utilisez la classe WebRequest.
L'exemple suivant montre comment utiliser un objet WebRequest pour implémenter des demandes Web GET et POST qui se connectent aux URL spécifiées (points de terminaison HTTP).
// ConnectingEndPoints.js
var resultElement;
function pageLoad()
{
resultElement = $get("ResultId");
}
// This function performs a GET Web request.
function GetWebRequest()
{
alert("Performing Get Web request.");
// Instantiate a WebRequest.
var wRequest = new Sys.Net.WebRequest();
// Set the request URL.
wRequest.set_url("getTarget.htm");
alert("Target Url: getTarget.htm");
// Set the request verb.
wRequest.set_httpVerb("GET");
// Set the request callback function.
wRequest.add_completed(OnWebRequestCompleted);
// Clear the results area.
resultElement.innerHTML = "";
// Execute the request.
wRequest.invoke();
}
// This function performs a POST Web request.
function PostWebRequest()
{
alert("Performing Post Web request.");
// Instantiate a WebRequest.
var wRequest = new Sys.Net.WebRequest();
// Set the request URL.
wRequest.set_url("postTarget.aspx");
alert("Target Url: postTarget.aspx");
// Set the request verb.
wRequest.set_httpVerb("POST");
// Set the request handler.
wRequest.add_completed(OnWebRequestCompleted);
// Set the body for he POST.
var requestBody =
"Message=Hello! Do you hear me?";
wRequest.set_body(requestBody);
wRequest.get_headers()["Content-Length"] =
requestBody.length;
// Clear the results area.
resultElement.innerHTML = "";
// Execute the request.
wRequest.invoke();
}
// This callback function processes the
// request return values. It is called asynchronously
// by the current executor.
function OnWebRequestCompleted(executor, eventArgs)
{
if(executor.get_responseAvailable())
{
// Clear the previous results.
resultElement.innerHTML = "";
// Display Web request status.
resultElement.innerHTML +=
"Status: [" + executor.get_statusCode() + " " +
executor.get_statusText() + "]" + "<br/>";
// Display Web request headers.
resultElement.innerHTML +=
"Headers: ";
resultElement.innerHTML +=
executor.getAllResponseHeaders() + "<br/>";
// Display Web request body.
resultElement.innerHTML +=
"Body:";
if(document.all)
resultElement.innerText +=
executor.get_responseData();
else
resultElement.textContent +=
executor.get_responseData();
}
}
if (typeof(Sys) !== "undefined") Sys.Application.notifyScriptLoaded();
Appel d'opérations de service WCF dans AJAX
Vous pouvez appeler, de façon asynchrone, des services Windows Communication Foundation (WCF) (.svc) à partir d'un script client comme s'il s'agissait, en fait, de services .asmx. L'exemple suivant montre comment exposer et appeler des opérations de service WCF dans une page Web ASP.NET.
<%@ Page Language="VB" AutoEventWireup="true" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" >
<head >
<style type="text/css">
body { font: 11pt Trebuchet MS;
font-color: #000000;
padding-top: 72px;
text-align: center }
.text { font: 8pt Trebuchet MS }
</style>
<title>Simple WCF Service Page</title>
</head>
<body>
<form id="form1" >
<asp:ScriptManager ID="ScriptManager1" >
<Services>
<asp:ServiceReference
Path="SimpleService.svc/ws"/>
</Services>
<Scripts>
<asp:ScriptReference Path="service.js" />
</Scripts>
</asp:ScriptManager>
<div>
<h2>Simple WCF Service</h2>
<input type='button' name="clickme" value="Greetings"
onclick="javascript:OnClick()" />
<input type='button' name="clickme2" value="Greetings2"
onclick="javascript:OnClick2()" />
<hr/>
<div>
<span id="Results"></span>
</div>
</div>
</form>
</body>
</html>
<%@ Page Language="C#" AutoEventWireup="true"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" >
<head >
<style type="text/css">
body { font: 11pt Trebuchet MS;
font-color: #000000;
padding-top: 72px;
text-align: center }
.text { font: 8pt Trebuchet MS }
</style>
<title>Simple WCF Service Page</title>
</head>
<body>
<form id="form1" >
<asp:ScriptManager ID="ScriptManager1" >
<Services>
<asp:ServiceReference
Path="SimpleService.svc/ws"/>
</Services>
<Scripts>
<asp:ScriptReference Path="service.js" />
</Scripts>
</asp:ScriptManager>
<div>
<h2>Simple WCF Service</h2>
<input type='button' name="clickme" value="Greetings"
onclick="javascript:OnClick()" />
<input type='button' name="clickme2" value="Greetings2"
onclick="javascript:OnClick2()" />
<hr/>
<div>
<span id="Results"></span>
</div>
</div>
</form>
</body>
</html>
var ServiceProxy;
function pageLoad()
{
ServiceProxy = new ISimpleService();
ServiceProxy.set_defaultSucceededCallback(SucceededCallback);
}
function OnClick()
{
// var myService = new ISimpleService();
ServiceProxy.HelloWorld1("George");
}
function OnClick2()
{
var dc = new DataContractType();
dc.FirstName = "George";
dc.LastName = "Washington";
ServiceProxy.HelloWorld2(dc);
}
// This is the callback function that
// processes the Web Service return value.
function SucceededCallback(result, userContext, methodName)
{
var RsltElem = document.getElementById("Results");
RsltElem.innerHTML = result + " from " + methodName + ".";
}
if (typeof(Sys) !== "undefined") Sys.Application.notifyScriptLoaded();
Imports System
Imports System.Web
Imports System.Collections
Imports System.Collections.Generic
Imports System.Threading
Imports System.Xml
Imports System.Xml.Serialization
Imports System.Text
Imports System.IO
Imports System.Runtime.Serialization
Imports System.ServiceModel
Imports System.ServiceModel.Description
Imports System.ServiceModel.Dispatcher
Imports System.ServiceModel.Channels
Imports System.ServiceModel.Activation
' This a WCF service which consists of a contract,
' defined below as ISimpleService, and DataContractType,
' a class which implements that interface, see SimpleService,
' and configuration entries that specify behaviors associated with
' that implementation (see <system.serviceModel> in web.config)
Namespace Aspnet.Samples.SimpleService
<ServiceContract()> _
Public Interface ISimpleService
<OperationContract()> _
Function HelloWorld1(ByVal value1 As String) As String
<OperationContract()> _
Function HelloWorld2(ByVal dataContractValue1 _
As DataContractType) As String
End Interface 'ISimpleService
<ServiceBehavior(IncludeExceptionDetailInFaults:=True), _
AspNetCompatibilityRequirements(RequirementsMode:= _
AspNetCompatibilityRequirementsMode.Allowed)> _
Public Class SimpleService
Implements ISimpleService
Public Sub New()
End Sub 'New
Public Function HelloWorld1(ByVal value1 As String) As String _
Implements ISimpleService.HelloWorld1
Return "Hello " + value1
End Function 'HelloWorld1
Public Function HelloWorld2(ByVal dataContractValue1 _
As DataContractType) As String _
Implements ISimpleService.HelloWorld2
Return "Hello " + dataContractValue1.FirstName + " " + _
dataContractValue1.LastName
End Function 'HelloWorld2
End Class 'SimpleService
<DataContract()> _
Public Class DataContractType
Private _firstName As String
Private _lastName As String
<DataMember()> _
Public Property FirstName() As String
Get
Return _firstName
End Get
Set(ByVal value As String)
_firstName = value
End Set
End Property
<DataMember()> _
Public Property LastName() As String
Get
Return _lastName
End Get
Set(ByVal value As String)
_lastName = value
End Set
End Property
End Class 'DataContractType
End Namespace
using System;
using System.Web;
using System.Collections;
using System.Collections.Generic;
using System.Threading;
using System.Xml;
using System.Xml.Serialization;
using System.Text;
using System.IO;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.ServiceModel.Description;
using System.ServiceModel.Dispatcher;
using System.ServiceModel.Channels;
using System.ServiceModel.Activation;
// This a WCF service which consists of a contract,
// defined below as ISimpleService, and DataContractType,
// a class which implements that interface, see SimpleService,
// and configuration entries that specify behaviors associated with
// that implementation (see <system.serviceModel> in web.config)
namespace Aspnet.Samples
{
[ServiceContract()]
public interface ISimpleService
{
[OperationContract]
string HelloWorld1(string value1);
[OperationContract]
string HelloWorld2(DataContractType dataContractValue1);
}
[ServiceBehavior(IncludeExceptionDetailInFaults = true)]
[AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]
public class SimpleService : ISimpleService
{
public SimpleService()
{ }
public string HelloWorld1(string value1)
{
return "Hello " + value1;
}
public string HelloWorld2(DataContractType dataContractValue1)
{
return "Hello " + dataContractValue1.FirstName +
" " + dataContractValue1.LastName;
}
}
[DataContract]
public class DataContractType
{
string firstName;
string lastName;
[DataMember]
public string FirstName
{
get { return firstName; }
set { firstName = value; }
}
[DataMember]
public string LastName
{
get { return lastName; }
set { lastName = value; }
}
}
}
Exemples supplémentaires
Procédure pas à pas : création et utilisation d'un service Web compatible AJAX
Utilisation de l'authentification par formulaire avec ASP.NET AJAX
Retour au début
Référence de classe
Les tableaux suivants répertorient les classes principales associées aux services Web pouvant être appelés à partir d'un script client.
Espaces de noms clients
Nom |
Description |
|---|---|
Contient des classes qui gèrent la communication entre les applications clientes ASP.NET AJAX et les services Web sur le serveur. L'espace de noms Sys.Net fait partie de Microsoft AJAX Library. |
|
Contient des classes liées à la sérialisation des données pour les applications clientes ASP.NET AJAX. |
|
Contient des types qui fournissent, dans les applications clientes ASP.NET AJAX, un accès de script aux services d'authentification, de profil et à d'autres services d'application ASP.NET. L'espace de noms Sys.Services fait partie de Microsoft AJAX Library. |
Espaces de noms serveur
Nom |
Description |
|---|---|
Contient des classes qui fournissent une sérialisation et une désérialisation JSON (JavaScript Objet Notation) pour les types managés. Cet espace de noms fournit également des fonctionnalités d'extensibilité permettant de personnaliser le comportement de sérialisation. |
Retour au début
Ressources supplémentaires
À propos du code XMLHTTP natif
http://www.json.org/json-fr.html
Qu'est-ce que Windows Communication Foundation ?
Infrastructure des services Web XML
Fonctionnement de l'architecture de services
Nouveautés
Les fonctionnalités suivantes sont des nouveautés de la version 3.0 d'ASP.NET :
Services d'application dans Windows Communication Foundation (WCF).
Services d'application dans AJAX appelés à partir d'une application cliente .NET Framework.
Retour au début
Voir aussi
Tâches
Procédure pas à pas : création et utilisation d'un service Web compatible AJAX
Concepts
Utilisation de l'authentification par formulaire avec ASP.NET AJAX