Faça o download do arquivo.

A Microsoft disponibiliza várias tecnologias para o desenvolvimento de aplicações distribuídas. Cada uma delas é voltada para uma necessidade específica, e entre essas tecnologias temos: ASP.NET Web Services, WSE - Web Services Enhancements, .NET Remoting, COM+ - Enterprise Services e MSMQ - Message Queue. Cada uma delas possui sua própria API, com vários tipos que devem ser estudados para que possamos desenvolver uma aplicação que exponha ou consuma recursos destas tecnologias.

Quando iniciou a criação do .NET Framework 3.0, um entre quatro dos grandes pilares que havia dentro dele era o Indigo que mais tarde recebeu o nome de Windows Communication Foundation, ou simplesmente WCF. O WCF unificou as várias tecnologias de programação distribuídas na plataforma Microsoft em um único modelo, baseando-se na arquitetura orientada à serviços (SOA). Essa nova API facilita consideravelmente o aprendizado e desenvolvimento, já que o WCF está totalmente desacoplado das regras de negócios que serão expostas pelo serviço. A finalidade deste artigo é mostrar uma introdução ao WCF, construindo passo-à-passo um exemplo simples de como criar e consumir um serviço.

Para começar a fazer uso do WCF, tudo o que precisamos é referenciar em nossa aplicação o assembly System.ServiceModel.dll. Esse assembly possui a maioria dos tipos necessários para a construção de um serviço ou de um cliente. Ainda há outros assemblies que complementam o WCF, como é o caso do suporte à serviços baseados em REST, mas que serão abordados em artigos específicos.

Estrutura

A estrutura de um serviço WCF não é muito complexa, pois devemos utilizar conceitos puros de programação .NET para a criação do contrato e da classe que representará o serviço. Além disso, o WCF também suporta a utilização de tipos complexos, como classes que criamos para atender uma determinada necessidade.

O primeiro passo na criação do serviço é a definição do contrato. É o contrato que determinará quais operações estarão expostas, quais informações essas operações necessitam para ser executadas e também qual será o tipo de retorno. O contrato nada mais é que uma Interface que, por sua vez, deverá possuir os métodos (apenas a sua assinatura) que serão expostos. A Interface que servirá como contrato deverá ser obrigatoriamente decorada com o atributo ServiceContractAttribute pois, caso contrário, uma exceção do tipo InvalidOperationException será disparada antes da abertura do host.

Nem sempre todos os membros expostos pela Interface devem ser expostos para o serviço e, justamente por isso, todas as operações que serão disponibilizadas devem ser decoradas com o atributo OperationContractAttribute. Vale lembrar que o WCF obriga a termos no mínimo uma operação definida com este atributo, já que não faz sentido publicar um serviço que não tenha nenhuma operação a ser executada. Caso a Interface não possua nenhuma operação definida com este atributo, uma exceção do tipo InvalidOperationException também será disparada antes da abertura do host. O código abaixo exibe uma Interface simples, que servirá como exemplo para o artigo:

using System;
using System.ServiceModel;

[ServiceContract]
public interface IContrato
{
    [OperationContract]
    Usuario RecuperarUsuario(string nome);
}

Imports System
Imports System.ServiceModel

<ServiceContract()> _
Public Interface IContrato
    <OperationContract()> _
    Function RecuperarUsuario(ByVal nome As String) As Usuario
End Interface

using System;
using System.Runtime.Serialization;

[DataContract] //Opcional com .NET 3.5 + SP1
public class Usuario
{
    [DataMember] //Opcional com .NET 3.5 + SP1
    public string Nome { get; set; }
}

Imports System
Imports System.Runtime.Serialization

<DataContract()> _ 'Opcional com .NET 3.5 + SP1
Public Class Usuario
    Private _nome As String

    <DataMember()> _ 'Opcional com .NET 3.5 + SP1
    Public Property Nome() As String
        Get
            Return Me._nome
        End Get
        Set(ByVal value As String)
            Me._nome = value
        End Set
    End Property
End Class

using System;

public class Servico : IContrato
{
    public Usuario RecuperarUsuario(string nome)
    {
        return new Usuario() { Nome = nome };
    }
}

Imports System

Public Class Servico
    Implements IContrato

    Public Function RecuperarUsuario(ByVal nome As String) As Usuario _
        Implements IContrato.RecuperarUsuario

        Return New Usuario() With {.Nome = nome}
    End Function
End Class

using System;
using System.ServiceModel;

using (ServiceHost host = new ServiceHost(typeof(Servico),
    new Uri[] { new Uri("net.tcp://localhost:9393") }))
{
    //endpoints

    host.Open();
    Console.ReadLine();
}

Imports System
Imports System.ServiceModel

Using host As New ServiceHost(GetType(Servico), _
    New Uri() {New Uri("net.tcp://localhost:9393")})

    'endpoints

    host.Open()
    Console.ReadLine()
End Using

Figura 1 - Estrutura de um endpoint.