Exposition de services WCF au script client

Article
10/22/2014

Mise à jour : novembre 2007

Windows Communication Foundation (WCF) est le modèle de programmation unifié de Microsoft pour générer des applications orientées service. Il prend en charge ASP.NET AJAX et le format de données JSON (JavaScript Objet Notation). Ce modèle permet aux services WCF d'exposer des fonctionnalités dans des pages Web qui exécutent le code ECMAScript (Javascript) et qui peuvent par conséquent accéder à ces services en utilisant des requêtes HTTP.

Si vous avez déjà créé des services WCF, vous pouvez ajouter des points de terminaison pour permettre au script des pages Web AJAX d'accéder à ces services. Cette rubrique explique comment rendre un service WCF accessible par JavaScript, exécuté dans le navigateur.

Le .NET Framework crée automatiquement des classes proxy JavaScript pour les services WCF lors du chargement de la page puis télécharge le script de classe proxy sur le navigateur. Ces classes proxy sont dérivées de la classe Sys.Net.WebServiceProxy dans Microsoft AJAX Library.

Vous pouvez appeler une opération de service WCF en appelant la méthode correspondante de la classe proxy JavaScript. Pour plus d'informations, consultez Appel de services Web à partir du script client.

Génération d'un service WCF accessible à partir du script client

Pour rendre un service WCF accessible à partir d'un script client, celui-ci doit satisfaire aux spécifications suivantes :

Le service doit être hébergé par une application Web qui contient un fichier avec une extension .svc. Ce fichier contient une directive @ ServiceHost qui pointe vers le service WCF. L'exemple suivant illustre une directive @ ServiceHost.
```
<%@ ServiceHost Language=C# Service="Aspnet.Samples.SimpleService" CodeBehind="~/App_Code/SimpleService.cs"%> 
```
```
<%@ ServiceHost Language=VB Service="Aspnet.Samples.SimpleService" CodeBehind="~/App_Code/SimpleService.vb"%> 
```
Vous devez configurer l'application Web pour prendre en charge l'appel de services Web à partir du script. Pour plus d'informations, consultez Comment : configurer les services WCF dans ASP.NET AJAX.
Le service doit être une classe qui implémente une interface marquée avec ServiceContractAttribute. Les opérations de service individuelles (méthodes) à appeler à partir du script doivent être qualifiées avec l'attribut OperationContractAttribute.

L'exemple suivant illustre une classe qui implémente une interface marquée avec ServiceContractAttribute.

namespace Samples.Aspnet
{
    [ServiceContract(Namespace="MyServices.org")]
    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; }
        }
    }

Namespace Aspnet.Samples.SimpleService

    <ServiceContract(NameSpace="MyServices.org")> _
    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

Pour plus d'informations, consultez Création de services WCF pour ASP.NET AJAX (en anglais).

Utilisation d'un service WCF à partir d'un script client d'une page Web ASP.NET

Pour appeler un service WCF à partir d'un script client d'une page Web ASP.NET, ajoutez tout d'abord un contrôle ScriptManager à la page. Définissez ensuite de façon déclarative l'objet ServiceReference en ajoutant un élément enfant asp:ServiceReference au contrôle ScriptManager et en définissant son attribut path afin qu'il pointe vers le service WCF. L'exemple suivant illustre une référence de service.

<asp:ScriptManager ID="ScriptManager1" >
  <Services>
    <asp:ServiceReference 
      Path="http://<serverhost>/SimpleService.svc"/>
  </Services>
</asp:ScriptManager>

L'objet ServiceReference ne peut référencer qu'un seul service Web par domaine. Le chemin d'accès du service Web peut être relatif, relatif à l'application, relatif au domaine ou absolu. Pour les chemins d'accès absolus, vous devez vous assurer que le chemin d'accès est dans le même domaine.

Lorsqu'une page qui contient ce contrôle ScriptManager s'affiche, elle crée une classe proxy JavaScript pour le service WCF. La classe proxy possède des fonctions qui correspondent à chaque opération de service. La page contient également des classes proxy JavaScript qui correspondent aux types de données de serveur utilisés comme paramètres d'entrée ou valeurs de retour pour les méthodes de service Web. Cela vous permet d'écrire un script client qui initialise ces paramètres et de les passer à l'appel de méthode.

Voir aussi

Concepts

Utilisation de services Web dans ASP.NET AJAX

Appel de services Web à partir du script client

Autres ressources

Prise en charge du format JSON et d'autres formats de transfert de données

Comment : utiliser la configuration pour ajouter un point de terminaison AJAX ASP.NET

Création de services WCF pour ASP.NET AJAX

Comment : créer un service WCF compatible AJAX et un client ASP.NET qui accède à ce service