Clique aqui para ler todos os artigos desta edição
Windows Communication Foundation (WCF)
Aprenda o ABC da programação com o “Indigo”
Aaron Skonnard
|
Este artigo discute |
Este artigo usa as seguintes tecnologias |
|
· Fundamentos do WCF; · Hospedando um serviço e definindo endpoints; · Criando e configurando os clientes. |
· WCF (“Indigo”), Visual Studio 2005, .NET Framework 2.0, WSDL, SOAP. |
O Windows Communication Foundation (WCF), cujo codinome anterior era “Indigo”, está a ponto de mudar radicalmente a cara da programação distribuída para os desenvolvedores que usam o Microsoft .NET Framework. O WCF unifica a suíte existente de tecnologias distribuídas .NET, em um único modelo de programação, que aumenta a experiência dos desenvolvedores, através de uma arquitetura consistente, novos níveis de funcionalidade e interoperabilidade e todos os pontos de extensibilidade que poderíamos desejar. Este artigo apresenta a programação WCF e mostra como começar a usá-la.
Nota: Este artigo é baseado em uma versão pré-release do WinFX e todos os aspectos aqui discutidos estão sujeitos à mudanças.
Como sugere o nome, o WCF provê ao .NET Framework uma base para escrever código que permita a comunicação entre componentes, aplicações e sistemas. O WCF foi projetado de acordo com os princípios de orientação a serviços. Um serviço é um trecho de código que interage através de mensagens. Serviços são passivos, eles aguardam a entrada de mensagens antes de executar qualquer trabalho. Os clientes são os iniciadores, eles enviam mensagens para os serviços para requisitar trabalho.
Os serviços expõem um ou mais endpoints para onde podem ser enviadas as mensagens. Cada endpoint consiste em um endereço, uma ligação (binding) e um contrato (Figura 1). O endereço especifica para onde enviar as mensagens, a ligação descreve como enviar as mensagens e o contrato descreve o que as mensagens contêm. Os clientes precisam ter conhecimento dessa informação, antes de poder acessar um serviço.
Figura 1. Serviços e Endpoints
Os serviços podem compartilhar descrições sobre endpoints para disponibilizar aos clientes, tipicamente usando a Web Services Description Language (WSDL). A seguir, os clientes podem usar a descrição de serviço fornecida, para gerar código dentro do ambiente, capaz de enviar e receber as mensagens apropriadas (Figura 2).
Figura 2. Compartilhando Descrições de Endpoint
O Windows Communication Foundation provê uma nova biblioteca de classes contidas no namespace System.ServiceModel, que implementam esses conceitos orientados a serviço. Isso é tipicamente conhecido como o modelo de programação WCF.
Com o WCF, podemos escrever serviços que expõem endpoints ou escrever clientes que interagem com endpoints. Conseqüentemente, os endpoints ocupam uma posição central no modelo de programação e na infra-estrutura do WCF. O modelo de endpoints do WCF, junto com as classes e interfaces .NET, são mostradas na Tabela 1. Esse mapeamento é verdadeiro tanto para escrever clientes quanto serviços para o WCF.
|
Elemento |
Classe ou Interface |
|
Endpoint |
System.ServiceModel.ServiceEndpoint |
|
Endereço(Address) |
System.Uri |
|
Ligação(Binding) |
System.ServiceModel.Binding |
|
Contrato(Contract) |
Interfaces assinadas com o atributo System.ServiceModel |
Tabela 1. Classes e Interfaces do WCF
Ao construir um serviço WCF, tipicamente começamos especificando uma definição de interface .NET a ser utilizada como contrato de prestação de serviços. Então implementamos o contrato de prestação de serviços dentro de uma classe .NET, conhecida como o tipo serviço (service type) e configuramos seu comportamento. A seguir, definimos os endpoints que o serviço irá expor, especificando o endereço, a ligação e o contrato para cada um. Finalmente, hospedamos o serviço em uma aplicação, usando a infra-estrutura de hospedagem do WCF. Uma vez que o serviço foi hospedado, os clientes podem recuperar suas descrições de endpoint e podem começar a interagir com o mesmo.
Ao construir um cliente WCF, precisamos, em primeiro lugar, a descrição do endpoint alvo que desejamos acessar. A descrição do endpoint pode ser usada para criar dinamicamente uma classe proxy. O WCF provê uma ferramenta chamada SvcUtil.exe para automatizar esse processo. Assim, podemos escrever o código para a classe proxy, a fim de acessar o serviço, enviando as mensagens apropriadas ao endpoint alvo.
Os contratos de prestação de serviços e o comportamento de despacho
Modelamos os contratos de prestação de serviços dentro do .NET, usando as definições de interface tradicionais do C#. Podemos usar qualquer interface .NET como ponto de partida, tal como a mostrada a seguir:
namespace ServiceLibrary
{
public interface IEchoService
{
string Echo(string msg);
}
}
Para realizar esse contrato de prestação de serviços WCF, temos que denotar a própria interface com o atributo [ServiceContract] e cada operação que desejamos expor com [OperationContract]:
using System.ServiceModel;
namespace ServiceLibrary
{
[ServiceContract(Namespace = "http://example.org/echo/")]
public interface IEchoService
{
[OperationContract]
string Echo(string msg);
}
}
Esses atributos influenciam o mapeamento entre os mundos .NET e SOAP. O WCF usa a informação contida no contrato de prestação de serviços para executar o despacho e a serialização. O despacho é o processo de decidir qual método chamar para uma mensagem SOAP de entrada. A serialização é o processo de mapear entre os dados contidos em uma mensagem SOAP e os correspondentes objetos .NET usados na invocação do método. Esse mapeamento é controlado pelos dados do contrato da operação.
O WCF faz o despacho baseado na ação da mensagem. Para cada método em um contrato de prestação de serviços, é automaticamente designado um valor de ação, baseado no namespace do serviço e no nome do método. Por exemplo, a ação padrão para o método Echo mostrado anteriormente, é http://example.org/echo/Echo. Podemos personalizar o valor de ação para cada método, usando [OperationContract]. Um valor * pode ser usado para qualquer ação, quando não existir uma correspondência específica.
No exemplo a seguir, o WCF despachará mensagens com uma ação urn:echo:string ao método Echo. Mensagens com qualquer outra ação, são despachadas ao método EchoMessage:
[ServiceContract(Namespace = "http://example.org/echo/")]
public interface IEchoService
{
[OperationContract(Action = "urn:echo:string")]
string Echo(string msg);
[OperationContract(Action = "*")]
Message EchoMessage(Message msg);
}
Dados de contrato
Uma vez que o método alvo tenha sido determinado baseado na ação, o WCF confia nos dados de contrato do método para executar a serialização. Os dados do contrato são definidos pelos tipos usados na assinatura do método. No exemplo anterior, EchoMessage é genérico e poderia ser usado para processar uma gama de mensagens SOAP de entrada. Portanto, usamos Message para modelar a entrada e a saída. Message é um tipo especial usado para representar todas as mensagens que fluem pelo WCF. Ao usar Message, o WCF não executa a serialização baseada em tipo. Em lugar disso, apenas dá acesso direto ao conteúdo da mensagem SOAP.
Quando Message não for usada, o WCF executa serialização para mapear entre os dados contidos na mensagem SOAP e os correspondentes objetos .NET necessários para invocar o método. Por exemplo, no caso de Echo, o WCF mapeia a carga SOAP para um string do .NET. O WCF provê um mapeamento implícito para todos os tipos primitivos do .NET Framework (string, int, double etc.).
O modo como o WCF serializa classes .NET depende do mecanismo de serialização em uso. O mecanismo de serialização padrão é conhecido como DataContract, uma versão simplificada de XmlSerializer, atualmente o padrão usado no ASMX. ...
