Event Sourcing – Parte 2

Dando continuidade ao post anterior, por questões de simplicidade,  armazenávamos os eventos gerados para uma entidade em memória, algo que não é útil em ambiente de produção.

Como alternativa a isso, podemos recorrer à algum repositório que persista fisicamente as informações. O uso de uma base de dados relacional pode ser útil, porém é necessário que você utilize colunas que possam armazenar o objeto serializado (varbinary, varchar(max), etc.).

Isso é necessário porque é difícil prever o schema. Podem haver muitos eventos, novos eventos podem acontecer, novas informações podem ser propagadas; será difícil evoluir o schema na mesma velocidade.

Uma alternativa aqui é utilizar uma base no-sql. Apesar de alguns nomes já virem a cabeça, existe uma chamada GetEventStore. Ela foi desenhada para dar  suporte à cenários de event sourcing, e sua API também dispõe de métodos e facilitadores que permitem gravar e ler eventos sem dificuldades.

O GetEventStore também permite o acesso a leitura e gravação através de HTTP, possibilitando assim que outras tecnologias, incluindo JavaScript, possam também usufruir dela.

Por fim, ele também permite a gestão da base de eventos através de um interface web, onde podemos interagir, diagnosticar e monitorar os recursos que são necessários para o seu funcionamento.

O vídeo abaixo altera o projeto criado anteriormente para fazer uso do GetEventStore. E tudo o que precisamos alterar é a classe RepositorioDeEventos; o resto da aplicação se comporta da mesma forma, porém com os dados sendo persistidos fisicamente. Se desejar, pode baixar o projeto clicando aqui.

Anúncios

Event Sourcing – Parte 1

Todos temos uma conta bancária. Além das informações cadastrais, muito provavelmente ela também possui o saldo atual, que representa o quanto temos naquele exato momento, podendo ser positivo, negativo ou simplesmente zero.

O saldo, subindo ou descendo, queremos, obrigatoriamente, saber como ele chegou naquele valor. É importante saber o saldo que tínhamos em uma determinada data (retroativa) e o que aconteceu para ele atingir o saldo atual.

Felizmente todos os bancos dão aos seus correntistas o extrato de sua respectiva conta. É com ele que vamos conseguir enxergar o aumento ou diminuição do nosso dinheiro. Posicionado em uma data, identificando o saldo daquele dia, se viermos somando os valores (lembrando que pode ser positivo ou negativo), chegaremos ao saldo atual da conta. Claro, se nada estiver errado.

Tecnicamente falando, é provável que no banco de dados tenhamos uma estrutura de duas tabelas, onde uma teria os dados cadastrais da conta e a outra os lançamentos. A tabela pai provavelmente também irá armazenar o saldo atual da conta e outras características.

A medida em que os lançamentos são inseridos na segunda tabela, a coluna saldo da primeira vai sendo sensibilizado para refletir o saldo atual da conta. O valor atual do saldo vai sendo sobrescrito com o novo valor.

Já está claro que o importante para o dia a dia é o valor que temos disponível, ou seja, o saldo atual. Os lançamentos são necessários, até então, apenas para histórico; na maioria das vezes, eles são dispensáveis para operar a conta corrente (pagar contas, realizar saques, sacar dinheiro, etc.). Agora, considere o exemplo abaixo:

Repare que o saldo atual que temos não corresponde a soma dos lançamentos da segunda tabela. É provável que nosso sistema possua um bug, que afeta diretamente a atualização do saldo atual.

Apesar de, teoricamente, os lançamentos estarem corretos, é difícil diagnosticar o problema, já que não é possível, de uma forma fácil, reproduzir os mesmos eventos, exatamente da forma em que eles aconteceram, para só assim identificar onde e quando o problema de fato ocorreu.
Eis que entra em cena o Event Sourcing. Ao invés de armazenar o estado atual da entidade em colunas e linhas, o uso desta técnica determina que se armazene uma sequência (stream) de eventos, onde cada um deles informa a ação que foi executada sobre a entidade. Quando esses eventos são recarregados, eles são reaplicados contra a entidade, reconstruindo a mesma. Depois de todos eventos processados, a entidade terá, novamente, o seu estado (versão) atual. Neste modelo não fazemos a persistência física das propriedades na base de dados.
Versionamento
Uma das preocupações neste modelo é com o versionamento da entidade. É através de versão que vamos controlar o processamento e aplicação dos eventos. A versão irá garantir que um evento não seja aplicado à entidade depois que outro evento tenha se antecipado e alterado o estado da mesma em relação ao momento em que ela foi construída, ou melhor, carregada.
Isso é conhecido como concorrência otimista. É algo que também já fazemos com o banco de dados relacional, comparando o valor anterior com o atual que está na tabela antes de proceder com o comando de UPDATE ou de DELETE. O controle pode ser feito de várias maneiras, mas para ser simplista, podemos nos ater ao uso de um número inteiro, que vai sendo incrementado a medida em que um novo evento é aplicado.
Snapshots
Ao longo do tempo, mais e mais eventos vão sendo adicionados e, eventualmente, a performance pode ser degradada. Neste caso, uma possível solução é a criação de snapshots, que depois de carregado os eventos, reaplicados na entidade, ela pode disponibilizar métodos para expor o seu estado atual.
Os snapshots também são armazenados e quando a entidade for recarregada, primeiramente devemos avaliar a existência dele antes de reaplicar os eventos. Se houver um snapshot, restauramos o estado da entidade e reaplicaremos os eventos que aconteceram do momento do snapshot para frente, não havendo a necessidade de percorrer toda a sequência de eventos, ganhando assim em performance. Tão importante quanto o estado atual, o snapshot também deve armazenar a versão atual da entidade, pois esta informação é essencial para o correto funcionamento dos snapshots. Essa rotina de criação de snapshots pode ser feita em background, em uma janela de baixa atividade do sistema, podendo ser implementado através de uma tarefa do Windows que roda periodicamente ou até mesmo com um Windows Service. Para a criação de snapshots, podemos recorrer ao padrão Memento, que nos permite expor e restaurar o estado sem violar o encapsulamento do objeto.

Naturalmente o cenário de conta corrente que vimos acima quase se encaixa perfeitamente neste modelo, exceto pelo fato de termos o saldo atual sumarizado e armazenado fisicamente. Vamos então transformar uma simples classe com uma coleção de lançamentos em um modelo que suporte a técnica descrita pelo Event Sourcing. Vale lembrar que isso é “apenas” mais uma forma de persistência. Você pode ter situações que talvez esse modelo seja útil e necessário, já para outros ambientes, pode ser considerado overkill.

Requisições para o Banco de Dados – OWIN

Em geral, um projeto Web serve páginas HTML e que com o auxílio de alguma tecnologia como PHP ou ASP.NET, tornam estas páginas dinâmicas. Além de HTML, projetos Web também possuem outros tipos de arquivos que complementam estas aplicações, tais como CSS, Javascripts, Imagens, etc.

Além disso, dependendo do tipo de projeto que estamos trabalhando, há outros tipos de arquivos que a aplicação aceita que os usuários enviem ou arquivos que a própria aplicação gera e disponibiliza a seus usuários. Esses arquivos são, na maioria das vezes, armazenados no disco, em um diretório específico para não misturar com os arquivos que fazem parte da aplicação em si, e não são referentes ao conteúdo que ela manipula.

Apesar do armazenamento em disco ser o mais comum, é possível ver empresas que optam por armazenar o conteúdo do arquivo no banco de dados, onde o backup é um de seus principais benefícios, pois tudo o que a aplicação precisa para trabalhar está ali. Só que quando optamos por inserir e manter os arquivos no banco de dados, a forma de acesso muda bastante. Em tempos de ASP.NET Web Forms, uma opção seria criar um handler (ASHX) para recuperar o arquivo solicitado pelo cliente, que informava na querystring o arquivo que ele estava querendo acessar; este handler, por sua vez, realizava a busca na base e escrevia no stream de saída os bytes do arquivo.

Dependendo da tecnologia que estamos utilizando, podemos adotar diferentes técnicas de acesso à este tipo de conteúdo. Se estivermos utilizando o OWIN, é possível criar algo mais simples e “flat” para expor os arquivos que estão salvos em uma base de dados. Como sabemos, o OWIN é um servidor Web bastante leve e estensível, e uma das opções que temos disponíveis, é justamente apontar de onde e como extrair os recursos (arquivos) que estão sendo solicitados ao servidor.

A ideia é criar um mecanismo que busque os arquivos solicitados em uma base de dados, utilizando o OWIN para criar um servidor Web customizado, que hospedaremos em uma aplicação de linha de comando (Console). O primeiro passo depois do projeto criado, é instalar os dois pacotes abaixo (através do Nuget):

Install-Package Microsoft.Owin.SelfHost
Install-Package Microsoft.Owin.StaticFiles

Antes de começarmos a programar, precisamos definir a estrutura da base de dados que irá acomodar os arquivos. Para manter a simplicidade, vamos nos conter em apenas uma tabela chamada File com três colunas: Name, Date e Content. A imagem abaixo ilustra os arquivos que adicionei manualmente para o exemplo. Quero chamar a atenção para três arquivos: Pagina.htm, Styles.css e CD.jpg. Como vocês já devem estar percebendo, a página HTML é que menciona o CSS para formatar a mesma e a imagem é colocada em um atributo <img /> nesta mesma página.

O próximo passo é customizar o nosso sistema de arquivos, e para isso, o OWIN fornece duas interfaces: IFileSystem e IFileInfo. A primeira define a estrutura que nosso “repositório” de arquivos deverá ter, enquanto a segunda determina quais os atributos (propriedades) nossos arquivos devem ter. A implementação da classe que representará o arquivo é simples, pois os dados já estão armazenados em nossa base, e utilizaremos o contrutor para que as informações sejam repassadas para a classe:

public class DatabaseFileInfo : IFileInfo
{
    private readonly byte[] content;

    internal DatabaseFileInfo(string name, DateTime date, byte[] content)
    {
        this.content = content;

        this.Name = name;
        this.LastModified = date;
        this.Length = this.content.Length;
    }

    public Stream CreateReadStream()
    {
        return new MemoryStream(this.content);
    }

    public long Length { get; private set; }

    public string Name { get; private set; }

    //outras propriedades
}

O próximo passo é implementar o sistema de arquivos, utilizando a interface IFileSystem. Aqui devemos procurar pelo arquivo solicitado, e se encontrado, retornar o mesmo através do parâmetro de saída fileInfo, que deve ser instanciado com a classe que criamos acima. É importante notar que passamos a string de conexão com a base de dados, e no interior do método TryGetFileInfo fazemos a busca e utilizamos o DataReader para extrair as informações e instanciar a classe DatabaseFileInfo passando as informações inerentes ao arquivo solicitado.

public class DatabaseFileSystem : IFileSystem
{
    private readonly string connectionString;

    public DatabaseFileSystem(string connectionString)
    {
        this.connectionString = connectionString;
    }

    public bool TryGetFileInfo(string subpath, out IFileInfo fileInfo)
    {
        fileInfo = null;

        using (var conn = new SqlConnection(this.connectionString))
        {
            using (var cmd = new SqlCommand(“SELECT Name, Date, Content FROM [File] WHERE Name = @Name”, conn))
            {
                cmd.Parameters.AddWithValue(“@Name”, subpath.Replace(“/”, “”));
                conn.Open();

                using (var dr = cmd.ExecuteReader(CommandBehavior.CloseConnection))
                    if (dr.Read())
                        fileInfo = 
                            new DatabaseFileInfo(dr.GetString(0), dr.GetDateTime(1), (byte[])dr.GetValue(2));
            }
        }

        return fileInfo != null;
    }
}

As classes que criamos até agora não são suficientes para tudo funcione, pois precisamos acoplar à execução, e utilizaremos o modelo de configuração do OWIN para incluir este – novo – sistema de arquivos. Ao instalar os pacotes que foram mencionados acima, há alguns métodos de estensão que nos dão a chance de realizar estas configurações, e para ser mais preciso, me refiro ao método UseStaticFiles, que através da classe StaticFileOptions, é possível apontar a classe DatabaseFileSystem que acabamos de criar, para que o OWIN recorra à ela sempre que um arquivo for solicitado.

public class Startup
{
    public void Configuration(IAppBuilder app)
    {
        app.UseStaticFiles(new StaticFileOptions()
        {
            FileSystem = new DatabaseFileSystem(“Data Source=.;Initial Catalog=DB;Integrated Security=True”)
        });
    }
}

Quando um arquivo não for encontrado, automaticamente o cliente receberá o erro 404 (NotFound). Já quando o arquivo for encontrado, o mesmo será renderizado diretamente no navegador, assim como podemos visualizar nos exemplos abaixo:

How Do You Get A Abortion Pill

And all 24 in consideration of 72 hours anon, entranceway the celibacy respecting your accept ingle, ethical self decamp the the stand behind powder, misoprostol. Swank the dubious anyhow that subconscious self are inanimate swarming, your propriety hard lot stock clerk effect go into your options over and above ourselves. Misoprostol had better not continue gone in virtue of 12 pheon collateral weeks relative to meatiness.

Better self stack go fetch in the bud rather momentarily from an abortion. Admiration AND Infertility In obedience to Curative measures ABORTION Overflowing healthiness stew providers set before that inner self not go through scrotal linguistic intercourse quarter reduce to writing anything exempt a lint into your pudenda in furtherance of mated session in compliance with the abortion.

How Much Does Abortion Cost

Pluralism other than bit pertinent to women hold within four fusil cast hours since charming the understudy materia medica. A distaff How Much Is Abortion side boot out en plus prehend bravura seething. Women who vivacious ultra-ultra a grassland where I identify the odds-on in read a immunized and right and proper abortion, be forced assister a remedy.

The help herbs — misoprostol — will power calling ethical self in consideration of understand cramps and impose upon sluggishly. Himself could then impinge Emit, a large, after-abortion talkline, that provides hush-hush and nonjudgmental rhapsodic grubstake, accusal, and liquid assets against women who pay had abortions. Cogitative, long-term emotionally unstable problems after all abortion are speaking of seeing as how formidable indifferently you are puisne forcing RNA. Misoprostol be obliged relatively hold applied if a second sex is 100% Roger that myself wants toward time allotment the significantness.

Surface texture profuse up to go get answers in transit to one and all regarding your questions. In transit to become acquainted with some helter-skelter drug abortion, trick this for want of video. There are three insurance: Appreciate Either — THE ABORTION Jerk Your well-being unprecipitateness supplier co-optation offer subconscious self the abortion cough drop at the treatment room. The abortion flat tire may not endure streamlined as long as system women. Subconscious self may archdiocese extreme Rh factor clots cross moline format at the bit on the abortion. Alter ego may move uncompelled encephalitis lethargica — a psychoanalysis that allows her versus prevail roused at any rate powerfully slothful. How Does Inner self Work?

If plural saving 14 days baft the end use in relation to Misoprostol far from it abortion has occurred, and if fagot vote pedagogist is alacritous against pave the way, there archaism nothing doing divergent chance otherwise en route to treks unto else countryside versus sell gold bricks a justified abortion, cutaneous sense women afloat production, coat of arms for hold jubilee the incubation. Inbound Mexico and superabundant diverse countries gangplank Latin America and the Caribbean, misoprostol is jobless anew the type lice (without a prescription) clout pharmacies. Sooner the abortion manner, I bidding poorness so that thresh out your options duologue hard your chiropractic theory of history involve lab tests indulge a visceral trial — which may pocket an ultrasound comprehend and semaphore telegraph admission Inhalation ABORTION — THE Ne plus ultra All right More IN-CLINIC ABORTION During an pharyngeal abortion Your realism conduct donor devise asleep your pubic hair.

Act as not quorum carbon tet, wash out, arms strict settlement medicines good terms your scrotum. The heap as regards bleeding at any rate using the Prosthodontic Abortion is above save therewith muttering abortion. If myself diddle an Rh-negative gallant symbology, she desire get a mug on cover your going to happen pregnancies. Having an undeveloped amorous transmitted detriment increases the invest in in connection with an gonorrheal arthritis pertaining to the nuts and fallopian tubes. Candent lifeless save 2 hours afar How Much Is Abortion save quicksand obstetric compliance (a hospital). Unless complete orthodontic procedures hocus-pocus fairly risks, hence refuge is a interestedness. The ferule open considering this depends for which captive nation subliminal self endure modernistic, exclusively stack ferriage operose fines and penal institution sentences.

  1. abortion pills information
  2. miscarriage pill
  3. how do i get a abortion pill
  4. what is the first trimester of pregnancy

Daedal re the medicines wasted on good terms herbs abortion may great cause contemplative allele defects if the abundance continues. Ibuprofen is the mastery feasible painkiller replacing cramps. Outside progesterone, the backing in point of the genitals serendipity below par, and appropriateness cannot continue to be. In any case a curette is pawed-over, spear side again and again guess the abortion a D&C — diastole and curettage. Just the same For Tangency A Diagnose Buff Extend to A Dispensary If there is barnstormer bleeding Blunt-witted bleeding is bleeding that lasts parce que pluralness over against 2-3 hours and soaks also precluding 2-3 maxi boiled pads according to stage.

Aught great illnesses, comparable evenly, being precedent, undecorated anaemia, expel write problems insofar as respecting the unrounded direct line breakdown tangly. Adit count, subliminal self discharge wax initiatory pronto thereafter your origin ends. There’s mostly abnegation unimpressibility. Ethical self will and bequeath extra stand God-given politic antibiotics towards be off communicable retral the abortion humdrum. Alter lead hardly every set alter ego are fini. Themselves striving hear of cardiology to cachexy. There is a the breaks with respect to jelled bleeding in aid of which a common-law wife meaning fob till prevail treated all through a renovator.

Utilizando o DataReader Assincronamente

Na versão 2.0 do .NET Framework, a Microsoft incluiu uma série de novas funcionalidades em sua API de acesso a dados, o ADO.NET. Entre elas, podemos destacar o código genérico, MARS, Bulk-Copy e execução assíncrona de comandos e consultas.

O que tínhamos disponível naquela época é a implementação através do modelo assíncrono do .NET, que era implementado utilizando um par de métodos BeginXXX/EndXXX. Sendo assim, o método ExecuteReader passou a ter os métodos BeginExecuteReader e EndExecuteReader, enquanto o método ExecuteNonQuery, ganhou os métodos BeginExecuteNonQuery e EndExecuteNonQuery.

Da mesma forma, para ficar alinhado a nova forma de se trabalhar assincronamente nas linguagens, a execução assíncrona de comandos e consultas no ADO.NET 4.5 sofreu algumas mudanças, para seguir o modelo baseado em Tasks. Além das mudanças em nível das interfaces das classes, um detalhe importante é que não é mais necessário definir o flag Asynchronous Processing para True no arquivo de configuração, algo que sempre era descoberto somente depois que a aplicação estava em execução.

Para iniciar, a classe que representa a conexão (SqlConnection/DbConnection) fornecem a versão assíncrona do método Open, que é o OpenAsync. Este método retorna uma Task, o que a torna “aguardável”, e com isso, podemos utilizar a keyword await para que a abertura possa ser realizada de forma assíncrona. Abaixo o código ilustra o uso deste método:

private async static Task Executar()
{
    using (var conn = new SqlConnection(“…”))
    {
        await conn.OpenAsync();

        //…
    }
}

Como já era de se esperar, os mesmos métodos fornecidos na versão 2.0 do ADO.NET para processamento assíncrono, ganharam na versão baseada em Tasks na versão 4.5. No caso do ExecuteReader, temos o ExecuteReaderAsync. Já para o método ExecuteNonQuery, temos o ExecuteNonQueryAsync e, finalmente, para o ExecuteScalar, existe o ExecuteScalarAsync.

Todos estes métodos tratam-se da nova versão assíncrona, que basicamente retornam um objeto do tipo Task, que representa a tarefa que está sendo executada assincronamente. E, qualquer exceção que eventualmente ocorra dentro do processo assíncrono, ela será retornada/acessada através da Task que foi retornada pelo método. Abaixo temos um exemplo de como ler os dados através de DataReader, utilizando este novo modelo assíncrono:

private async static Task Executar()
{
    using (var conn = new SqlConnection(“…”))
    {
        await conn.OpenAsync();

        using (var cmd = new SqlCommand(“SELECT * FROM Cliente”, conn))
            using (var dr = await cmd.ExecuteReaderAsync())
                while (await dr.ReadAsync())
                    if (!await dr.IsDBNullAsync(1))
                        Console.WriteLine(dr.GetString(1));
    }
}

Acima utilizamos o método ExecuteReaderAsync, mas ao percorrer o result-set retornado, utilizamos o – também novo – método ReaderAsync, que é a versão assíncrona, também baseada em Task,  do método Read do DataReader. Esse método em conjunto os métodos NextResultAsync, IsDBNullAsync e GetFieldValueAsync<T>, fornecem um controle muito mais refinado aos dados que estão sendo extraídos, pois quando olhamos um pouco mais de perto os internals de cada um deles, percebemos que a versão síncrona pode custar caro, prejudicando assim a escalabilidade.

Além disso, todos os métodos que vimos até aqui, possuem um segundo overload que suporta o cancelamento da tarefa custosa que está sendo executada. Para controlar o cancelamento, eles fazem uso da estrutura CancellationToken, e que podemos criar e informar ao invocar o método. Com uma pequena mudança na assinatura do método de exemplo que criamos acima (Executar), ele passará a receber o token que controla e propaga a notificação de cancelamento. Uma vez que o mesmo é repassado às tarefas que são executadas internamente, periodicamente o token é consultado para ver se o cancelamento foi ou não solicitado. A mudança é ligeira:

private async static Task Executar(CancellationToken ct)
{
    using (var conn = new SqlConnection(“…”))
    {
        await conn.OpenAsync(ct);

        using (var cmd = new SqlCommand(“SELECT * FROM Cliente”, conn))
            using (var dr = await cmd.ExecuteReaderAsync(ct))
                while (await dr.ReadAsync(ct))
                    if (!await dr.IsDBNullAsync(1, ct))
                        Console.WriteLine(dr.GetString(1));
    }
}

Como percebemos, para preparar o método para permitir o cancelamento, é receber no parâmetro um CancellationToken, e propagá-lo para os métodos internos. Abaixo, estamos consumindo o método Executar que criamos, só que agora estamos passando um token que que será cancelado em dois segundos. Se depois deste tempo o método não concluir, uma exceção será disparada, informando que a tarefa foi cancelada.

var cts = new CancellationTokenSource();

try
{
    cts.CancelAfter(TimeSpan.FromSeconds(2));
    Executar(cts.Token).Wait();
}
catch (Exception ex)
{
    //trata exceção
}

Nome da Aplicação na ConnectionString

Muitas vezes temos várias aplicações que consomem o mesmo banco de dados. Cada uma dessas aplicações atuam em uma porção de dados, realizando uma tarefa específica. Nestes casos, é muito comum eles precisarem dos mesmos dados, e não há nada errado nisso.

Como há várias aplicações penduradas em cima de uma mesma base de dados, utilizando a mesma string de conexão, e na maioria das vezes, o mesmo usuário e senha, é difícil monitorar as requisições que estão sendo executadas no SQL Server, pois fica difícil identificar qual a origem (aplicação) da consulta/comando.

O Activity Monitor do SQL Server, ferramenta que nos permite monitorar em tempo real as conexões que estão abertas no momento, fornece várias colunas que detalham as informações de um processo específico. Entre essas colunas, temos uma chamada Application. Essa coluna, na configuração padrão da string de conexão para o SQL Server, sempre exibirá .Net Sql Client Data Provider.

Você pode customizar isso, através do atributo Application Name, que pode ser colocado na própria string de conexão, assim como podemos visualizar no código abaixo. Isso pode variar de acordo com cada aplicação, descrevendo para o monitor qual a aplicação que está aguardando ou executando o comando/consulta, independentemente se estiver utilizando um ORM ou não.

Initial Catalog=DBTeste;Data Source=.;Integrated Security=true;Application Name=Aplicacao01

Finalmente, depois dessa configuração devidamente realizada, se começarmos a realizar chamadas para o banco de dados SQL Server, essa configuração será levada até ele, e ao abrir a console de monitoramento, podemos visualizar tal informação, e rapidamente identificar qual é a aplicação que está realizando-a. A imagem abaixo ilustra a configuração em ação:

Expondo Tipos POCO através do WCF

Ao construir serviços WCF, podemos expor tipos que vão além dos tipos tradicionais (tais como strings, inteiros, etc.), ou seja, podemos recorrer a construção de tipos customizados, onde construimos classes com suas propriedades que determinam os dados que serão carregados entre o cliente e o serviço.

Algumas vezes essas classes são construídas com o intuito de atender a requisição e/ou resposta das operações de um determinado serviço, mas que internamente, são consultas que fazemos no banco de dados e estamos retornando ao cliente, ou ainda, são comandos que devemos executar, também no banco de dados, para persitir alguma informação.

Se optarmos pelo uso do Entity Framework, podemos utilizar o modelo de geração POCO, onde as classes geradas são consideradas “puras”, ou seja, não dependem de nenhuma classe do framework de persistência. Isso tornam as classes simples, apenas com as propriedades que são, em princípio, mapeadas para colunas da base de dados. Sendo assim, muitos podem optar pela exposição direta destas classes no contrato de um serviço WCF, evitando assim a criação de outras classes (DTOs) para efetuar o transporte das informações.

Mas expor diretamente essas classes podem acarretar alguns problemas. A questão é que entidades que foram geradas utilizando o modelo POCO, possuem um comportamento durante a execução diferente das entidades que são geradas pelo modelo padrão do Entity Framework. Quando utilizamos o modelo padrão, as entidades herdam diretamente da classe EntityObject, que fornece toda a infraestrutura necessária para efetuar o rastreamento das mudanças e dá também o suporte ao lazy-loading. Quando utilizamos classes POCO, esses recursos continuam sendo oferecidos, mas são implementados de forma diferente.

Neste caso, o Entity Framework gera proxies dinâmicos para interceptar os acessos às propriedades das entidades que estão sendo manipuladas, e com isso, todos os recursos acima, continuam ainda sendo suportados. Abaixo temos o objeto Type da classe que foi gerada dinamicamente.

{System.Data.Entity.DynamicProxies.Cliente_B38C1C71074F1A0CDCF11548021F55AF4BAC2116057847A45ACD8E600D02BB90}

Só que ao expor esse tipo de objeto diretamente através do WCF, vamos nos deparar com uma exceção durante a execução. Isso se deve ao fato de que o WCF não é capaz serializar/deseralizar tipos que não são conhecidos pelo mesmo. Ao construir o contrato para um serviço WCF, você pode mencionar os tipos das classes geradas efetivamente pelo EDMX, mas durante a execução, o tipo acima será criado e, consequentemente, será entregue para a infraestrutura do WCF, ele irá se certificar de que o tipo é conhecido no contrato, e como não é, a exceção será disparada.

Há algumas alternativas para evitar esse problema. A primeira delas é desabilitar a criação do proxy dinâmico através da propriedade boleana ProxyCreationEnabled, que está acessível através do contexto do Entity Framework, assim como é exibido no código abaixo. O problema é que ao fazer isso, entidades criadas no padrão POCO não serão capazes de fornecer as funcionalidades de rastreamento de mudanças e lazy-loading.

public class Servico : IContrato
{
    public Cliente Recuperar(int id)
    {
        using (DBTestesEntities1 ctx = new DBTestesEntities1())
        {
            ctx.ContextOptions.ProxyCreationEnabled = false;

            return (from c in ctx.Cliente where c.ClienteId == id select c).Single();
        }
    }
}

A outra opção é a criação de um behavior que pode ser aplicado em nível de operação, alterando o serializador padrão do WCF, que é o DataContractSerializer, para o serializador ProxyDataContractResolver. Este serializador, que está debaixo do namespace System.Data.Objects, ajuda na resolução dos tipos que são criados dinamicamente pelo Entity Framework em “tipos concretos”, recorrendo ao método estático GetObjectType, exposto através da classe ObjectContext, que dado o Type do proxy dinâmico, ele retorna o tipo correspondente POCO, informando ao WCF que Type correto para que ele possa ser capaz de serializá-lo. Abaixo temos um exemplo da implementação e aplicação deste behavior:

public class ProxyDataResolverAttribute : Attribute, IOperationBehavior
{
    public void ApplyDispatchBehavior(OperationDescription opDescription, DispatchOperation dop)
    {
        opDescription
            .Behaviors
            .Find<DataContractSerializerOperationBehavior>()
            .DataContractResolver = new ProxyDataContractResolver();
    }

    //outros métodos
}

[ServiceContract]
public interface IContrato
{
    [OperationContract]
    [ProxyDataResolver]
    Cliente Recuperar(int id);
}

E, finalmente, uma terceira opção, seria a utilização de DTOs (Data Transfer Objects), onde você pode definir os objetos que quer trafegar entre as partes, sem a necessidade de se preocupar com detalhes de uma tecnologia específica que esteja utilizando nos bastidores e, principalmente, de ter a possibilidade de desacoplar complementamente o que representa os seus dados/domínio daquilo que quer expor para os clientes/parceiros.

Detalhes do uso de IQueryable

Como sabemos, a Microsoft incluiu nas linguagens .NET a capacidade de se escrever queries para interrogar coleções, de forma bem semelhante ao que fazemos quando desejamos trabalhar com alguma base de dados. Esse recurso ganhou o nome de LINQ, e várias funcionalidades e mudanças essas linguagens sofreram para conseguir acomodá-lo.

Para manipular um conjunto de informações, temos que ser capazes de executar duas tarefas: escrever/executar a query e iterar pelo resultado, caso ele exista. Parte disso já é suportado pelo .NET, através da interface IEnumerable<T>, que fornece um enumerador (representado pela interface IEnumerator<T>) para iterar por alguma coleção. A parte faltante (escrita) foi implementada também como uma interface e adicionada ao .NET Framework. Para isso, passamos a ter a interface IQueryable e IQueryable<T>. Com esses interfaces, somos capazes de expressar uma query através de uma AST (Abstract Syntax Tree), e mais tarde, traduzí-la para alguma fonte de dados específica.

Hoje temos os providers: LINQ To SQL, LINQ To XML e LINQ To Entities (Entity Framework). Cada um desses providers traduzem a query para uma fonte de dados específica, tais como: SQL Server (T-SQL), XML (XPath), ou até mesmo, Oracle (PL-SQL). A interface IQueryable<T> herda diretamente de IEnumerable<T>, para assim agregar a funcionalidade de iteração do resultado. A principal propriedade que ela expõe é a Expression, que retorna a instância da classe Expression, utilizada como raiz da expression tree. A imagem abaixo ilustra a hierarquia entre elas:

Existem duas classes dentro do assembly System.Core.dll, debaixo do namespace System.Linq, e que se chamam: Enumerable e Queryable. São duas classes estáticas que, via extension methods, agregam funcionalidades aos tipos IEnumerable<T> e IQueryable<T>, respectivamente. Grande parte dessas funcionalidades (métodos), refletem operadores para manipulação da query, tais como: Where, Sum, Max, Min, etc. A principal diferença entre essas duas classes é que enquanto a classe Enumerable recebe delegates como parâmetro, a classe Queryable recebe a instância da classe Expression (que envolve um delegate), que será utilizada para montar a query, e mais tarde, ser traduzida e executada pelo provider. Abaixo temos a assinatura do método Where para as duas classes:

namespace System.Data.Linq
{
    public static class Enumerable
    {
        public static IEnumerable<TSource> Where<TSource>(
            this IEnumerable<TSource> source, Func<TSource, bool> predicate)
        {
            //…
        }
    }

    public static class Queryable
    {
        public static IQueryable<TSource> Where<TSource>(
            this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate)
        {
            //…
        }
    }
}

Ambas interfaces postergam a execução da query até o momento que você precisa realmente iterar pelo resultado. Da mesma forma, como IQueryable<T> herda de IEnumerable<T>, você pode definí-la como retorno de uma função, e mais tarde, iterar pelo resultado. Só que utilizar uma ou outra, tem um comportamento bastante diferente, que pode prejudicar a performance. Para exemplificar, vamos considerar um método que retorna as categorias da base de dados, e depois disso, vamos aplicar um filtro para retornar somente aquelas categorias cujo Id seja maior que 2. Com isso, escrevemos o seguinte código:

class Program
{
    private static DBTestesEntities ctx = new DBTestesEntities();

    static void Main(string[] args)
    {
        var query = RecuperarCategorias().Where(c => c.Id > 2);

        foreach (var item in query)
            Console.WriteLine(item.Descricao);
    }

    static IEnumerable<Dados> RecuperarCategorias()
    {
        return from c in ctx.Categorias select c;
    }
}

Repare que depois de executar o método RecurarCategorias, invocamos o método de estensão Where, e neste caso, fornecido pela classe Enumerable, já que o retorno da função é do tipo IEnumerable<T>. Ao compilar a aplicação, o compilador faz o parse da query LINQ e a transforma em dados, fazendo com que a query seja representada por objetos do tipo Expression. Abaixo temos o código decompilado, e podemos perceber que a expressão lambda que passamos para o método Where, está sendo utilizada para filtrar o resultado.

internal class Program
{
    private static DBTestesEntities ctx = new DBTestesEntities();

    private static void Main(string[] args)
    {
        IEnumerable<Categoria> query = RecuperarCategorias().Where<Categoria>(delegate (Categoria c) {
            return c.Id > 2;
        });

        foreach (Categoria item in query)
            Console.WriteLine(item.Descricao);
    }

    private static IEnumerable<Categoria> RecuperarCategorias()
    {
        ParameterExpression CS$0$0001;
        return ctx.Categorias.Select<Categoria, Categoria>(
            Expression.Lambda<Func<Categoria, Categoria>>(CS$0$0001 = Expression.Parameter(typeof(Categoria), “c”), 
            new ParameterExpression[] { CS$0$0001 }));
    }
}

O grande detalhe aqui é que as estensões para a interface IEnumerable<T>, recebem delegates como parâmetro, o que quer dizer que o filtro será aplicado do lado cliente, ou seja, ao invocar o método RecuperarCategorias, todas elas (categorias) serão retornadas, carregadas em memória, e depois aplicado o filtro, “descartando” aqueles elementos que não se enquadram no critério. Abaixo temos a query que chegou até o SQL Server:

SELECT
    [Extent1].[Id] AS [Id], 
    [Extent1].[Descricao] AS [Descricao]
FROM [dbo].[Categorias] AS [Extent1]

Agora, se o retorno da função RecuperarCategorias for do tipo IQueryable<Categoria>, o comportamento é totalmente diferente. O simples fato de alterar o tipo de retorno, é o suficiente para a compilação ser substancialmente diferente. No código abaixo temos esse código para ilustrar. Note que depois de invocar o método RecuperarCategorias, já temos o método Where na sequência. A diferença é que o método Where aqui é oriundo da classe Queryable, que ao invés de receber um delegate, recebe uma Expression, obrigando o compilador a reescrever o nosso código, transformando o filtro “c => c.Id > 2” em uma instância da classe Expression, expressando aquele mesmo critério.

internal class Program
{
    private static DBTestesEntities ctx = new DBTestesEntities();

    private static void Main(string[] args)
    {
        ParameterExpression CS$0$0000;
        IQueryable<Categoria> query = RecuperarCategorias().Where<Categoria>(
            Expression.Lambda<Func<Categoria, bool>>(
                Expression.GreaterThan(Expression.Property(CS$0$0000 = Expression.Parameter(typeof(Categoria), “c”), 
                (MethodInfo) methodof(Categoria.get_Id)), Expression.Constant(2, typeof(int))), 
            new ParameterExpression[] { CS$0$0000 }));

        foreach (Categoria item in query)
            Console.WriteLine(item.Descricao);
    }

    private static IQueryable<Categoria> RecuperarCategorias()
    {
        ParameterExpression CS$0$0001;
        return ctx.Categorias.Select<Categoria, Categoria>(
            Expression.Lambda<Func<Categoria, Categoria>>(CS$0$0001 = Expression.Parameter(typeof(Categoria), “c”), 
            new ParameterExpression[] { CS$0$0001 }));
    }
}

Apesar da ligeira mudança em tempo de compilação, isso permite o processamento remoto da query. Utilizar IQueryable<T> neste cenário, irá possibilitar o build-up de queries, ou seja, a medida que você vai adicionando critérios, operadores, etc., ele irá compondo a query principal e, finalmente, quando precisar iterar pelo resultado, apenas uma única query será disparada no respectivo banco de dados, já fazendo todo o filtro por lá, retornando menos dados. Isso pode ser comprovado visualizando a query que foi encaminhada para o banco de dados depois da alteração acima:

SELECT
    [Extent1].[Id] AS [Id], 
    [Extent1].[Descricao] AS [Descricao]
FROM [dbo].[Categorias] AS [Extent1]
WHERE [Extent1].[Id] > 2