Tome dois parâmetros e me ligue pela manhã

Primeiramente gostaria de pedir desculpas pela demora nos posts mas como estas ultimas semanas foram um pouco corridas, não tive muito tempo para passar por aqui. Mas como teremos um belo feriado pela frente, é capaz que eu consiga colocar minha vida na linha novamente.
O titulo se refere a duas técnicas bem interessantes que utilizei esta semana no trabalho: Chamadas Assincronas de Métodos e os famosos Callbacks.
Muitas vezes nos deparamos com situações em que precisamos executar diversas tarefas ao mesmo tempo, e ha casos em que por exemplo precisamos chamar um serviço e não queremos bloquear a aplicação ou a interface com o usuário esperando a execução do mesmo. É ai que entram as chamadas assincronas. Quando utilizamos esta técnica, o método é chamado em uma thread separada e a thread principal continua livre para coninuar fazendo seu trabalho.
Tá bom, mas o que isso tem tem de diferente do método tradicional onde nós mesmos criamos as threads? Bom duas coisas: o .NET tem uma implementação mais simples e mais limpa, e temos muito mais facilidade na passagem de parametros.
Quando utilizamos apenas as chamadas assincronas, executamos esse método nesta nova thread e não temos a menor idéia do que aconteceu. Para termos este controles podemos ou segurar a thread principal, ou utilizarmos os Callbacks.
Um clalback é um método que é passado como parametro na chamada assincrona e é executado assim que o mesmo finaliza. Com ele podemos pegar todos os parametros passados, e os retornados dando assim total controle do que aconteceu.
Ai voce me perunta: Ué, mas a gente não viu isso em algum lugar? Ahã. Se voce ja gerou um Proxy de Web Service no Visual Studio, la dentro estão todas as chamadas assincronas dos seus métodos. Vejamos como isso funciona.

criamos primeiro um delegate com a assinatura que queremos chamar

public delegate bool DelegateAssincrono(string param1, int param2, bool param3);

criamos o método que ira ser executado. Este método é um método normal e não vou colocar um exeplo aqui.

Para chamarmos o método de forma assincrona é tão simples como comprar pão na padaria:

DelegateAssincrono delAssinc = new DelegateAssincrono(nossoMetodo);
delAssinc.BeginInvoke(param1, param2, param3, null, null);

Uau simples né. E se quisessemo um callback?

delAssinc.BeginInvoke(param1, param2, param3, callBackAssinc, null);

E o método callback

private void callBackAssinc(IAsyncResult result)
{
AsyncResult ar = (AsyncResult)result;
DelegateAssinc delAssinc = (DelegateAssinc)ar.AsyncDelegate;

bool retorno = delAssinc.EndInvoke();
}

Pretendo escrever um artigo sobre este assunto, por isso não estou colocando muitos detalhes aqui. Maiores referencias podem ser encontradas no Code PRoject procurando pelas palavras chaves Assync Invokation.

Até o próximo post!!!!!