Programação assíncrona no C# 5.0 - Revista .net Magazine 89

Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Para efetuar o download você precisa estar logado. Clique aqui para efetuar o login
Confirmar voto
0
 (0)  (0)

O artigo trata do novo padrão de desenvolvimento assíncrono chamado T.A.P. (Task-based Assynchronous Pattern), presente na próxima versão do C# e também do .NET framework.

De que se trata o artigo

O artigo trata do novo padrão de desenvolvimento assíncrono chamado T.A.P. (Task-based Assynchronous Pattern), presente na próxima versão do C# e também do .NET framework. Será utilizada a TAP a fim de permitir um desenvolvimento de operações assíncronas de mais alto nível.

Em que situação o tema é útil

Esse padrão assíncrono é útil em operações que demandam longos períodos de execução, cálculos que exigem muito recurso da CPU bloqueando as próximas operações como, por exemplo, uma folha de pagamento, onde dependendo do porte da empresa essa rotina pode consumir muito tempo até ser concluída. Outro cenário de utilização seria requisições de dados na Web, onde o desempenho pode variar muito, pois depende de vários fatores, e em alguns casos, a espera pode ser em vão.

C# 5 – Programação assíncrona na nova versão

Neste artigo será apresentado um novo recurso que teremos na próxima versão do C#, mostraremos como será a nova forma de desenvolver aplicações utilizando o padrão T.A.P. e suas novidades. Será explicado a evolução do .NET no que diz respeito à programação assíncrona. Entenderemos também como funciona esse novo padrão e suas nomenclaturas. Mostraremos como você já pode aproveitar esse recurso hoje, sem que seja necessário aguardar o lançamento oficial e o que você irá precisar para o uso, por fim conheceremos um pouco sobre o padrão T.A.P. através de um pequeno exemplo de operações assíncronas. Será comentado também as vantagens e desvantagens desse novo padrão bem como uma dica ao leitor sobre as situações em que ele poderá tirar proveito desse novo recurso.

Os equipamentos que usamos atualmente, desde microcomputadores, celulares, tables etc., estão ganhando mais e mais recursos a cada dia. Todos esses recursos exigem certo nível de processamento do equipamento para que estes executem com uma velocidade satisfatória.

Uma boa parte das aplicações que desenvolvemos não distribui adequadamente a carga de processamento como deveria, boa parte do fluxo de execução é mantido na mesma thread da aplicação. Esse tipo de desenvolvimento em uma única thread traz vários inconvenientes como: tela travada, componentes visuais não atualizados durante a execução, impossibilidade de cancelar uma operação e ainda subutilizando os recursos de hardware.

É sabido que isso se deve a vários motivos, falta de tempo para desenvolver, pois trabalhar com threads não é uma coisa muito trivial, e também dificuldade de manutenção futura, pois muitas vezes a lógica é desmembrada em partes para que tenhamos um resultado conforme o esperado, e isso é extremamente suscetível a erro.

Precisamos programar a fim de utilizar da melhor maneira possível todos os recursos que as CPUs oferecem. Nos últimos anos os processadores vinham evoluindo rapidamente (Lei de Moore). No período entre um ano e meio a dois anos, chegavam a dobrar o seu poder de processamento, porém atingimos um nível onde isso não ocorre com tanta frequência, ou melhor, nem tem ocorrido ultimamente. O que vimos hoje em dia é o aumento do número de núcleos nos processadores, e também dos processadores. Computadores multiprocessados ou multinucleados estão cada vez mais presentes no dia a dia.

Com isso, certas linguagens de programação, foram se adaptando a esse contexto para garantir uma melhor performance na execução de tarefas que exigem grande carga de processamento com a possibilidade de distribuir essa carga entre os diversos núcleos e/ou processadores tudo isso com o mínimo de esforço para o desenvolvedor.

Nota

A lei de Moore foi criada em 1965 por Gordon E. Moore, um dos co-fundadores da Intel onde ele disse que o número de transistores em um processador dobraria a cada 18 a 24 meses ao mesmo custo, e isso veio ocorrendo desde então, segundo dados da Intel a ideia hoje é continuar mantendo essa lei com a tecnologia reduzida que é empregada nos novos modelos de processadores.

Programação síncrona x assíncrona

De uma forma natural, os códigos que escrevemos no dia a dia são chamados puramente operações síncronas, essas operações têm como thread de execução a própria thread que realizou a chamada. No momento em que executamos alguma operação síncrona, essa operação inicia a sua execução, bloqueando a thread atual para as demais operações até que ela termine de executar e passe o controle novamente para a thread principal, que se encarregará de prosseguir com as demais operações que aguardam.

O grande problema dessa situação é que se a operação a ser executada demorar muito tempo para realizar o processamento, isso acarretará em demasiada espera para as demais operações. Trabalhar dessa forma é subutilizar o hardware, claro que nem todas as operações têm a necessidade de serem assíncronas, mas temos que ser cuidadosos na hora de definir qual operação será ou não síncrona.

Por outro lado, o .NET Framework nos permite o desenvolvimento com operações assíncronas, as operações assíncronas não possuem um desenvolvimento tão natural assim como as operações síncronas, elas demandam um certo conhecimento por parte do desenvolvedor, exigem mais tempo para serem desenvolvidas e eis um dos motivos pelo qual a maioria dos sistemas ainda não contemplam essas técnicas em seu código. Esse tipo de operação funciona de forma a não bloquear a thread principal do sistema garantindo um fluxo contínuo nas operações.

"

A exibição deste artigo foi interrompida :(
Este post está disponível para assinantes MVP

 
Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Receba nossas novidades
Ficou com alguma dúvida?