Noções básicas sobre o código do cliente gerado

A Ferramenta de Utilitário de Metadados do ServiceModel (Svcutil.exe) gera o código do cliente e um arquivo de configuração de aplicativo cliente para uso na criação de aplicativos cliente. Este tópico fornece um tour de exemplos de código gerados para cenários de contrato de serviço padrão. Para obter mais informações sobre como criar um aplicativo cliente usando o código gerado, consulte a Visão geral do cliente do WCF.

Visão geral

Se você usar o Visual Studio para gerar tipos de cliente do WCF (Windows Communication Foundation) para seu projeto, normalmente não será necessário examinar o código do cliente gerado. Se você não estiver usando um ambiente de desenvolvimento que executa os mesmos serviços para você, poderá usar uma ferramenta como Svcutil.exe para gerar código do cliente e, em seguida, usar esse código para desenvolver seu aplicativo cliente.

Como Svcutil.exe tem várias opções que modificam as informações de tipo geradas, este tópico não discute todos os cenários. No entanto, as seguintes tarefas padrão envolvem a localização do código gerado:

• Identificando interfaces de contrato de serviço.

• Identificando a classe de cliente WCF.

• Identificando tipos de dados.

• Identificando contratos de retorno de chamada para serviços duplex.

• Identificando a interface do canal do contrato de serviço auxiliar.

Localizando interfaces de contrato de serviço

Para localizar as interfaces que modelam contratos de serviço, pesquise interfaces marcadas com o System.ServiceModel.ServiceContractAttribute atributo. Geralmente, esse atributo pode ser difícil de localizar com uma leitura rápida devido à presença de outros atributos e às propriedades explícitas definidas no próprio atributo. Lembre-se de que a interface do contrato de serviço e a interface do contrato do cliente são dois tipos diferentes. O exemplo de código a seguir mostra o contrato de serviço original.

[ServiceContractAttribute(
  Namespace = "http://microsoft.wcf.documentation"
)]
public interface ISampleService
{
  [OperationContractAttribute]
  [FaultContractAttribute(typeof(microsoft.wcf.documentation.SampleFault))]
  string SampleMethod(string msg);
}

O exemplo de código a seguir mostra o mesmo contrato de serviço gerado por Svcutil.exe.

[System.ServiceModel.ServiceContractAttribute(
  Namespace = "http://microsoft.wcf.documentation"
)]
public interface ISampleService
{
    [System.ServiceModel.OperationContractAttribute(
      Action = "http://microsoft.wcf.documentation/ISampleService/SampleMethod",
      ReplyAction = "http://microsoft.wcf.documentation/ISampleService/SampleMethodResponse"
    )]
    [System.ServiceModel.FaultContractAttribute(
      typeof(microsoft.wcf.documentation.SampleFault),
      Action = "http://microsoft.wcf.documentation/ISampleService/SampleMethodSampleFaultFault"
    )]
    string SampleMethod(string msg);
}

Você pode usar a interface de contrato de serviço gerada junto com a System.ServiceModel.ChannelFactory classe para criar um objeto de canal WCF com o qual invocar operações de serviço. Para obter mais informações, consulte Como usar o ChannelFactory.

Localizando classes de cliente do WCF

Para localizar a classe de cliente WCF que implementa o contrato de serviço que você deseja usar, procure uma extensão de System.ServiceModel.ClientBase<TChannel>, em que o parâmetro de tipo é a interface do contrato de serviço que você localizou anteriormente e que estende essa interface. O exemplo de código a seguir mostra a ClientBase<TChannel> classe do tipo ISampleService.

[System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "3.0.0.0")]
public partial class SampleServiceClient : System.ServiceModel.ClientBase<ISampleService>, ISampleService
{

    public SampleServiceClient()
    {
    }

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

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

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

    public SampleServiceClient(System.ServiceModel.Channels.Binding binding, System.ServiceModel.EndpointAddress remoteAddress)
        :
            base(binding, remoteAddress)
    {
    }
    public string SampleMethod(string msg)
    {
        return base.Channel.SampleMethod(msg);
    }
}

Você pode usar essa classe de cliente WCF criando uma nova instância dela e chamando os métodos que ela implementa. Esses métodos invocam a operação de serviço com a qual ela foi projetada e configurada para interagir. Para obter mais informações, consulte a visão geral do cliente do WCF.

Localizando tipos de dados

Para localizar tipos de dados no código gerado, o mecanismo mais básico é identificar o nome de tipo especificado em um contrato e pesquisar o código para essa declaração de tipo. Por exemplo, o contrato a seguir especifica que ele SampleMethod pode retornar uma falha SOAP do tipo microsoft.wcf.documentation.SampleFault.

[System.ServiceModel.OperationContractAttribute(
  Action = "http://microsoft.wcf.documentation/ISampleService/SampleMethod",
  ReplyAction = "http://microsoft.wcf.documentation/ISampleService/SampleMethodResponse"
)]
[System.ServiceModel.FaultContractAttribute(
  typeof(microsoft.wcf.documentation.SampleFault),
  Action = "http://microsoft.wcf.documentation/ISampleService/SampleMethodSampleFaultFault"
)]
string SampleMethod(string msg);

A pesquisa por SampleFault localiza a seguinte declaração de tipo.

[assembly: System.Runtime.Serialization.ContractNamespaceAttribute(
  "http://microsoft.wcf.documentation",
  ClrNamespace = "microsoft.wcf.documentation"
)]
namespace microsoft.wcf.documentation
{
    using System.Runtime.Serialization;

    [System.CodeDom.Compiler.GeneratedCodeAttribute("System.Runtime.Serialization", "3.0.0.0")]
    [System.Runtime.Serialization.DataContractAttribute()]
    public partial class SampleFault : object, System.Runtime.Serialization.IExtensibleDataObject
    {
        private System.Runtime.Serialization.ExtensionDataObject extensionDataField;
        private string FaultMessageField;

        public System.Runtime.Serialization.ExtensionDataObject ExtensionData
        {
            get
            {
                return this.extensionDataField;
            }
            set
            {
                this.extensionDataField = value;
            }
        }

        [System.Runtime.Serialization.DataMemberAttribute()]
        public string FaultMessage
        {
            get
            {
                return this.FaultMessageField;
            }
            set
            {
                this.FaultMessageField = value;
            }
        }
    }
}

Nesse caso, o tipo de dados é o tipo de detalhe gerado por uma exceção específica no cliente, um FaultException<TDetail> em que o parâmetro do tipo de detalhe é microsoft.wcf.documentation.SampleFault. Para obter mais informações sobre tipos de dados, consulte Especificando a transferência de dados em contratos de serviço. Para obter mais informações sobre como lidar com exceções em clientes, consulte Envio e Recebimento de Falhas.

Encontrando contratos de retorno de chamada para serviços duplex

Se você localizar um contrato de serviço para o qual a interface do contrato especifica um valor para a propriedade ServiceContractAttribute.CallbackContract, esse contrato especifica um contrato duplex. Os contratos duplex exigem que o aplicativo cliente crie uma classe de retorno de chamada que implemente o contrato de retorno de chamada e passe uma instância dessa classe para o System.ServiceModel.DuplexClientBase<TChannel> ou System.ServiceModel.DuplexChannelFactory<TChannel> usado para se comunicar com o serviço. Para obter mais informações sobre clientes duplex, consulte Como acessar serviços com um contrato Duplex.

O contrato a seguir especifica um contrato de callback do tipo SampleDuplexHelloCallback.

[System.ServiceModel.ServiceContractAttribute(
  Namespace="http://microsoft.wcf.documentation",
  ConfigurationName="SampleDuplexHello",
  CallbackContract=typeof(SampleDuplexHelloCallback),
  SessionMode=System.ServiceModel.SessionMode.Required
)]
public interface SampleDuplexHello
{
  [System.ServiceModel.OperationContractAttribute(
      IsOneWay=true,
      Action="http://microsoft.wcf.documentation/SampleDuplexHello/Hello"
    )]
    void Hello(string greeting);
  }

    <System.ServiceModel.OperationContractAttribute(IsOneWay:=True, _
        Action:="http://microsoft.wcf.documentation/SampleDuplexHello/Hello")> _
    Sub Hello(ByVal greeting As String)
End Interface 'SampleDuplexHello

A pesquisa desse contrato de callback localiza a interface a seguir que o aplicativo cliente deve implementar.

  [System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "3.0.0.0")]
public interface SampleDuplexHelloCallback
{
  [System.ServiceModel.OperationContractAttribute(
      IsOneWay=true,
      Action="http://microsoft.wcf.documentation/SampleDuplexHello/Reply"
    )]
    void Reply(string responseToGreeting);
  }

<System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "3.0.0.0")>  _
Public Interface SampleDuplexHelloCallback
    <System.ServiceModel.OperationContractAttribute( _
        IsOneWay:=True, _
        Action:="http://microsoft.wcf.documentation/SampleDuplexHello/Reply")> _
    Sub Reply(ByVal responseToGreeting As String)
End Interface 'SampleDuplexHelloCallback

Encontrando interfaces de canal de contrato de serviço

Ao usar a classe ChannelFactory com uma interface de contrato de serviço, é necessário fazer um cast para a interface System.ServiceModel.IClientChannel para abrir, fechar ou cancelar explicitamente o canal. Para facilitar o trabalho, a ferramenta Svcutil.exe também gera uma interface auxiliar que implementa a interface do contrato de serviço e IClientChannel para permitir que você interaja com a infraestrutura do canal do cliente sem ter que converter. O código a seguir mostra a definição de um canal cliente auxiliar que implementa o contrato de serviço anterior.

[System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "3.0.0.0")]
public interface ISampleServiceChannel : ISampleService, System.ServiceModel.IClientChannel
{
}

Consulte também

• Visão geral do cliente WCF