Architecture du client

  • Article

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

Vue d’ensemble

L’exécution de modèle de service crée des clients WCF qui se composent 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, les messages de réponse en paramètres de sortie et retourne des valeurs pouvant être récupérées par votre application.

  • Implémentation d'une interface de contrôle (System.ServiceModel.IClientChannel) qui regroupe différentes interfaces et fournit l'accès au contrôle des fonctionnalités, plus précisément aux fonctionnalités permettant de fermer la session client et de déployer le canal.

  • Canal de client construit en fonction des 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 classe dérivée ClientBase<TChannel>, car celle-ci est générée par l’outil Service Model Metadata Utility (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, cette rubrique traite principalement des canaux de client et de la fabrication de canal à leur origine.

Objets et canaux de client

L’interface de base des clients WCF correspond à l’interface System.ServiceModel.IClientChannel qui expose la fonctionnalité principale de client, la fonctionnalité d’objet de communication de base de System.ServiceModel.ICommunicationObject, la fonctionnalité de contexte de System.ServiceModel.IContextChannel et le comportement extensible de System.ServiceModel.IExtensibleObject<T>.

Toutefois, l'interface IClientChannel ne définit pas de contrat de service. Ces contrats sont déclarés par l’interface de contrat de service (ordinairement générée à partir de métadonnées de service à l’aide d’un outil tel que l’outil Service Model Metadata Utility (Svcutil.exe)). Les types de clients WCF étendent IClientChannel et l’interface cible du contrat de service pour permettre aux applications d’appeler des opérations directement et d’avoir également accès à la fonctionnalité runtime côté client. La création d’un client WCF fournit aux objets WCF System.ServiceModel.ChannelFactory les informations nécessaires pour créer un runtime pouvant se connecter au point de terminaison de service configuré et interagir avec celui-ci.

Comme mentionné précédemment, les deux types de clients WCF doivent être configurés pour pouvoir être utilisés. Le type de client WCF le plus simple correspond à un ensemble d’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 en utilisant un constructeur (ou un fichier de configuration) configuré par un programme, puis appelé directement pour appeler les opérations de service. Pour obtenir une vue d’ensemble de base des objets ClientBase<TChannel>, consultez Vue d’ensemble d’un client WCF.

Le second type est généré pendant l'exécution depuis un appel de la méthode CreateChannel. Les applications pour lesquelles le contrôle strict des spécifications de communication est important utilisent généralement ce type de client, appelé objet canal client, parce qu’il leur permet d’avoir une interaction plus directe que le système sous-jacent de runtime et de canal client.

Fabrication de canal

La classe qui est chargée de créer le processus d'exécution sous-jacent prenant en charge les appels de client correspond à System.ServiceModel.ChannelFactory<TChannel>. Les objets et canaux clients 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, dans certaines situations, il est parfaitement judicieux d’utiliser directement la fabrique de canaux. Vous souhaiterez le plus souvent créer à plusieurs reprises de nouveaux canaux de client à partir de la fabrication de canal 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 de client ou un canal de client avec une configuration différente, vous devez d'abord créer une nouvelle fabrication de canal.

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

Les deux sections suivantes contiennent des instructions permettant de créer et d’utiliser des objets canaux clients WCF.

Création d'un nouvel objet de canal de client WCF

Dans notre exemple illustrant l'utilisation d'un canal de client, nous 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>). Après avoir créé et configuré une fabrication de canal pour un contrat particulier, vous pouvez appeler la méthode CreateChannel pour retourner des objets de canal de client qui vous permettront de communiquer avec un service ISampleService.

Lorsque vous utilisez la classe ChannelFactory<TChannel> avec une interface de contrat de service, vous devez effectuer une conversion de type dans l'interface IClientChannel pour ouvrir, fermer ou abandonner le canal de manière explicite. 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 illustre 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 nouvel objet de canal de 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.

Une fois créés, les objets de canal de client implémentent IClientChannel ainsi que l'interface de contrat. Par conséquent, vous pouvez les utiliser directement pour appeler les opérations qui interagissent avec un service prenant en charge le contrat.

La différence entre les objets de client et les objets de canal de client réside dans leurs modalités de contrôle et leur simplicité d'utilisation. De nombreux développeurs habitués à travailler avec des classes et des objets préfèrent utiliser l’objet client WCF plutôt que le canal client WCF.

Pour obtenir un exemple, consultez Comment : Utiliser la classe ChannelFactory.