ServiceContractAttribute Classe

Référence

Définition

Espace de noms:: System.ServiceModel

Assembly:: System.ServiceModel.Primitives.dll

Assembly:: System.ServiceModel.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Indique qu’une interface ou une classe définit un contrat de service dans une application Windows Communication Foundation (WCF).

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, Inherited=false)]
public sealed class ServiceContractAttribute : Attribute

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

[<System.AttributeUsage(System.AttributeTargets.Class | System.AttributeTargets.Interface, 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 indique comment appliquer la ServiceContractAttribute à une interface pour définir un contrat de service avec une méthode de service, tel qu'indiqué par la OperationContractAttribute. Dans ce cas, le niveau de protection requis des liaisons pour tous les messages est ProtectionLevel.EncryptAndSign.

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

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 présente 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 affiche un client simple qui appelle le SampleService précédent.

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. Puis utilisez 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é à 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 Prise en main Tutoriel. Pour plus d’informations sur la création de contrats de service, consultez Conception et implémentation de services.

Les informations exprimées par une ServiceContractAttribute et son interface sont faiblement mises en rapport avec l'élément <portType> WSDL (Web Services Description Language). Un contrat de service est utilisé côté service pour spécifier ce que le point de terminaison du service expose aux appelants. Il est également utilisé sur le 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 propriété CallbackContract) que le client doit implémenter afin de participer à une conversation duplex.

Notes

Une interface ou une classe qui est décorée avec ServiceContractAttribute doit également avoir au moins une méthode marquée avec l'attribut OperationContractAttribute pour exposer toutes les fonctionnalités. Consultez la section Exemples pour obtenir un exemple de code de l'utilisation la plus simple des deux attributs pour définir et implémenter un service.

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

La propriété ConfigurationName spécifie le nom de l'élément de service dans le fichier de configuration à utiliser.
Les propriétés Name et Namespace contrôlent le nom et l'espace de noms du contrat dans l'élément <portType> WSDL.
La propriété SessionMode spécifie si le contrat requiert une liaison qui prend en charge des sessions.
La propriété CallbackContract spécifie le contrat de retour dans une conversation bidirectionnelle (duplex).
Les propriétés HasProtectionLevel et ProtectionLevel indiquent si tous les messages qui prennent en charge le contrat ont une valeur ProtectionLevel explicite, et le cas échéant, quel est le niveau.

Les services implémentent des contrats de service qui représentent l'échange de données qu'un type de service prend en charge. Une classe de service peut implémenter un contrat de service (en implémentant une interface marquée avec ServiceContractAttribute qui a des méthodes marquées avec OperationContractAttribute) ou elle peut être marquée avec la 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 Name et Namespace correspondent au nom du type de contrat et de http://tempuri.org, respectivement, et ProtectionLevel a la valeur 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'assurer deux fonctions. D'une part, cela génère un contrat qui n'est pas directement connecté aux informations de type managé, en vous permettant de refactoriser votre code managé et vos espaces de noms sans rompre le contrat comme cela est exprimé dans WSDL. D’autre part, exiger de façon explicite un certain niveau de protection sur le contrat permet à l’exécution de valider si la configuration de liaison prend en charge ce niveau de sécurité, ce qui permet d’éviter d’exposer des informations sensibles en raison d’une mauvaise configuration. Pour plus d’informations sur les niveaux de protection, consultez Présentation du niveau de protection.

Pour exposer un service à utiliser par des 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 Windows service, les applications ASP.NET, les applications Windows Forms ou tout autre type de domaine d’application.

L'hébergement dans WAS est extrêmement 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 au service ou ils utilisent les objets clients (qui associent les informations de type de l'interface de contrat de service avec la classe ClientBase<TChannel>) pour communiquer avec votre service. Pour plus d’informations sur les canaux clients vers les services, consultez la classe et la vue d’ensemble du ChannelFactory<TChannel> client WCF.

L'utilisation d'une classe ou d'une interface ServiceContractAttribute pour hériter d'une autre classe ou interface ServiceContractAttribute étend le contrat parent. Par exemple, si une interface IChildContract est marquée avec ServiceContractAttribute et héritée d'une autre interface de contrat de service, IParentContract, le contrat de service IChildContract contient les méthodes de IParentContract et de IChildContract. L'extension des contrats (sur les classes ou les interfaces) est extrêmement similaire à l'extension des classes et des interfaces managées.

L'approche la plus flexible en termes de création de services consiste à définir tout d'abord des interfaces de contrat de service, puis de faire implémenter cette interface par votre contrat de service. (Il s’agit également du moyen le 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.) Création de services directement en marquant une classe avec ServiceContractAttribute et ses méthodes lorsque OperationContractAttribute 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.

Constructeurs

ServiceContractAttribute()

Initialise une nouvelle instance de la classe ServiceContractAttribute.

Propriétés

CallbackContract	Obtient ou définit le type de contrat de rappel lorsque le contrat est un contrat duplex.
ConfigurationName	Obtient ou définit le nom utilisé pour localiser le service dans un fichier de configuration de l'application.
HasProtectionLevel	Obtient une valeur qui indique si un niveau de protection a été assigné au membre.
Name	Obtient ou définit le nom pour l'élément `<portType>` dans WSDL (Web Services Description Language).
Namespace	Obtient ou définit l'espace de noms de l'élément `<portType>` dans WSDL (Web Services Description Language).
ProtectionLevel	Spécifie si la liaison pour le contrat doit prendre en charge la valeur de la propriété ProtectionLevel.
SessionMode	Obtient ou définit si les sessions sont autorisées, ne sont pas autorisées ou sont requises.
TypeId	Lors de l'implémentation dans une classe dérivée, obtient un identificateur unique pour l'objet Attribute. (Hérité de Attribute)

Méthodes

Equals(Object)	Retourne une valeur qui indique si cette instance est égale à un objet spécifié. (Hérité de Attribute)
GetHashCode()	Retourne le code de hachage de cette instance. (Hérité de Attribute)
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
IsDefaultAttribute()	En cas de substitution dans une classe dérivée, indique si la valeur de cette instance est la valeur par défaut pour la classe dérivée. (Hérité de Attribute)
Match(Object)	En cas de substitution dans une classe dérivée, retourne une valeur indiquant si cette instance équivaut à un objet spécifié. (Hérité de Attribute)
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
ToString()	Retourne une chaîne qui représente l'objet actuel. (Hérité de Object)

Implémentations d’interfaces explicites

_Attribute.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Mappe un jeu de noms avec un jeu correspondant d'identificateurs de dispatch. (Hérité de Attribute)
_Attribute.GetTypeInfo(UInt32, UInt32, IntPtr)	Récupère les informations de type pour un objet, qui peuvent être utilisées pour obtenir les informations de type d'une interface. (Hérité de Attribute)
_Attribute.GetTypeInfoCount(UInt32)	Récupère le nombre d'interfaces d'informations de type fourni par un objet (0 ou 1). (Hérité de Attribute)
_Attribute.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Fournit l'accès aux propriétés et aux méthodes exposées par un objet. (Hérité de Attribute)

S’applique à