ServiceContractAttribute Klas

Definitie

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

Overname

Object

Attribute

ServiceContractAttribute

Kenmerken

AttributeUsageAttribute

Voorbeelden

In het volgende codevoorbeeld ziet u hoe u de ServiceContractAttribute interface toepast om een servicecontract te definiëren met één servicemethode, aangegeven door de OperationContractAttribute. In dit geval is het beveiligingsniveau dat vereist is ProtectionLevel.EncryptAndSignvoor bindingen voor alle berichten.

In het codevoorbeeld wordt dat contract vervolgens op de SampleService klasse geïmplementeerd.

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

In het volgende codevoorbeeld ziet u een eenvoudig configuratiebestand voor de voorgaande service waarmee één eindpunt wordt gemaakt.

<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>

In het volgende codevoorbeeld ziet u een eenvoudige client die de voorgaande SampleServiceaanroept.

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

Opmerkingen

Gebruik het ServiceContractAttribute kenmerk op een interface (of klasse) om een servicecontract te definiëren. Gebruik vervolgens het OperationContractAttribute kenmerk op een of meer van de klassemethoden (of interface) om de servicebewerkingen van het contract te definiëren. Wanneer het servicecontract wordt geïmplementeerd en gecombineerd met bindingen en een EndpointAddress object, wordt het servicecontract beschikbaar gesteld voor gebruik door clients. Zie De zelfstudie Aan de slag voor een overzicht van het proces met behulp van eenvoudige voorbeelden. Zie Services ontwerpen en implementeren voor meer informatie over het maken van servicecontracten.

De informatie die door een ServiceContractAttribute en de bijbehorende interface wordt uitgedrukt, is losjes gerelateerd aan het WSDL-element (Web Services Description Language). <portType> Aan de servicezijde wordt een servicecontract gebruikt om op te geven wat het eindpunt van de service beschikbaar maakt voor bellers. Het wordt ook gebruikt aan de clientzijde om het contract op te geven van het eindpunt waarmee de client communiceert en, in het geval van dubbelzijdige contracten, het callback-contract (met behulp van de CallbackContract eigenschap) op te geven dat de client moet implementeren om deel te nemen aan een dubbelzijdig gesprek.

Gebruik de ServiceContractAttribute eigenschappen om het servicecontract te wijzigen.

• De ConfigurationName eigenschap geeft de naam op van het service-element in het configuratiebestand dat moet worden gebruikt.

• De Name en Namespace eigenschappen bepalen de naam en naamruimte van het contract in het WSDL-element <portType> .

• De SessionMode eigenschap geeft aan of voor het contract een binding is vereist die sessies ondersteunt.

• De CallbackContract eigenschap geeft het retourcontract op in een tweerichtingsgesprek (duplex).

• De HasProtectionLevel en ProtectionLevel eigenschappen geven aan of alle berichten die het contract ondersteunen een expliciete ProtectionLevel waarde hebben, en zo ja, wat dat niveau is.

Services implementeren servicecontracten, die de gegevensuitwisseling vertegenwoordigen die een servicetype ondersteunt. Een serviceklasse kan een servicecontract implementeren (door een interface te implementeren die is gemarkeerd met ServiceContractAttribute methoden die zijn gemarkeerd met OperationContractAttribute) of kan worden gemarkeerd met het ServiceContractAttribute kenmerk en het OperationContractAttribute kenmerk toepassen op zijn eigen methoden. (Als een klasse een interface implementeert die is gemarkeerd met ServiceContractAttribute, kan deze niet zelf worden gemarkeerd met ServiceContractAttribute.) Methoden voor servicetypen die zijn gemarkeerd met de OperationContractAttribute service, worden behandeld als onderdeel van een standaardservicecontract dat is opgegeven door het servicetype zelf. Zie voor meer informatie over servicebewerkingen OperationContractAttribute.

De eigenschappen en Namespace eigenschappen Name zijn standaard de naam van het contracttype en http://tempuri.org, respectievelijk, en ProtectionLevel is ProtectionLevel.None. Het wordt aanbevolen dat servicecontracten expliciet hun namen, naamruimten en beveiligingsniveaus instellen met behulp van deze eigenschappen. Als u dit doet, worden twee doelen bereikt. Ten eerste bouwt het een contract dat niet rechtstreeks is verbonden met de gegevens van het beheerde type, zodat u uw beheerde code en naamruimten kunt herstructureren zonder dat het contract wordt onderbroken, zoals deze wordt uitgedrukt in WSDL. Ten tweede, expliciet een bepaald beschermingsniveau voor het contract zelf vereist, kan de runtime valideren of de bindingsconfiguratie dat beveiligingsniveau ondersteunt, waardoor slechte configuratie gevoelige informatie kan blootstellen. Zie Understanding Protection Level ( Beveiligingsniveau) voor meer informatie over beveiligingsniveaus.

Als u een service beschikbaar wilt maken voor gebruik door clienttoepassingen, maakt u een hosttoepassing om uw service-eindpunt te registreren bij Windows Communication Foundation (WCF). U kunt WCF-services hosten met behulp van Windows Activation Services (WAS), in consoletoepassingen, Windows Service-toepassingen, ASP.NET-toepassingen, Windows Forms-toepassingen of een ander soort toepassingsdomein.

Hosting in de WAS is vergelijkbaar met het maken van een ASP.NET toepassing. Zie Procedure: Een WCF-service hosten in IIS voor meer informatie.

Clients gebruiken de interface van het servicecontract (de interface die is gemarkeerd met ServiceContractAttribute) om een kanaal te maken voor de service of ze gebruiken de clientobjecten (die de typegegevens van de servicecontractinterface met de ClientBase<TChannel> klasse combineren) om met uw service te communiceren. Zie het ChannelFactory<TChannel> klasse- en WCF-clientoverzicht voor meer informatie over clientkanalen voor services.

Als u een ServiceContractAttribute klasse of interface gebruikt om over te nemen van een andere ServiceContractAttribute klasse of interface, wordt het bovenliggende contract uitgebreid. Als een IChildContract interface bijvoorbeeld is gemarkeerd met ServiceContractAttribute en overgenomen van een andere interface voor servicecontract, IParentContractbevat het IChildContract servicecontract de methoden van beide IParentContract en IChildContract. Het uitbreiden van contracten (of op klassen of interfaces) is vergelijkbaar met het uitbreiden van beheerde klassen en interfaces.

De meest flexibele benadering voor het maken van services is om eerst servicecontractinterfaces te definiëren en vervolgens uw serviceklasse die interface te laten implementeren. (Dit is ook de eenvoudigste manier om uw services te bouwen als u servicecontracten moet implementeren die door anderen zijn gedefinieerd.) Services rechtstreeks bouwen door een klasse met ServiceContractAttribute en de bijbehorende methoden te markeren wanneer OperationContractAttribute de service slechts één contract beschikbaar maakt (maar dat contract kan worden weergegeven door meer dan één eindpunt).

Gebruik de CallbackContract eigenschap om een ander servicecontract aan te geven dat, wanneer het afhankelijk is van het oorspronkelijke servicecontract, een berichtuitwisseling definieert die op twee manieren onafhankelijk kan stromen. Zie CallbackContractvoor meer informatie.

Zie ook

• OperationContractAttribute
• Servicecontracten definiëren
• Een service hosten
• Overzicht van het maken van services
• Een client bouwen
• Overzicht van het maken van een proxy