Partager via

Spécification du comportement du service Run-Time

Une fois que vous avez conçu un contrat de service (Conception de contrats de service) et implémenté votre contrat de service (implémentation de contrats de service), vous pouvez configurer le comportement d’opération du runtime de service. Cette rubrique décrit les comportements de service et d’opération fournis par le système et décrit où trouver plus d’informations pour créer de nouveaux comportements. Bien que certains comportements soient appliqués en tant qu’attributs, de nombreux sont appliqués à l’aide d’un fichier de configuration d’application ou par programmation. Pour plus d’informations sur la configuration de votre application de service, consultez Configuration des services.

Aperçu

Le contrat définit les entrées, sorties, types de données et fonctionnalités 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’il implémente. Les informations contractuelles, contraignantes et d’adresse sont toutes connues du client ; sans eux, le client ne peut pas utiliser le service.

Toutefois, les spécificités de l’opération, telles que les problèmes de threading ou la gestion des instances, sont opaques pour les 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 de comportements. Les comportements sont des objets qui modifient le runtime Windows Communication Foundation (WCF) en définissant une propriété 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 les plus largement utiles et exposent les fonctionnalités d’opération les plus couramment demandées. Étant donné qu’ils sont des attributs, vous les appliquez à l’implémentation du service ou de l’opération. D'autres comportements, tels que le System.ServiceModel.Description.ServiceMetadataBehavior ou System.ServiceModel.Description.ServiceDebugBehavior, sont généralement appliqués à l'aide d'un fichier de configuration d'application, même si vous pouvez les utiliser par programmation.

Cette rubrique fournit une vue d’ensemble des attributs ServiceBehaviorAttribute et OperationBehaviorAttribute, décrit les différentes étendues aux niveaux desquels les comportements peuvent opérer, et offre une description succincte de nombreux comportements fournis par le système, à divers niveaux d'étendues, susceptibles d’intéresser 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 des instances

  • Prise en charge multi-utilisateur et de synchronisation

  • Comportement de configuration

  • Comportement des transactions

  • Comportements de sérialisation

  • Transformation des métadonnées

  • Durée de vie de la session

  • Filtrage d’adresses et traitement d’en-tête

  • Usurpation d'identité

  • Pour utiliser ces attributs, marquez l’implémentation du service ou de l’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 nécessite une transaction 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 publié, et les propriétés OperationBehaviorAttribute.ReleaseInstanceMode et ServiceBehaviorAttribute.ReleaseServiceInstanceOnTransactionComplete contrôlent le moment où l'objet de service est libéré.

Toutefois, vous pouvez également créer un objet de service vous-même et créer l’hôte de service à l’aide de 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 ServiceHost(Object, Uri[]) constructeur pour créer un tel service. Il offre une alternative à l’implémentation d’une instance d’objet personnalisée System.ServiceModel.Dispatcher.IInstanceContextInitializer lorsque vous souhaitez fournir une instance d’objet spécifique à utiliser 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 fonctionnalités liées au comportement d’instanciation windows Communication Foundation (WCF) fonctionnent différemment. Par exemple, l’appel 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 ServiceHost classe se comporte toujours comme si la OperationBehaviorAttribute.ReleaseInstanceMode propriété est définie 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 définissez la ServiceBehaviorAttribute.ConcurrencyMode propriété sur ConcurrencyMode.Multiple vous devez gérer les problèmes de synchronisation de threads à l’intérieur de chaque opération de ce service vous-même. Les comportements de point de terminaison fonctionnent sur un point de terminaison ; la plupart 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 manière dont les opérations sont réalisées.

La plupart de ces comportements sont implémentés sur des attributs, et vous les utilisez comme vous le faites avec les attributs ServiceBehaviorAttribute et OperationBehaviorAttribute, en les appliquant à la classe de service ou à l’implémentation de l’opération appropriée. D'autres comportements, tels que les objets ServiceMetadataBehavior ou ServiceDebugBehavior, sont généralement appliqués à l'aide d'un fichier de configuration d'application, bien qu'ils puissent également être utilisés de manière programmatique.

Par exemple, la publication des métadonnées est configurée à l’aide de l’objet ServiceMetadataBehavior . Le fichier de configuration d’application suivant affiche 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 de nombreux comportements fournis par le système, parmi les plus utiles, que vous pourrez utiliser pour modifier l'exécution de votre service ou de votre client. Consultez la rubrique de référence pour déterminer comment utiliser chacune d’elles.

Comportements de service

Les comportements suivants fonctionnent sur les services.

  • AspNetCompatibilityRequirementsAttribute. Appliqué à un service WCF pour indiquer si ce service peut être exécuté en mode de compatibilité ASP.NET.

  • ServiceAuthorizationBehavior. Contrôle la façon dont le service autorise les revendications du client.

  • ServiceCredentials. Configure les informations d'identification d'un service. Utilisez cette classe pour spécifier les informations d’identification du service, telles qu’un certificat X.509.

  • ServiceDebugBehavior. Active le débogage et les fonctionnalités d’informations d’aide pour un service WCF.

  • ServiceMetadataBehavior. Contrôle la publication des métadonnées de service et les informations associées.

  • ServiceSecurityAuditBehavior. Spécifie le comportement d’audit des événements de sécurité.

  • ServiceThrottlingBehavior. Configure les paramètres de débit d’exécution qui vous permettent d’optimiser les performances du service.

Comportements de point de terminaison

Les comportements suivants s'appliquent aux points de terminaison. La plupart 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 du client et du service, ainsi que les paramètres d’authentification des informations d’identification du 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 au runtime 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 contractuels

DeliveryRequirementsAttribute. Spécifie les exigences de fonctionnalité que les liaisons doivent fournir à l’implémentation du service ou du client.

Comportements des opérations

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

Voir aussi

  • Last updated on