Arquivo

Archive for the ‘WCF’ Category

WCF: Configurar o IIS para trabalhar com protocolo TCP IP

O WCF trabalha com várias formas de comunicação, o TCP IP é uma das formas. Nesse artigo vou mostrar como configurar o IIS para trabalhar com o WCF com o protocolo TCP IP. (para entender esse artigo é necessário ter conhecimentos básicos em WCF).

Primeira informação importante é saber que apenas o IIS 7 permite hospedagem do protocolo TCP IP.

A seguir precisamos verificar se o .Net Framework está configurado para aceitar trabalhar com protocolos. Para habilitar acesse Painel de Controle\Programas e Recursos\Ativar ou desativar recursos do Windows.

Procure na janela de Recurso do Windows a opção Microsoft.NET Framework 3.5.1. Expanda essa opção e você verá duas opções conforme a imagem abaixo:

A primeira opção é WCF HTTP Activation. Essa opção deve estar selecionada para que o IIS trabalhe com cenários HTTP. A segunda opção é WCF Non-HTTP Activation. Essa opção deve estar selecionada para que o IIS trabalhe com cenário não HTTP, no nosso caso para que trabalhe com TCP IP.

Marque as duas opções, clique no botão OK e aguarda a instalação.

Após a instalação vamos acessar o IIS, ele está disponível em Painel Controle\Ferramenta Administrativa\Gerenciador do Serviços de Informações da Internet (IIS).

Com o IIS aberto, podemos agora publicar nosso serviço no Default Web Site e utilizar o WCF com protocolo TCP IP. Vamos criar um serviço básico para utilizar com o TCP IP.

Abra o Visual Studio e crie um projeto do tipo WCF Service Application. Não precisamos mudar nada no projeto apenas marque o arquivo Service1.svc para inicializar o projeto, vamos utilizar os serviços disponibilizados por padrão pelo projeto. Agora é necessário publicar o serviço. Crie uma pasta no C:\ chamada WCF_TCPIP, no Visual Studio clique com o botão direito no mouse no projeto e em “Publish”, publique o projeto na pasta que criamos. Veja na imagem abaixo a tela de publicação.

Com o serviço publicado, volte para o IIS clique com o botão direito do mouse em Default Web Site e em adicionar aplicativo. Faça as configurações do nosso projeto conforme a imagem abaixo:

Definimos uma alias para nosso projeto, um pool de aplicativo (lembre-se de usar um pool que utilize o mesmo framework da sua aplicação, no meu exemplo estou usando um pool feio por mim, mas você pode utilizar o DefaultAppPool) e o caminho físico. Clique no botão OK.

Em seguida clique na opção pesquisa no diretório, do seu lado direito clique na opção habilitar.

Pronto, agora vamos testar. Clique do lado direito em Procurar e veja se sua aplicação está rodando.

Com o serviço funcionando, vamos agora configura-lo para trabalhar com protocolo TCP IP. No IIS, selecione Default Web Site e do lado direito clique em ligações (ou bindings em inglês). Na janela Ligações do Site, verifique se o protocolo net.tcp está configurado. Caso não esteja, vamos configurar. Clique no botão Adicionar, em tipo selecione net.tcp e em informações de ligações coloque 808:*. Dessa forma nossa comunicação com o serviço em TCP IP irá ocorrer com a porta 808 e o último numero fica a critério do IIS. Você pode trabalhar com outra numeração se quiser, mas tome cuidado. Você utilizar uma porta que já esteja em uso por outra aplicação. Clique em OK.

Agora clique no aplicativo WCF_TCPIP e no mesmo menu do lado direito procure por “Configurações Avançadas” a janela como mesmo nome será exibida. Procure a opção Protocolos Habilitados. Ele deve estar configurado apenas com o protocolo http, vamos altera-lo e adicionar o protocolo net.tcp (não apague o http) ele deve ficar assim: http,net.tcp (não coloque espaço entre http, a virgula, e o net.tcp ou um erro irá ocorrer quando tentamos acessar o serviço).

Pronto nosso serviço está atualizado no IIS para protocolo TCP IP, agora vamos fazer um teste? Vamos criar um projeto Web Site, fazemos referência a esse serviço (utilizando o endereço HTTP que tem o xml do WSDL) . Ao adicionarmos essa referencia, nosso web.config irá exibir dois endpoint, um HTTP e outro TCP IP. Apague o endpoint HTTP senão teremos um erro ao acessar o serviço avisando que existem dois endereços para o mesmo serviço.

Na minha aplicação Web Site de teste, coloquei um botão e uma label e no evento click do botão coloquei o seguinte código:

WCFService.Service1Client proxy = null;

        try
        {
            proxy = new WCFService.Service1Client();

            this.lblTeste.Text = proxy.GetData(10);
        }
        catch (Exception ex)
        {
            this.lblTeste.Text = ex.Message;
        }
        finally
        {
            if (proxy != null &&
                proxy.State == System.ServiceModel.CommunicationState.Opened)

                proxy.Close();
        }

A label deve exibir: You entered: 10.

Obrigado pessoal e até a próxima.

Categorias:WCF Tags:, ,

WCF – Retorno de coleções

Quando trabalhamos com WCF, podemos definir como será o retorno das coleções na aplicação client. Por padrão o retorno é do tipo Array, pois normalmente outras linguagens de programação trabalham com o mesmo tipo. Caso você queria trocar a forma de retorno é simples.

Clique com o botão direito do mouse sobre seu serviço e acesse a opção “Configure Service References”. Uma janela será aberta. Veja a opção “Collection Type” está marcada como “System.Array”. Você pode alterar para ArrayList ou um Generic.List por exemplo. E assim seu retorno será alterado. Veja a imagem abaixo a opção que deve ser alterada.

Obrigado e até a próxima.

Categorias:WCF Tags:

Gerenciamento de Instância no WCF

Olá a todos.

Esse artigo irá falar sobre gerenciamento de instância no WCF e para que você possa entender esse artigo é necessário ter um conhecimento básico em WCF.

Existem três formas de realizar requisições através de um serviço WCF. Essas formas são conhecidas como gerenciamento de instancia e ajudam a melhorar o desempenho e a segurança do WCF.

Antes de explicar cada gerenciamento de instância, vou mostrar abaixo o código fonte que vamos utilizar para os exemplos. Lembre-se é recomendado ter conhecimento em WCF.

Vamos utilizar um projeto Console. Primeiro vamos criar a seguinte Interface:

[ServiceContract]
public interface IContrato
{
    [OperationContract]
    int Contador();
}

Em seguida uma classe que é herdada dessa Interface com a implementação do método Contador:

[ServiceBehavior(InstanceContextMode=InstanceContextMode.PerSession)]
public class Contrato: IContrato
{
    private int _intContador;

    public int Contador()
    {
        return _intContador++;
    }
}

Em Program.cs no método Main digite o seguinte código:

using (ServiceHost host = new ServiceHost(typeof(Contrato), new Uri[] { new Uri("net.tcp://localhost:9393") }))
{
    host.Description.Behaviors.Add(new ServiceMetadataBehavior());
    host.AddServiceEndpoint(typeof(IContrato), new NetTcpBinding(), "srv");
    host.AddServiceEndpoint(typeof(IMetadataExchange), MetadataExchangeBindings.CreateMexTcpBinding(), "mex");

    host.Open();

    Console.WriteLine("[ O Serviço está rodando ]");

    Console.ReadLine();

    using (ChannelFactory<IContrato> f = new ChannelFactory<IContrato>(new NetTcpBinding(),               "net.tcp://localhost:9393/srv"))
{
    var channel = f.CreateChannel();
    for (int intContador = 0; intContador < 5; intContador++)
    {
        Console.WriteLine(channel.Contador().ToString());
    }

}

using (ChannelFactory<IContrato> f = new ChannelFactory<IContrato>(new NetTcpBinding(), "net.tcp://localhost:9393/srv"))
{
    var channel = f.CreateChannel();
    for (int intContador = 0; intContador < 5; intContador++)
    {
        Console.WriteLine(channel.Contador().ToString());
    }
}

Console.ReadLine();

Para esse exemplo estou criando o host e a chamada ao serviço em uma única aplicação, isso não é correto em um projeto, mas para um exemplo será útil. Depois de criar o host, crio dois proxy (instância do serviço) que  realizaram cinco requisições cada um.

Bem com esse código pronto vamos às explicações.

PerSession

Esse é a instância padrão do WCF. Quando a aplicação cliente cria uma proxy, esse proxy ira realizar todas as conexões com o serviço que o cliente chamar, até que o método Close (ou Dispose) seja chamado e o proxy seja encerrado. Enquanto o proxy não for fechado todas as alterações feita nos membros internos do serviço (como em uma propriedade global como no nosso exemplo em _intContador) será armazenada. Caso a aplicação cliente crie dois proxy , cada proxy irá controlar sua memoria, não interferindo um proxy no outro.

Como já escrevi, o PerSession é a instancia default do WCF, nesse caso não precisamos informá-la quando desejamos utilizar, mas em nosso exemplo vamos especificar. Vamos dizer ao WCF para trabalhar com PerSession na classe do serviço (no nosso exemplo na classe Contrato), como exemplo abaixo:

[ServiceBehavior(InstanceContextMode=InstanceContextMode.PerSession)]

Ao executar nosso exemplo temos o seguinte resultado:

A propriedade _intContador é incrementada sempre que o proxy é chamado, porém quando o proxy é finalizado e uma novo proxy é criado, o _intContador começa do zero (propriedade int por padrão começa com valor zero), pois a instância anterior foi perdida.

PerCall

Diferente do PerSession o PerCall cria uma nova requisição do proxy, ou seja, quando a operação é finalizada o proxy é removido da memoria.  Para utilizarmos o PerCall precisamos alterar na classe Contador o InstanceContextMode conforme exemplo abaixo:

[ServiceBehavior(InstanceContextMode=InstanceContextMode.PerCall)]

Ao executar nosso exemplo após a alteração, temos o seguinte resultado:

O resultado sempre será zero porque, apesar de realizar N requisições ao serviço a propriedade _intContador não é incrementada.

Single

Single tem uma maneira diferente de se comportar. Existir apenas uma única instancia do proxy que ira servir para todas as requisições, mesmo que o Close ou Dispose sejam chamados ou que um novo objeto proxy seja criado. Para utilizarmos o Single precisamos alterar na classe Contador o InstanceContextMode conforme exemplo abaixo.

[ServiceBehavior(InstanceContextMode=InstanceContextMode.Single)]

Mesmo descartando o primeiro proxy, quando começamos a utilizar o segundo proxy o _intContador continua sendo incrementando com o valor que foi finalizado pelo primeiro proxy, conforme podemos ver na imagem abaixo:

Você deve-se perguntar qual é a melhor? Isso depende, ninguém melhor do que você para decidir qual tipo de gerenciamento de instância é a melhor para a sua solução. Só devemos tomar cuidado porque a instância está ligada ao binding, ou seja, nem todos os binding (como BasicHttpBinding) suportar esse exemplo que implementamos.

O código fonte desse exemplo está disponível aqui.

Espero que tenham gostado e até a próxima.

Obrigado.