Comment : héberger un service WCF dans WAS

Article
02/27/2011

Cette rubrique décrit les étapes de base requises pour créer un service Windows Communication Foundation (WCF) hébergé dans le service d'activation des processus de Windows (également appelé WAS). WAS est le nouveau service d'activation de processus généralisant les fonctionnalités des services IIS (Internet Information Services) qui fonctionnent avec des protocoles de transport non-HTTP. WCF utilise l'interface de l'adaptateur d'écouteur pour communiquer les demandes d'activation reçues sur les protocoles non-HTTP pris en charge par WCF, tels que TCP, les canaux nommés et Message Queuing.

Cette option d'hébergement requiert que les composants d'activation WAS soient installés et configurés correctement, mais ne requiert pas l'écriture du code d'hébergement dans le cadre de l'application. Pour plus d'informations sur le sujet suivant l'installation et la configuration de WAS, consultez Comment : installer et configurer des composants d'activation WCF.

Attention :
L'activation de WAS n'est pas prise en charge si le pipeline de traitement de demande du serveur Web est en mode classique. Le pipeline de traitement de demande du serveur Web doit être en mode intégré si l'activation de WAS doit être utilisée.

Lorsqu'un service WCF est hébergé dans WAS, les liaisons standard sont utilisées de la façon habituelle. Toutefois, lors de l'utilisation de NetTcpBinding et de NetNamedPipeBinding pour configurer un service hébergé WAS, une contrainte doit être satisfaite. Lorsque des points de terminaison différents utilisent le même transport, les paramètres de liaison doivent correspondre dans les sept propriétés suivantes :

ConnectionBufferSize
ChannelInitializationTimeout
MaxPendingConnections
MaxOutputDelay
MaxPendingAccepts
ConnectionPoolSettings.IdleTimeout
ConnectionPoolSettings.MaxOutboundConnectionsPerEndpoint

Sinon, le point de terminaison initialisé en premier détermine toujours les valeurs de ces propriétés et les points de terminaison ajoutés ultérieurement lèvent un ServiceActivationException s'ils ne correspondent pas à ces paramètres.

Pour la copie source de cet exemple, consultez TCP Activation.

Pour créer un service de base hébergé par WAS

Définissez un contrat de service pour le type de service.

[ServiceContract]
public interface ICalculator
{
   [OperationContract]
   double Add(double n1, double n2);
   [OperationContract]
   double Subtract(double n1, double n2);
   [OperationContract]
   double Multiply(double n1, double n2);
   [OperationContract]
   double Divide(double n1, double n2);
}

Implémentez le contrat de service dans une classe de service. Notez que l'adresse ou les informations de liaison ne sont pas spécifiées dans l'implémentation du service. Par ailleurs, il n'est pas nécessaire d'écrire du code pour récupérer ces informations à partir du fichier de configuration.

public class CalculatorService : ICalculator
{
   public double Add(double n1, double n2)
   {
      return n1 + n2;
   }
   public double Subtract(double n1, double n2)
   {
      return n1 - n2;
   }
   public double Multiply(double n1, double n2)
   {
      return n1 * n2;
   }
   public double Divide(double n1, double n2)
   {
      return n1 / n2;
   }
}

Créez un fichier Web.config pour définir la liaison NetTcpBinding à utiliser par les points de terminaison CalculatorService.

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.serviceModel>
    <bindings>
      <netTcpBinding>
        <binding portSharingEnabled="true">
          <security mode="None" />
        </binding>
      </netTcpBinding>
    </bindings>
  </system.serviceModel>
</configuration>

Créez un fichier Service.svc contenant le code suivant.

<%@ServiceHost language=c# Service="CalculatorService" %>

Placez le fichier Service.svc dans votre répertoire virtuel IIS.

Pour créer un client qui utilise le service

Utilisez Outil Service Model Metadata Tool (Svcutil.exe) à partir de la ligne de commande pour générer le code à partir des métadonnées du service.
```
Svcutil.exe <service's Metadata Exchange (MEX) address or HTTP GET address> 
```

Le client généré contient l'interface ICalculator qui définit le contrat de service auquel l'implémentation du client doit satisfaire.

//Generated interface defining the ICalculator contract    
[System.ServiceModel.ServiceContractAttribute(
Namespace="http://Microsoft.ServiceModel.Samples", ConfigurationName="Microsoft.ServiceModel.Samples.ICalculator")]
public interface ICalculator
{

    [System.ServiceModel.OperationContractAttribute(
Action="http://Microsoft.ServiceModel.Samples/ICalculator/Add", ReplyAction="http://Microsoft.ServiceModel.Samples/ICalculator/AddResponse")]
    double Add(double n1, double n2);

        [System.ServiceModel.OperationContractAttribute(
Action="http://Microsoft.ServiceModel.Samples/ICalculator/Subtract", ReplyAction="http://Microsoft.ServiceModel.Samples/ICalculator/SubtractResponse")]
    double Subtract(double n1, double n2);

        [System.ServiceModel.OperationContractAttribute(
Action="http://Microsoft.ServiceModel.Samples/ICalculator/Multiply", ReplyAction="http://Microsoft.ServiceModel.Samples/ICalculator/MultiplyResponse")]
    double Multiply(double n1, double n2);

        [System.ServiceModel.OperationContractAttribute(
Action="http://Microsoft.ServiceModel.Samples/ICalculator/Divide", ReplyAction="http://Microsoft.ServiceModel.Samples/ICalculator/DivideResponse")]
    double Divide(double n1, double n2);
}

L'application cliente générée contient également l'implémentation de ClientCalculator. Notez que les informations d'adresse et de liaison ne sont pas spécifiées n'importe où dans l'implémentation du service. Par ailleurs, il n'est pas nécessaire d'écrire du code pour récupérer ces informations à partir du fichier de configuration.

// Implementation of the CalculatorClient
public partial class CalculatorClient : System.ServiceModel.ClientBase<Microsoft.ServiceModel.Samples.ICalculator>, Microsoft.ServiceModel.Samples.ICalculator
{

    public CalculatorClient()
    {
    }

    public CalculatorClient(string endpointConfigurationName) : 
            base(endpointConfigurationName)
    {
    }

    public CalculatorClient(string endpointConfigurationName, string remoteAddress) : 
            base(endpointConfigurationName, remoteAddress)
    {
    }

    public CalculatorClient(string endpointConfigurationName, 
            System.ServiceModel.EndpointAddress remoteAddress) : 
            base(endpointConfigurationName, remoteAddress)
    {
    }

    public CalculatorClient(System.ServiceModel.Channels.Binding binding,                 System.ServiceModel.EndpointAddress remoteAddress) : 
            base(binding, remoteAddress)
    {
    }

    public double Add(double n1, double n2)
    {
        return base.Channel.Add(n1, n2);
    }

    public double Subtract(double n1, double n2)
    {
        return base.Channel.Subtract(n1, n2);
    }

    public double Multiply(double n1, double n2)
    {
        return base.Channel.Multiply(n1, n2);
    }

    public double Divide(double n1, double n2)
    {
        return base.Channel.Divide(n1, n2);
    }
}

La configuration du client qui utilise NetTcpBinding est également générée par Svcutil.exe. Ce fichier doit être nommé dans le fichier App.config lors de l'utilisation de Visual Studio.

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <system.serviceModel> 
        <bindings> 
            <netTcpBinding> 
                <binding name="NetTcpBinding_ICalculator"> 
                    <security mode="None"/> 
                </binding> 
            </netTcpBinding> 
        </bindings> 
        <client> 
            <endpoint 
              address="net.tcp://localhost/servicemodelsamples/service.svc" 
              binding="netTcpBinding" bindingConfiguration="NetTcpBinding_ICalculator" 
              contract="ICalculator" name="NetTcpBinding_ICalculator" /> 
        </client>
    </system.serviceModel> 
</configuration>

Créez une instance ClientCalculator dans une application, puis appelez les opérations de service.

//Client implementation code.
class Client
{
    static void Main()
    {
        // Create a client with given client endpoint configuration
        CalculatorClient client = new CalculatorClient();

        // Call the Add service operation.
        double value1 = 100.00D;
        double value2 = 15.99D;
        double result = client.Add(value1, value2);
        Console.WriteLine("Add({0},{1}) = {2}", value1, value2, result);

        // Call the Subtract service operation.
        value1 = 145.00D;
        value2 = 76.54D;
        result = client.Subtract(value1, value2);
        Console.WriteLine("Subtract({0},{1}) = {2}", value1, value2, result);

        // Call the Multiply service operation.
        value1 = 9.00D;
        value2 = 81.25D;
        result = client.Multiply(value1, value2);
        Console.WriteLine("Multiply({0},{1}) = {2}", value1, value2, result);

        // Call the Divide service operation.
        value1 = 22.00D;
        value2 = 7.00D;
        result = client.Divide(value1, value2);
        Console.WriteLine("Divide({0},{1}) = {2}", value1, value2, result);

        //Closing the client gracefully closes the connection and cleans up resources
        client.Close();

        Console.WriteLine();
        Console.WriteLine("Press <ENTER> to terminate client.");
        Console.ReadLine();
    }
}

Compilez, puis exécutez le client.

Voir aussi

Tâches

TCP Activation

Autres ressources

Fonctionnalités d'hébergement de Windows Server AppFabric

Partager via