WCF - Consommation du service WCF

Les services WCF permettent à d'autres applications d'y accéder ou de les utiliser. Un service WCF peut être utilisé de plusieurs manières selon le type d'hébergement. Ici, nous expliquons la méthode étape par étape pour consommer un service WCF pour chacune des options d'hébergement populaires suivantes -

Consommation du service WCF hébergé dans IIS 5/6
Consommer un service WCF auto-hébergé
Consommation du service WCF hébergé dans le service d'activation Windows
Consommation du service WCF hébergé dans le service Windows

Consommation du service WCF hébergé dans IIS 5/6

Le processus de consommation d'un service WCF hébergé dans IIS 5/6 est décrit en détail ci-dessous. En outre, la discussion comprend comment créer des applications proxy et console.

Step 1- Une fois qu'un service est hébergé dans IIS, nous devons le consommer dans les applications clientes. Avant de créer l'application client, nous devons créer un proxy pour le service. Ce proxy est utilisé par l'application cliente pour interagir avec le service. Pour créer un proxy, exécutez l'invite de commandes Visual Studio 2008. À l'aide de l'utilitaire de service, nous pouvons créer la classe proxy et ses informations de configuration.

svcutilhttp: //localhost/IISHostedService/Service.svc

Après avoir exécuté cette commande, nous obtiendrons deux fichiers générés à l'emplacement par défaut.

MyService.cs - Classe proxy pour le service WCF
output.config - Informations de configuration sur le service

Step 2 - Nous allons maintenant commencer à créer l'application Console à l'aide de Visual Studio 2008 (application client).

Step 3- Ajoutez la référence 'System.ServiceModel'; il s'agit de la DLL principale de WCF.

Step 4 - Créez une classe Proxy.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace MyServiceClient {
   Class Program {
      Static void Main(string[] args) {
         // Creating Proxy for the MyService
         ServiceClient Client = newServiceClient();
         Console.WriteLine("Client calling the service...");
         Console.WriteLine("Hello Ram");
         Console.Read();
      }
   }
}

La sortie apparaît comme suit -

Consommation du service WCF auto-hébergé

Ici, l'ensemble du processus de consommation d'un service WCF auto-hébergé est expliqué étape par étape, ainsi que de nombreux codages et captures d'écran si nécessaire.

Step 1- Le service est hébergé, nous devons maintenant implémenter la classe proxy pour le client. Il existe différentes manières de créer le proxy.

En utilisant SvcUtil.exe, nous pouvons créer la classe proxy et son fichier de configuration avec des points de terminaison.
Ajout d'une référence de service à l'application cliente.
Implémentation de la classe ClientBase <T>

Parmi ces trois méthodes, la mise en œuvre de ClientBase <T> est la meilleure pratique. Si vous utilisez les deux autres méthodes, nous devons créer une classe proxy chaque fois que nous apportons des modifications à l'implémentation du service. Mais ce n'est pas le cas pour ClientBase <T>. Il ne créera le proxy qu'au moment de l'exécution et s'occupera donc de tout.

À cette fin, créez une classe proxy, qui inclut les références de System.ServiceModel et MyCalculatorService.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel;
using MyCalculatorService;

namespace MyCalculatorServiceProxy {
   // WCF create proxy for ISimpleCalculator using ClientBase
   Public class MyCalculatorServiceProxy : 
   ClientBase<ISimpleCalculator>,
   
   ISimpleCalculator {
      Public int Add(int num1, int num2) {
         //Call base to do funtion
         returnbase.Channel.Add(num1, num2);
      }
   }
}

Maintenant, créez une application console, qui inclut les références de System.ServiceModel et MyCalculatorServiceProxy.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel;
using MyCalculatorServiceProxy;

namespace MyCalculatorServiceClient {
   classProgram {
      Static void Main(string[] args) {
         MyCalculatorServiceProxy.MyCalculatorServiceProxy proxy = newMyCalculatorServiceProxy.MyCalculatorServiceProxy();
         
         Console.WriteLine("Client is running at " + DateTime.Now.ToString());
         Console.WriteLine("Sum of two numbers. 5 + 5 =" + proxy.Add(5,5));
         Console.ReadLine();
      }
   }
}

Step 2 - Les informations de point final (identiques à celles du service) doivent être ajoutées au fichier de configuration de l'application cliente.

<?xmlversion = "1.0"encoding = "utf-8" ?>
<configuration>
   <system.serviceModel>
      <client>
         <endpoint address 
            ="http://localhost:8090/MyCalculatorServiceProxy/ISimpleCalculator"
            binding = "wsHttpBinding" contract "MyCalculatorServiceProxy.ISimpleCalculator">
            </endpoint>
      </client>
   </system.serviceModel>
</configuration>

Step 3- Avant d'exécuter l'application client, vous devez exécuter le service. Ci-dessous, la sortie de l'application cliente.

Consommation du service WCF hébergé dans WAS

La consommation d'un service WCF hébergé dans WAS est un processus simple impliquant seulement quelques étapes. Les étapes sont les suivantes -

Ajoutez la classe proxy et le fichier de configuration à l'application cliente.
Créez l'objet pour MathServiceClient et appelez la méthode.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespaceWASHostedClient {
   classProgram {
      staticvoid Main(string[] args) {
         MathServiceClient client = newMathServiceClient();
         Console.WriteLine("Sum of two number 5,6");
         Console.WriteLine(client.Add(5, 6));
         Console.ReadLine();
      }
   }
}

La sortie apparaît comme indiqué ci-dessous.

Consommation du service WCF hébergé dans le service Windows

Le processus étape par étape de la consommation d'un service WCF hébergé dans le service Windows est décrit ci-dessous en détail avec un codage et des instructions.

Une fois qu'il est hébergé avec succès, nous pouvons créer une classe proxy pour le service et commencer à l'utiliser dans l'application cliente. Ici, il est affiché avec le type d'hébergement IIS consommant.

Ajoutez la référence de ServiceModel.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespaceWindowServiceClient {
   classProgram {
      staticvoid Main(string[] args) {
         //Creating Proxy for the MyService
         MyServiceClient client = newMyServiceClient();
         Console.WriteLine("Client calling the service...");
         Console.WriteLine("Sum of two numbers 5,6");
         Console.WriteLine(client.Add(5, 6));
        
         Console.WriteLine("Subtraction of two numbers 6,5");
         Console.WriteLine(client.Sub(6, 5));
        
         Console.WriteLine("Multiplication of two numbers 6,5");
         Console.WriteLine(client.Mul(6, 5));
        
         Console.WriteLine("Division of two numbers 6,3");
         Console.WriteLine(client.Div(6, 3));
         Console.Read();
      }
   }
}

La sortie apparaît comme suit -