ServiceContractAttribute Classe

Définition

public ref class ServiceContractAttribute sealed : Attribute

[System.AttributeUsage(System.AttributeTargets.Class | System.AttributeTargets.Interface, AllowMultiple=false, Inherited=false)]
public sealed class ServiceContractAttribute : Attribute

[<System.AttributeUsage(System.AttributeTargets.Class | System.AttributeTargets.Interface, AllowMultiple=false, Inherited=false)>]
type ServiceContractAttribute = class
    inherit Attribute

Public NotInheritable Class ServiceContractAttribute
Inherits Attribute

Héritage

Object

Attribute

ServiceContractAttribute

Attributs

AttributeUsageAttribute

Exemples

L’exemple de code suivant montre comment appliquer l’interface ServiceContractAttribute à une interface pour définir un contrat de service avec une méthode de service, indiquée par le OperationContractAttribute. Dans ce cas, le niveau de protection requis pour toutes les liaisons pour tous les messages est ProtectionLevel.EncryptAndSign.

L’exemple de code implémente ensuite ce contrat sur la SampleService classe.

using System;
using System.Collections.Generic;
using System.Net.Security;
using System.ServiceModel;
using System.Text;

namespace Microsoft.WCF.Documentation
{
  [ServiceContract(
    Namespace="http://microsoft.wcf.documentation",
    Name="SampleService",
    ProtectionLevel=ProtectionLevel.EncryptAndSign
  )]
  public interface ISampleService{
    [OperationContract]
    string SampleMethod(string msg);
  }

  class SampleService : ISampleService
  {
  #region ISampleService Members

  public string  SampleMethod(string msg)
  {
      return "The service greets you: " + msg;
  }

  #endregion
  }
}

Imports System.Collections.Generic
Imports System.Net.Security
Imports System.ServiceModel
Imports System.Text

Namespace Microsoft.WCF.Documentation
  <ServiceContract(Namespace:="http://microsoft.wcf.documentation", Name:="SampleService", ProtectionLevel:=ProtectionLevel.EncryptAndSign)> _
  Public Interface ISampleService
    <OperationContract> _
    Function SampleMethod(ByVal msg As String) As String
  End Interface

  Friend Class SampleService
      Implements ISampleService
  #Region "ISampleService Members"

  Public Function SampleMethod(ByVal msg As String) As String Implements ISampleService.SampleMethod
       Return "The service greets you: " & msg
  End Function

  #End Region
  End Class
End Namespace

L’exemple de code suivant montre un fichier de configuration simple pour le service précédent qui crée un point de terminaison.

<configuration>
  <system.serviceModel>
    <services>
      <service 
        name="Microsoft.WCF.Documentation.SampleService"
        behaviorConfiguration="mex"
      >
        <host>
          <baseAddresses>
            <add baseAddress="http://localhost:8080/SampleService"/>
          </baseAddresses>
        </host>
        <endpoint
          address=""
          binding="wsHttpBinding"
          contract="Microsoft.WCF.Documentation.ISampleService"
         />
        <endpoint
          address="mex"
          binding="mexHttpBinding"
          contract="IMetadataExchange"
        />
      </service>
    </services>
    <behaviors>
      <serviceBehaviors>
        <behavior name="mex">
          <serviceMetadata httpGetEnabled="true" httpGetUrl=""/>
        </behavior>
      </serviceBehaviors>
    </behaviors>
  </system.serviceModel>
</configuration>

L’exemple de code suivant montre un client simple qui appelle le précédent SampleService.

using System;
using System.ServiceModel;
using System.ServiceModel.Channels;

public class Client
{
  public static void Main()
  {
    // Picks up configuration from the config file.
    SampleServiceClient wcfClient = new SampleServiceClient();
    try
    {
        // Making calls.
        Console.WriteLine("Enter the greeting to send: ");
        string greeting = Console.ReadLine();
        Console.WriteLine("The service responded: " + wcfClient.SampleMethod(greeting));

        Console.WriteLine("Press ENTER to exit:");
        Console.ReadLine();

        // Done with service.
        wcfClient.Close();
        Console.WriteLine("Done!");
    }
    catch (TimeoutException timeProblem)
    {
      Console.WriteLine("The service operation timed out. " + timeProblem.Message);
      wcfClient.Abort();
      Console.Read();
    }
    catch(CommunicationException commProblem)
    {
      Console.WriteLine("There was a communication problem. " + commProblem.Message);
      wcfClient.Abort();
      Console.Read();
    }
  }
}

Imports System.ServiceModel
Imports System.ServiceModel.Channels

Public Class Client
  Public Shared Sub Main()
    ' Picks up configuration from the config file.
    Dim wcfClient As New SampleServiceClient()
    Try
        ' Making calls.
        Console.WriteLine("Enter the greeting to send: ")
            Dim greeting = Console.ReadLine()
        Console.WriteLine("The service responded: " & wcfClient.SampleMethod(greeting))

        Console.WriteLine("Press ENTER to exit:")
        Console.ReadLine()

        ' Done with service. 
        wcfClient.Close()
        Console.WriteLine("Done!")
    Catch timeProblem As TimeoutException
      Console.WriteLine("The service operation timed out. " & timeProblem.Message)
      wcfClient.Abort()
      Console.Read()
    Catch commProblem As CommunicationException
      Console.WriteLine("There was a communication problem. " & commProblem.Message)
      wcfClient.Abort()
      Console.Read()
    End Try
  End Sub
End Class

Remarques

Utilisez l’attribut ServiceContractAttribute sur une interface (ou une classe) pour définir un contrat de service. Utilisez ensuite l’attribut OperationContractAttribute sur une ou plusieurs méthodes de classe (ou d’interface) pour définir les opérations de service du contrat. Lorsque le contrat de service est implémenté et combiné avec des liaisons et un EndpointAddress objet, le contrat de service est exposé pour une utilisation par les clients. Pour obtenir une vue d’ensemble du processus à l’aide d’exemples simples, consultez Didacticiel de prise en main. Pour plus d’informations sur la création de contrats de service, consultez Conception et implémentation de services.

Les informations exprimées par un ServiceContractAttribute et son interface sont faiblement liées à l’élément WSDL (Web Services Description Language). <portType> Un contrat de service est utilisé côté service pour spécifier le point de terminaison du service exposé aux appelants. Il est également utilisé côté client pour spécifier le contrat du point de terminaison avec lequel le client communique et, dans le cas de contrats duplex, pour spécifier le contrat de rappel (à l’aide de la CallbackContract propriété) que le client doit implémenter pour participer à une conversation duplex.

Utilisez les ServiceContractAttribute propriétés pour modifier le contrat de service.

• La ConfigurationName propriété spécifie le nom de l’élément de service dans le fichier de configuration à utiliser.

• Namespace Les Name propriétés contrôlent le nom et l’espace de noms du contrat dans l’élément WSDL<portType>.

• La SessionMode propriété spécifie si le contrat nécessite une liaison qui prend en charge les sessions.

• La CallbackContract propriété spécifie le contrat de retour dans une conversation bidirectionnelle (duplex).

• Les HasProtectionLevel propriétés et ProtectionLevel les propriétés indiquent si tous les messages prenant en charge le contrat ont une valeur explicite ProtectionLevel et, le cas échéant, quel est ce niveau.

Les services implémentent des contrats de service, qui représentent l’échange de données pris en charge par un type de service. Une classe de service peut implémenter un contrat de service (en implémentant une interface marquée avec ServiceContractAttribute les méthodes marquées avec OperationContractAttribute) ou elle peut être marquée avec l’attribut ServiceContractAttribute et appliquer l’attribut OperationContractAttribute à ses propres méthodes. (Si une classe implémente une interface marquée avec ServiceContractAttribute, elle ne peut pas être elle-même marquée avec ServiceContractAttribute.) Les méthodes sur les types de service marqués avec ceux-ci OperationContractAttribute sont traitées dans le cadre d’un contrat de service par défaut spécifié par le type de service lui-même. Pour plus d’informations sur les opérations de service, consultez OperationContractAttribute.

Par défaut, les propriétés et Namespace les Name propriétés sont le nom du type de contrat ethttp://tempuri.org, respectivement, et ProtectionLevel est ProtectionLevel.None. Il est recommandé que les contrats de service définissent explicitement leurs noms, espaces de noms et niveaux de protection à l’aide de ces propriétés. Cela permet d’atteindre deux objectifs. Tout d’abord, il génère un contrat qui n’est pas directement connecté aux informations de type managé, ce qui vous permet de refactoriser votre code managé et vos espaces de noms sans rompre le contrat tel qu’il est exprimé dans WSDL. Deuxièmement, exiger explicitement un certain niveau de protection sur le contrat lui-même permet au runtime de vérifier si la configuration de liaison prend en charge ce niveau de sécurité, empêchant ainsi une configuration médiocre d’exposer des informations sensibles. Pour plus d’informations sur les niveaux de protection, consultez Présentation du niveau de protection.

Pour exposer un service à utiliser par les applications clientes, créez une application hôte pour inscrire votre point de terminaison de service auprès de Windows Communication Foundation (WCF). Vous pouvez héberger des services WCF à l’aide des services d’activation Windows (WAS), dans les applications console, les applications de service Windows, les applications ASP.NET, les applications Windows Forms ou tout autre type de domaine d’application.

L’hébergement dans was est très similaire à la création d’une application ASP.NET. Pour plus d’informations, consultez Guide pratique pour héberger un service WCF dans IIS.

Les clients utilisent l’interface de contrat de service (l’interface marquée avec ServiceContractAttribute) pour créer un canal vers le service ou utiliser les objets clients (qui combinent les informations de type de l’interface de contrat de service avec la ClientBase<TChannel> classe) pour communiquer avec votre service. Pour plus d’informations sur les canaux clients vers les services, consultez la classe et la ChannelFactory<TChannel>vue d’ensemble du client WCF.

L’utilisation d’une classe ou d’une ServiceContractAttribute interface pour hériter d’une autre ServiceContractAttribute classe ou interface étend le contrat parent. Par exemple, si une IChildContract interface est marquée avec ServiceContractAttribute et héritée d’une autre interface de contrat de service, IParentContractle IChildContract contrat de service contient les méthodes des deux IParentContract et IChildContractdes deux. L’extension des contrats (que ce soit sur des classes ou des interfaces) est très similaire à l’extension des classes managées et des interfaces.

L’approche la plus flexible pour créer des services consiste à définir d’abord des interfaces de contrat de service, puis à mettre en œuvre cette interface par votre classe de service. (Il s’agit également de la façon la plus simple de créer vos services si vous devez implémenter des contrats de service qui ont été définis par d’autres utilisateurs.) La création de services directement en marquant une classe avec ServiceContractAttribute et ses méthodes fonctionne OperationContractAttribute lorsque le service n’expose qu’un seul contrat (mais ce contrat peut être exposé par plusieurs points de terminaison).

Utilisez la CallbackContract propriété pour indiquer un autre contrat de service qui, lorsqu’il est lié avec le contrat de service d’origine, définissez un échange de messages qui peut circuler de deux manières indépendamment. Pour plus d’informations, consultez CallbackContract.

Voir aussi

• OperationContractAttribute
• Définition de contrats de service
• Hébergement d’un service
• Vue d’ensemble de la création de service
• Création d’un client
• Vue d’ensemble de la création de proxy