ServiceContractAttribute Classe

Definição

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

Herança

Object

Attribute

ServiceContractAttribute

Atributos

AttributeUsageAttribute

Exemplos

O exemplo de código a seguir mostra como aplicar a ServiceContractAttribute uma interface para definir um contrato de serviço com um método de serviço, indicado pelo OperationContractAttribute. Nesse caso, o nível de proteção necessário de associações para todas as mensagens é ProtectionLevel.EncryptAndSign.

Em seguida, o exemplo de código implementa esse contrato na 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

O exemplo de código a seguir mostra um arquivo de configuração simples para o serviço anterior que cria um ponto de extremidade.

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

O exemplo de código a seguir mostra um cliente simples que invoca o anterior 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

Comentários

Use o ServiceContractAttribute atributo em uma interface (ou classe) para definir um contrato de serviço. Em seguida, use o OperationContractAttribute atributo em um ou mais métodos de classe (ou interface) para definir as operações de serviço do contrato. Quando o contrato de serviço é implementado e combinado com uma Associação e um EndpointAddress objeto, o contrato de serviço é exposto para uso pelos clientes. Para obter uma visão geral do processo usando exemplos simples, consulte Introdução Tutorial. Para obter mais informações sobre como criar contratos de serviço, consulte Projetar e implementar serviços.

As informações expressas por um ServiceContractAttribute e sua interface estão vagamente relacionadas ao elemento WSDL (Linguagem de Descrição dos <portType> Serviços Web). Um contrato de serviço é usado no lado do serviço para especificar o que o ponto de extremidade do serviço expõe aos chamadores. Ele também é usado no lado do cliente para especificar o contrato do ponto de extremidade com o qual o cliente se comunica e, no caso de contratos duplex, para especificar o contrato de retorno de chamada (usando a CallbackContract propriedade) que o cliente deve implementar para participar de uma conversa duplex.

Use as ServiceContractAttribute propriedades para modificar o contrato de serviço.

• A ConfigurationName propriedade especifica o nome do elemento de serviço no arquivo de configuração a ser usado.

• As Name propriedades e Namespace o nome e o namespace do contrato no elemento WSDL <portType> .

• A SessionMode propriedade especifica se o contrato requer uma associação que dá suporte a sessões.

• A CallbackContract propriedade especifica o contrato de retorno em uma conversa bidirecional (duplex).

• As HasProtectionLevel propriedades e ProtectionLevel as propriedades indicam se todas as mensagens compatíveis com o contrato têm um valor explícito ProtectionLevel e, se for o caso, qual é esse nível.

Os serviços implementam contratos de serviço, que representam a troca de dados compatível com um tipo de serviço. Uma classe de serviço pode implementar um contrato de serviço (implementando uma interface marcada com ServiceContractAttribute métodos marcados com OperationContractAttribute) ou pode ser marcada com o ServiceContractAttribute atributo e aplicar o OperationContractAttribute atributo aos seus próprios métodos. (Se uma classe implementar uma interface marcada com ServiceContractAttribute, ela não poderá ser marcada com ServiceContractAttribute.) Métodos em tipos de serviço marcados com o OperationContractAttribute são tratados como parte de um contrato de serviço padrão especificado pelo próprio tipo de serviço. Para obter detalhes sobre operações de serviço, consulte OperationContractAttribute.

Por padrão, o e Namespace as Name propriedades são o nome do tipo de contrato ehttp://tempuri.org, respectivamente, e ProtectionLevel é ProtectionLevel.None. É recomendável que os contratos de serviço definam explicitamente seus nomes, namespaces e níveis de proteção usando essas propriedades. Fazer isso atinge duas metas. Primeiro, ele cria um contrato que não está diretamente conectado às informações de tipo gerenciado, permitindo que você refatore seu código gerenciado e namespaces sem quebrar o contrato como ele é expresso no WSDL. Em segundo lugar, exigir explicitamente um determinado nível de proteção no próprio contrato permite que o runtime valide se a configuração de associação dá suporte a esse nível de segurança, impedindo que a configuração ruim exponha informações confidenciais. Para obter mais informações sobre os níveis de proteção, consulte Noções básicas sobre o nível de proteção.

Para expor um serviço para uso por aplicativos cliente, crie um aplicativo host para registrar seu ponto de extremidade de serviço com Windows Communication Foundation (WCF). Você pode hospedar serviços do WCF usando Windows WAS (Serviços de Ativação), em aplicativos de console, aplicativos de serviço de Windows, aplicativos ASP.NET, aplicativos Windows Forms ou qualquer outro tipo de domínio de aplicativo.

Hospedar no WAS é muito semelhante à criação de um aplicativo ASP.NET. Para obter detalhes, consulte Como hospedar um serviço WCF no IIS.

Os clientes também usam a interface de contrato de serviço (a interface marcada com ServiceContractAttribute) para criar um canal para o serviço ou eles usam os objetos de cliente (que combine as informações de tipo da interface do contrato de serviço com o ClientBase<TChannel> classe) para se comunicar com seu serviço. Para obter detalhes sobre os canais de cliente aos serviços, consulte a ChannelFactory<TChannel> classe e visão geral do cliente WCF.

Usando um ServiceContractAttribute classe ou interface para herdar de outro ServiceContractAttribute classe ou interface estende o contrato do pai. Por exemplo, se um IChildContract interface é marcado com ServiceContractAttribute e herdada de outra interface de contrato de serviço IParentContract, o IChildContract contrato de serviço contém os métodos de ambos IParentContract e IChildContract. Estender contratos (seja em classes ou interfaces) é muito semelhante à extensão de classes e interfaces gerenciadas.

A abordagem mais flexível para criar serviços é definir as interfaces do contrato de serviço primeiro e, em seguida, fazer com que sua classe de serviço implemente essa interface. (Essa também é a maneira mais simples de criar seus serviços se você precisar implementar contratos de serviço que foram definidos por outras pessoas.) Criar serviços diretamente marcando uma classe com ServiceContractAttribute e seus métodos com OperationContractAttribute trabalhos quando o serviço expõe apenas um contrato (mas esse contrato pode ser exposto por mais de um ponto de extremidade).

Use a CallbackContract propriedade para indicar outro contrato de serviço que, quando associado ao contrato de serviço original, defina uma troca de mensagens que pode fluir de duas maneiras de forma independente. Para obter detalhes, consulte CallbackContract.

Construtores

Propriedades

Métodos

Implantações explícitas de interface

Aplica-se a

Confira também

• OperationContractAttribute
• Definindo contratos de serviço
• Hospedar um serviço
• Visão geral da Criação de Serviço
• Criando um cliente
• Visão geral da criação de proxy