WCF ChannelFactory vs génération de proxy

Je me demande dans quelles circonstances préférez-vous générer un proxy à partir d’un service WCF lorsque vous pouvez simplement appeler des appels à l’aide de ChannelFactory?

De cette façon, vous n’avez pas besoin de générer un proxy et de vous soucier de la régénération d’un proxy lorsque le serveur est mis à jour?

Merci

Il existe 3 méthodes de base pour créer un client WCF:

  1. Laissez Visual Studio générer votre proxy. Cette auto génère un code qui se connecte au service en lisant le WSDL. Si le service change pour une raison quelconque, vous devez le régénérer. Le gros avantage de ceci est qu’il est facile à configurer – VS a un assistant et tout est automatique. L’inconvénient est que vous comptez sur VS pour faire tout le travail pour vous et que vous perdez ainsi le contrôle.

  2. Utilisez ChannelFactory avec une interface connue. Cela dépend de vous avoir des interfaces locales qui décrivent le service (le contrat de service). Le gros avantage est que vous pouvez gérer le changement beaucoup plus facilement – vous devez toujours recomstackr et corriger les modifications, mais maintenant vous ne régénérez pas le code, vous faites référence aux nouvelles interfaces. Généralement, cela est utilisé lorsque vous contrôlez à la fois le serveur et le client, car les deux peuvent être beaucoup plus facilement simulés pour les tests unitaires. Cependant, les interfaces peuvent être écrites pour n’importe quel service, même ceux de REST – jetez un coup d’œil à cette API Twitter .

  3. Ecrivez votre propre proxy – cela est assez facile à faire, en particulier pour les services REST, en utilisant HttpClient ou WebClient . Cela vous donne le meilleur contrôle du grain, mais au prix de nombreuses API de service dans les chaînes. Par exemple: var content = new HttpClient().Get("http://yoursite.com/resource/id").Content; – Si les détails de l’API changent, vous ne rencontrerez aucune erreur avant l’exécution.

Personnellement, je n’ai jamais aimé l’option 1: compter sur le code généré automatiquement est compliqué et perd trop de contrôle. De plus, cela crée souvent des problèmes de sérialisation – je me retrouve avec deux classes identiques (une dans le code du serveur, une auto-générée) qui peut être corrigée mais qui est pénible.

L’option 2 devrait être parfaite, mais les canaux sont un peu trop ressortingctifs – par exemple, ils perdent complètement le contenu des erreurs HTTP . Cela dit, avoir des interfaces qui décrivent le service est beaucoup plus facile à coder et à maintenir.

J’utilise ChannelFactory avec la méthode MetadataResolver.Resolve. La configuration du client est un problème, alors je reçois mon ServiceEndpoint du serveur.

Lorsque vous utilisez ChannelFactory (Of T), T est le contrat d’origine que vous pouvez obtenir d’une référence dans votre projet ou d’une instance de contrat générée. Dans certains projets, j’ai généré le code à partir d’une référence de service car je ne pouvais pas append de référence à la DLL du contrat. Vous pouvez même générer un contrat asynchrone avec la référence de service et utiliser cette interface de contrat avec ChannelFactory.

Le principal intérêt de ChannelFactory était de me débarrasser des informations de configuration du client WCF. Dans l’exemple de code ci-dessous, vous pouvez voir comment obtenir un client WCF sans configuration.

 Dim fixedAddress = "net.tcp://server/service.svc/mex" Dim availableBindings = MetadataResolver.Resolve(GetType(ContractAssembly.IContractName), New EndpointAddress(fixedAddress)) factoryService = New ChannelFactory(Of ContractAssembly.IContractName)(availableBindings(0)) accesService = factoryService.CreateChannel() 

Dans mon projet final, les éléments availableBindings sont vérifiés pour utiliser net.tcp ou net.pipe s’ils sont disponibles. De cette façon, je peux utiliser la meilleure liaison disponible pour mes besoins. Je ne m’appuie que sur le fait qu’un point d’extrémité de métadonnées existe sur le serveur.

J’espère que ça aide

BTW, cela est fait en utilisant .NET 3.5. Cependant, cela fonctionne aussi avec 4.0.

Eh bien, pour pouvoir utiliser ChannelFactory vous devez être prêt à partager des assemblages de contrats entre le service et le client. Si cela vous convient, ChannelFactory peut vous faire gagner du temps.

Le proxy va créer des fonctions asynchrones, ce qui est plutôt sympa.

Ma réponse est une sorte de résumé des réponses de Keith et Andrew Hare .

Si vous ne contrôlez pas le serveur, mais que vous ne disposez que du proxy WSDL / URL-générer en utilisant Visual Studio ou svcutil. (Notez que Visual Studio a parfois échoué, lorsque svcutil fonctionne mieux).

Lorsque vous contrôlez le serveur et le client, partagez les interfaces / contrats et appelez ChannelFactory
.

Ce n’est pas juste une question de temps sauvé. L’utilisation du proxy WSDL généré est dangereuse car si vous oubliez de mettre à jour la référence de service, vous pouvez laisser la solution dans un état incohérent. Tout comstack mais le contrat de service est cassé. Je suggère définitivement d’utiliser un ChannelFactory autant que possible, vous rendre la vie beaucoup plus facile.

Une alternative possible pourrait consister à écrire un script de pré-construction qui appelle l’utilitaire SVCUtil pour créer le proxy à chaque fois que vous construisez votre projet, mais de toute façon, ChannelFactory est beaucoup plus soigné et élégant.