Architecture du client

Les applications utilisent des objets clients Windows Communication Foundation (WCF) pour appeler des opérations de service. Cette rubrique décrit les objets clients WCF, les canaux clients WCF et leurs relations avec l’architecture de canal sous-jacente. Pour obtenir une vue d’ensemble de base des objets clients WCF, consultez Vue d’ensemble du client WCF. Pour plus d’informations sur la couche de canal, consultez Extension de la couche canal.

Aperçu

Le runtime du modèle de service crée des clients WCF, qui sont composés des éléments suivants :

• Implémentation de client générée automatiquement d’un contrat de service, qui transforme les appels de votre code d’application en messages sortants et transforme les messages de réponse en paramètres de sortie et les valeurs de retour que votre application peut récupérer.

• Implémentation d’une interface de contrôle (System.ServiceModel.IClientChannel) qui regroupe différentes interfaces et fournit l’accès aux fonctionnalités de contrôle, notamment la possibilité de fermer la session cliente et de supprimer le canal.

• Canal client basé sur les paramètres de configuration spécifiés par la liaison utilisée.

Les applications peuvent créer de tels clients à la demande, via une System.ServiceModel.ChannelFactory ou en créant une instance d’une ClientBase<TChannel> classe dérivée telle qu’elle est générée par l’outil utilitaire de métadonnées ServiceModel (Svcutil.exe). Ces classes de client déjà construites encapsulent une implémentation de canal de client construite dynamiquement par un ChannelFactory et délèguent vers cette implémentation. Par conséquent, le canal client et la fabrique de canaux qui les produisent sont le point focal d’intérêt pour cette discussion.

Objets clients et canaux clients

L’interface de base des clients WCF est l’interface System.ServiceModel.IClientChannel , qui expose les fonctionnalités principales du client ainsi que les fonctionnalités d’objet de communication de base de System.ServiceModel.ICommunicationObject, la fonctionnalité de contexte et System.ServiceModel.IContextChannelle comportement extensible de System.ServiceModel.IExtensibleObject<T>.

Toutefois, l’interface IClientChannel ne définit pas de contrat de service lui-même. Ceux-ci sont déclarés par l’interface de contrat de service (généralement générées à partir de métadonnées de service à l’aide d’un outil tel que l’outil ServiceModel Metadata Utility (Svcutil.exe)). Les types de clients WCF étendent à la fois IClientChannel et l’interface de contrat de service cible pour permettre aux applications d’appeler des opérations directement et ont également accès aux fonctionnalités d’exécution côté client. La création d’un client WCF fournit des objets WCFSystem.ServiceModel.ChannelFactory avec les informations nécessaires pour créer un runtime qui peut se connecter et interagir avec le point de terminaison de service configuré.

Comme mentionné précédemment, les deux types de clients WCF doivent être configurés avant de pouvoir les utiliser. Les types clients WCF les plus simples sont des objets qui dérivent de ClientBase<TChannel> (ou de DuplexClientBase<TChannel> si le contrat de service est un contrat duplex). Vous pouvez créer ces types à l’aide d’un constructeur, configuré par programme ou à l’aide d’un fichier de configuration, puis appelé directement pour appeler des opérations de service. Pour obtenir une vue d’ensemble de base des objets, consultez ClientBase<TChannel> du client WCF.

Le deuxième type est généré au moment de l’exécution à partir d’un appel à la CreateChannel méthode. Les applications concernées par un contrôle étroit des spécificités de communication utilisent généralement ce type de client, appelé objet de canal client, car elle permet une interaction plus directe que le runtime client et le système de canal sous-jacents.

Fabriques de canaux

La classe chargée de créer le runtime sous-jacent qui prend en charge les appels clients est la System.ServiceModel.ChannelFactory<TChannel> classe. Les objets clients WCF et les objets de canal client WCF utilisent un objet ChannelFactory<TChannel> pour créer des instances ; l’objet client dérivé ClientBase<TChannel> encapsule la gestion de la fabrique de canaux, mais pour un certain nombre de scénarios, il est parfaitement raisonnable d’utiliser directement la fabrique de canal. Le scénario courant est que vous souhaitez créer plusieurs fois de nouveaux canaux clients à partir d’une fabrique existante. Si vous utilisez un objet client, vous pouvez obtenir la fabrique de canaux sous-jacente d’un objet client WCF en appelant la propriété ClientBase<TChannel>.ChannelFactory.

Concernant les fabrications de canaux, il est important de garder à l'esprit qu'elles créent des nouvelles instances de canaux de client pour la configuration fournie avant l'appel de la méthode ChannelFactory<TChannel>.CreateChannel. Après avoir appelé CreateChannel (ou ClientBase<TChannel>.Open, ClientBase<TChannel>.CreateChannel ou toute opération sur un objet client WCF), vous ne pouvez plus modifier la fabrique de canaux et espérer obtenir des canaux vers des instances de service différentes, même si vous modifiez simplement l’adresse de point de terminaison cible. Si vous souhaitez créer un objet client ou un canal client avec une autre configuration, vous devez d’abord créer une fabrique de canaux.

Pour plus d’informations sur les différents problèmes liés à l’utilisation d’objets clients WCF et de canaux clients WCF, consultez Accès aux services à l’aide d’un client WCF.

Les deux sections suivantes décrivent la création et l’utilisation d’objets de canal client WCF.

Création d’un objet de canal client WCF

Pour illustrer l’utilisation d’un canal client, supposons que le contrat de service suivant a été généré.

[System.ServiceModel.ServiceContractAttribute(
  Namespace = "http://microsoft.wcf.documentation"
)]
public interface ISampleService
{
    [System.ServiceModel.OperationContractAttribute(
      Action = "http://microsoft.wcf.documentation/ISampleService/SampleMethod",
      ReplyAction = "http://microsoft.wcf.documentation/ISampleService/SampleMethodResponse"
    )]
    [System.ServiceModel.FaultContractAttribute(
      typeof(microsoft.wcf.documentation.SampleFault),
      Action = "http://microsoft.wcf.documentation/ISampleService/SampleMethodSampleFaultFault"
    )]
    string SampleMethod(string msg);
}

Pour vous connecter à un service ISampleService, utilisez l'interface de contrat générée directement avec une fabrication de canal (ChannelFactory<TChannel>). Une fois que vous avez créé et configuré une fabrication de canaux pour un contrat particulier, vous pouvez appeler la méthode CreateChannel pour obtenir des objets de canal client que vous pouvez utiliser pour communiquer avec un service ISampleService.

Lorsque vous utilisez la ChannelFactory<TChannel> classe avec une interface de contrat de service, vous devez effectuer un cast vers l’interface IClientChannel pour ouvrir, fermer ou abandonner explicitement le canal. Pour faciliter son utilisation, l'outil Svcutil.exe génère également une interface d'assistance qui implémente à la fois l'interface de contrat de service et IClientChannel afin de vous permettre d'interagir avec l'infrastructure de canal client sans devoir convertir de type. Le code suivant montre la définition d’un canal client d’assistance qui implémente le contrat de service précédent.

[System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "3.0.0.0")]
public interface ISampleServiceChannel : ISampleService, System.ServiceModel.IClientChannel
{
}

Création d’un objet de canal client WCF

Pour utiliser un canal client et se connecter à un service ISampleService, utilisez directement l’interface de contrat générée (ou la version d’assistance) avec une fabrication de canal, en passant le type de l’interface de contrat comme paramètre de type. Après avoir créé et configuré une fabrication de canal pour un contrat particulier, vous pouvez appeler la méthode ChannelFactory<TChannel>.CreateChannel pour retourner des objets de canal client qui vous permettront de communiquer avec un service ISampleService.

Lors de la création, les objets de canal client implémentent IClientChannel et l’interface de contrat. Par conséquent, vous pouvez les utiliser directement pour appeler des opérations qui interagissent avec un service qui prend en charge ce contrat.

La différence entre l’utilisation d’objets clients et d’objets de canal client est simplement une question de contrôle et de facilité d’utilisation pour les développeurs. De nombreux développeurs qui sont à l’aise avec les classes et les objets préfèrent utiliser l’objet client WCF au lieu du canal client WCF.

Pour obtenir un exemple, consultez Guide pratique pour utiliser ChannelFactory.