Partager via

Spécification du comportement du service au moment de l'exécution

  • Article

Une fois que vous avez conçu un contrat de service (Designing Service Contracts) et implémenté votre contrat de service (Implementing Service Contracts), vous pouvez configurer le comportement d’opération de l’exécution du service. Cette rubrique traite des comportements de service fournis par le système et des comportements d'opération et précise où rechercher plus d'informations pour créer de nouveaux comportements. Si certains comportements sont appliqués sous la forme d'attributs, un grand nombre s'appliquent à l'aide d'un fichier de configuration de l'application ou par programme. Pour plus d’informations sur la configuration de votre application de service, consultez Configuration des services.

Vue d’ensemble

Le contrat définit les entrées, sorties, types de données et fonctions d'un service de ce type. L'implémentation d'un contrat de service crée une classe qui, lorsqu'elle est configurée avec une liaison à une adresse, répond au contrat qu'elle implémente. Les informations contractuelles, de liaisons et d'adresse sont tout connues du client ; sans elles, le client ne peut pas utiliser le service.

Toutefois, les caractéristiques d'opération, telles que les problèmes de thread ou la gestion d'instance, sont opaques aux clients. Une fois que vous avez implémenté votre contrat de service, vous pouvez configurer un grand nombre de caractéristiques d'opération à l'aide des comportements. Les comportements sont des objets qui modifient le runtime Windows Communication Foundation (WCF) en définissant une propriété de runtime ou en insérant un type de personnalisation dans le runtime. Pour plus d’informations sur la modification du runtime en créant des comportements définis par l’utilisateur, consultez Extension de ServiceHost et de la couche de modèle de service.

Les attributs System.ServiceModel.ServiceBehaviorAttribute et System.ServiceModel.OperationBehaviorAttribute sont les comportements le plus largement utiles et qui exposent les fonctionnalités d'opération les plus couramment demandées. Comme ce sont des attributs, vous les appliquez à l'implémentation de service ou d'opération. Les autres comportements, tels que System.ServiceModel.Description.ServiceMetadataBehavior ou System.ServiceModel.Description.ServiceDebugBehavior, sont appliqués en général à l'aide d'un fichier de configuration de l'application, bien que vous puissiez les utiliser par programme.

Cette rubrique fournit une vue d’ensemble des attributs ServiceBehaviorAttribute et OperationBehaviorAttribute, décrit les différentes étendues au niveau desquelles les comportements peuvent fonctionner, et fournit une description rapide d’un grand nombre des comportements fournis par le système aux diverses étendues qui peuvent présenter un intérêt pour les développeurs WCF.

ServiceBehaviorAttribute et OperationBehaviorAttribute

Les comportements les plus importants sont les attributs ServiceBehaviorAttribute et OperationBehaviorAttribute que vous pouvez utiliser pour contrôler :

  • Durées de vie d'instance

  • Prise en charge multi-utilisateur et de synchronisation

  • Comportement de configuration

  • Comportement de transaction

  • Comportements de sérialisation

  • Transformation de métadonnées

  • Durée de vie de session

  • Filtrage d'adresse et traitement d'en-tête

  • Emprunt d'identité

  • Pour utiliser ces attributs, marquez l'implémentation de service ou d'opération avec l'attribut approprié à cette étendue et définissez les propriétés. Par exemple, l'exemple de code suivant affiche une implémentation d'opération qui utilise la propriété OperationBehaviorAttribute.Impersonation pour exiger que les appelants de cette opération prennent en charge l'emprunt d'identité.

using System;
using System.Collections.Generic;
using System.ServiceModel;
using System.Threading;

namespace Microsoft.WCF.Documentation
{
  [ServiceContract(
    Name="SampleHello",
    Namespace="http://microsoft.wcf.documentation"
  )]
  public interface IHello
  {
    [OperationContract]
    string Hello(string greeting);
  }

  public class HelloService : IHello
  {

    public HelloService()
    {
      Console.WriteLine("Service object created: " + this.GetHashCode().ToString());
    }

    ~HelloService()
    {
      Console.WriteLine("Service object destroyed: " + this.GetHashCode().ToString());
    }

    [OperationBehavior(Impersonation=ImpersonationOption.Required)]
    public string Hello(string greeting)
    {
      Console.WriteLine("Called by: " + Thread.CurrentPrincipal.Identity.Name);
      Console.WriteLine("IsAuthenticated: " + Thread.CurrentPrincipal.Identity.IsAuthenticated.ToString());
      Console.WriteLine("AuthenticationType: " + Thread.CurrentPrincipal.Identity.AuthenticationType.ToString());

      Console.WriteLine("Caller sent: " + greeting);
      Console.WriteLine("Sending back: Hi, " + Thread.CurrentPrincipal.Identity.Name);
      return "Hi, " + Thread.CurrentPrincipal.Identity.Name;
    }
  }
}

Imports System.ServiceModel
Imports System.Threading

Namespace Microsoft.WCF.Documentation
    <ServiceContract(Name:="SampleHello", Namespace:="http://microsoft.wcf.documentation")> _
    Public Interface IHello
        <OperationContract> _
        Function Hello(ByVal greeting As String) As String
    End Interface

    Public Class HelloService
        Implements IHello

        Public Sub New()
            Console.WriteLine("Service object created: " & Me.GetHashCode().ToString())
        End Sub

        Protected Overrides Sub Finalize()
            Console.WriteLine("Service object destroyed: " & Me.GetHashCode().ToString())
        End Sub

        <OperationBehavior(Impersonation:=ImpersonationOption.Required)> _
        Public Function Hello(ByVal greeting As String) As String Implements IHello.Hello
            Console.WriteLine("Called by: " & Thread.CurrentPrincipal.Identity.Name)
            Console.WriteLine("IsAuthenticated: " & Thread.CurrentPrincipal.Identity.IsAuthenticated.ToString())
            Console.WriteLine("AuthenticationType: " & Thread.CurrentPrincipal.Identity.AuthenticationType.ToString())

            Console.WriteLine("Caller sent: " & greeting)
            Console.WriteLine("Sending back: Hi, " & Thread.CurrentPrincipal.Identity.Name)
            Return "Hi, " & Thread.CurrentPrincipal.Identity.Name
        End Function
    End Class
End Namespace

Un grand nombre des propriétés exigent la prise en charge supplémentaire à partir de la liaison. Par exemple, une opération qui requiert une transaction à partir du client doit être configurée pour utiliser une liaison qui prend en charge les transactions transmises.

Services singleton connus

Vous pouvez utiliser les attributs ServiceBehaviorAttribute et OperationBehaviorAttribute pour contrôler certaines durées de vie, les deux InstanceContext et des objets de service qui implémentent les opérations.

Par exemple, la propriété ServiceBehaviorAttribute.InstanceContextMode contrôle la fréquence à laquelle InstanceContext est diffusé, et les propriétés OperationBehaviorAttribute.ReleaseInstanceMode et ServiceBehaviorAttribute.ReleaseServiceInstanceOnTransactionComplete contrôlent le moment auquel l'objet de service est diffusé.

Toutefois, vous pouvez également créer un objet de service vous-même et créer l'hôte de service utilisant cet objet. Pour ce faire, vous devez également affecter ServiceBehaviorAttribute.InstanceContextMode à la propriété Single , sans quoi une exception est levée lorsque l'hôte de service est ouvert.

Utilisez le constructeur ServiceHost(Object, Uri[]) pour créer un service de ce type. Il fournit une alternative à l'implémentation d'un System.ServiceModel.Dispatcher.IInstanceContextInitializer personnalisé lorsque vous souhaitez fournir une instance d'objet spécifique qui sera utilisée par un service singleton. Vous pouvez utiliser cette surcharge lorsque votre type d’implémentation de service est difficile à construire (par exemple, s’il n’implémente pas de constructeur public sans paramètre).

Notez que lorsqu’un objet est fourni à ce constructeur, certaines des fonctionnalités associées au comportement d’instanciation Windows Communication Foundation (WCF) fonctionnent différemment. Par exemple, l'appel de InstanceContext.ReleaseServiceInstance n'a aucun effet lorsqu'une instance d'objet connue est fournie. De même, tout autre mécanisme de libération d'instance est ignoré. La classe ServiceHost se comporte toujours comme si la propriété OperationBehaviorAttribute.ReleaseInstanceMode avait la valeur ReleaseInstanceMode.None pour toutes les opérations.

Autres comportements de service, de point de terminaison, de contrat et d'opération

Les comportements de service, tels que l'attribut ServiceBehaviorAttribute , fonctionnent sur l'ensemble d'un service. Par exemple, si vous affectez à la propriété ServiceBehaviorAttribute.ConcurrencyMode la valeur ConcurrencyMode.Multiple , vous devez gérer vous-même les problèmes de synchronisation de thread à l'intérieur de chaque opération dans ce service. Les comportements de point de terminaison fonctionnent sur un point de terminaison ; un grand nombre des comportements de point de terminaison fournis par le système sont destinés aux fonctionnalités clientes. Les comportements de contrat fonctionnent au niveau du contrat, et les comportements d'opération modifient la remise d'opération.

Un grand nombre de ces comportements sont implémentés sur les attributs, et sont utilisés comme les attributs ServiceBehaviorAttribute et OperationBehaviorAttribute , en les appliquant à l'implémentation d'opération ou de classe de service appropriée. Les autres comportements, tels que les objets ServiceMetadataBehavior ou ServiceDebugBehavior , sont appliqués en général à l'aide d'un fichier de configuration de l'application, bien que vous puissiez les utiliser par programme.

Par exemple, la publication de métadonnées est configurée en utilisant l'objet ServiceMetadataBehavior . Le fichier de configuration de l'application suivant illustre l'utilisation la plus courante.

<configuration>
  <system.serviceModel>
    <services>
      <service 
        name="Microsoft.WCF.Documentation.SampleService"
        behaviorConfiguration="metadataSupport"
      >
        <host>
          <baseAddresses>
            <add baseAddress="http://localhost:8080/SampleService" />
          </baseAddresses>
        </host>
        <endpoint
          address=""
          binding="wsHttpBinding"
          contract="Microsoft.WCF.Documentation.ISampleService"
        />
        <!-- Adds a WS-MetadataExchange endpoint at -->
        <!-- "http://localhost:8080/SampleService/mex" -->
        <endpoint
           address="mex"
           binding="mexHttpBinding"
           contract="IMetadataExchange"
        />
      </service>
    </services>
    <behaviors>
      <serviceBehaviors>
      <behavior name="metadataSupport">
        <!-- Enables the IMetadataExchange endpoint in services that -->
        <!-- use "metadataSupport" in their behaviorConfiguration attribute. -->
        <!-- In addition, the httpGetEnabled and httpGetUrl attributes publish -->
        <!-- Service metadata for retrieval by HTTP/GET at the address -->
        <!-- "http://localhost:8080/SampleService?wsdl" -->
        <serviceMetadata httpGetEnabled="true" httpGetUrl=""/>
      </behavior>
    </serviceBehaviors>
  </behaviors>
  </system.serviceModel>
</configuration>

Les sections suivantes décrivent un grand nombre des comportements les plus utiles fournis par le système que vous pouvez utiliser pour modifier la remise d'exécution de votre service ou client. Consultez la rubrique de référence pour déterminer comment utiliser chacun d'entre eux.

Comportements de service

Les comportements suivants fonctionnent sur les services.

Comportements de point de terminaison

Les comportements suivants fonctionnent sur des points de terminaison. Un grand nombre de ces comportements sont utilisés dans les applications clientes.

  • CallbackBehaviorAttribute. Configure une implémentation de service de rappel dans une application cliente duplex.

  • CallbackDebugBehavior. Active le débogage de service pour un objet de rappel WCF.

  • ClientCredentials. Permet à l'utilisateur de configurer les informations d'identification de service et de client ainsi que paramètres d'authentification des informations d'identification de service à utiliser sur le client.

  • ClientViaBehavior. Utilisé par les clients pour spécifier l'URI (Uniform Resource Identifier) pour lequel le canal de transport doit être créé.

  • MustUnderstandBehavior. Indique à WCF de désactiver le traitement MustUnderstand.

  • SynchronousReceiveBehavior. Indique à l'exécution d'utiliser un processus de réception synchrone pour les canaux.

  • TransactedBatchingBehavior. Optimise les opérations de réception pour les transports qui prennent en charge les réceptions transactionnelles.

Comportements de contrat

DeliveryRequirementsAttribute. Spécifie les fonctionnalités que les liaisons doivent fournir à l'implémentation de service ou de client.

Comportements d'opération

Les comportements d'opération suivants spécifient les contrôles de sérialisation et de transaction pour les opérations.

Voir aussi