Callback functions são blocos de código executável que são passados como parâmetro para outro código, que fica responsável por invocá-los quando apropriado.
O modo como callback functions são suportados em cada linguagem de programação é diferente, mas são frequentemente implementados como subrotinas, expressões lambdas ou ponteiros de função.
O tratamento das linguagens não-gerenciadas sobre os callback functions é limitada a apenas um endereço de memória. Este endereço de memória não contém nenhuma informação adicional sobre o tipo de retorno, o número de parâmetros ou os tipos de dados dos parâmetros.
O .Net Framework expõe o mecanismo de callback functions por meio do uso de delegates.
Delegates asseguram que os callback functions são type-safe (i.e., tipados, fortemente tipado, de tipagem segura). Delegates também permitem a execução de métodos estáticos e execução sequencial de múltiplos métodos.
No .Net Framework os delegates são utilizados para diversas tarefas, como: notificação de exceções não tratadas, seleção de itens de menu, eventos em controles de formulários e término de operações assíncronas.
Tome como exemplo o código abaixo:
using System;
using System.Reflection;
internal delegate void Answer(Guid value);
class Program {
static void Main(string[] args) {
Program program = new Program();
var fb0 = new Answer(Program.WriteSomething);
var fb1 = new Answer(program.WriteSomethingInRed);
var fb2 = new Answer(program.WriteSomethingInBlue);
#region [ Single delegate ]
Object instance = fb0.Target;
MethodInfo method = fb0.Method;
ExecuteAllStuff(fb0);
#endregion
#region [ Multiple delegates ]
Answer allFeeds = null;
allFeeds += fb0;
allFeeds += fb1;
allFeeds = (Answer)Delegate.Combine(allFeeds, fb2);
var invocationList = allFeeds.GetInvocationList();
ExecuteAllStuff(allFeeds);
#endregion
// The line below is just here to stop the screen and you see the results
// Or delete the line below and execute with (Ctrl + F5)
Console.Read();
}
public static void ExecuteAllStuff(Answer feedBackDelegate) {
Console.WriteLine("*****************************");
// Invoque method(s)
feedBackDelegate(Guid.NewGuid());
}
public static void WriteSomething(Guid value) {
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine("The value is: {0}", value);
}
private void WriteSomethingInRed(Guid value) {
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("The red value is: {0}", value);
}
public void WriteSomethingInBlue(Guid value) {
Console.ForegroundColor = ConsoleColor.Blue;
Console.WriteLine("The blue value is: {0}", value);
}
}
No código acima é criado um delegate de nome Answer. Em sua declaração pode-se identificar a estrutura esperada para os callback functions: métodos com retorno void e cujo único parâmetro é do tipo Guid.
Também é definido um método privado estático chamado ExecuteAllStuff. Este método espera como parâmetro um delegate Answer e faz o invoque do callback function associado ao delegate. Note que para realizar o invoque do método, por meio do delegate, o parâmetro é passado entre parênteses:
feedBackDelegate(Guid.NewGuid());
… mas o compilador gera uma chamada ao método Invoke, como demonstrado abaixo:
feedBackDelegate.Invoke(Guid.NewGuid());
Isso demonstra que as duas operações são semelhantes e ambas podem ser utilizadas para obtenção dos mesmos resultados.
Em seguida existem três métodos: WriteSomething, WriteSomethingInRed e WriteSomethingInBlue. Veja que estes métodos tem a assinatura esperada pelo delegate Answer (retorno void com um único parâmetro do tipo Guid).
O método estático Main contém a parte mais interessante do código e está dividido em três partes: declaração dos delegates, uso de um simples delegate e uso de múltiplos delegates.
Veja que no bloco de declaração dos delegates são criadas três instâncias de Aswer. A primeira das instâncias criadas recebe como parâmetro uma referência para um método estático da classe Program. As demais instâncias criadas recebem como parâmetro dois métodos de instância, sendo um público e o outro privado.
No bloco "Single delegate" algumas informações sobre o delegate são acessadas. A propriedade Target de um delegate indica qual instância de objeto é a detentora do método a ser invocado. No caso dos callback functions que utilizam métodos estáticos o valor desta propriedade será null, pois realmente não existe uma instância ativa para um método estático. A propriedade Method de um delegate, como o próprio nome já diz, indica qual método será invocado pelo delegate.
#region [ Single delegate ]
Object instance = fb0.Target;
MethodInfo method = fb0.Method;
ExecuteAllStuff(fb0);
#endregion
O bloco "Multiple delegates" demonstra o acumulo de delegates, conceito conhecido como Delegate Chain Invocation. Essa funcionalidade não existe nas linguagens não-gerenciadas e permite o acumulo de delegates, para que sejam invocados de uma única vez e de maneira sequencial. O acumulo de delegates pode ser feito de duas maneiras: utilizando o operador "+=" ou por meio do método estático Combine da classe Delegate. Perceba que para o acúmulo dos delegates foi criado um novo delegate chamado allFeeds.
#region [ Multiple delegates ]
Answer allFeeds = null;
allFeeds += fb0;
allFeeds += fb1;
allFeeds = (Answer)Delegate.Combine(allFeeds, fb2);
var invocationList = allFeeds.GetInvocationList();
ExecuteAllStuff(allFeeds);
#endregion
A execução de diversos delegates de uma única vez nem sempre é vantajosa. Caso algum dos delegates lance uma exceção todos os delegates subsequentes serão bloqueados.
Para estes cenários, podemos utilizar o método GetInvocationList. Este método que cria um array com todos os delegates encadeados a serem executados e o retorna ao ponto chamador. Caso o delegate não contenha delegates acumulados, isto é, caso o delegate contenha apenas um delegate, então o retorno deste método será null, pois não existe uma coleção de delegates a serem retornados já que a referência é feita a apenas um delegate. O código abaixo demonstra como isso pode ser feito:
public static void ExecuteOneByOne(Answer feedBackDelegate) {
if (feedBackDelegate == null)
return;
Delegate[] delegates = feedBackDelegate.GetInvocationList();
if (delegates == null) {
feedBackDelegate(Guid.NewGuid());
return;
}
foreach (Answer delegateInstance in delegates) {
try {
delegateInstance(Guid.NewGuid());
}
catch (Exception ex) {
Object component = delegateInstance.Target;
Console.WriteLine("Error executing callback function: {0}/{1} - Error: {2}",
(component != null)? component.GetType().ToString() : "(static)",
delegateInstance.Method.Name,
ex.Message);
}
}
}
Por
MSc. Fernando Henrique Inocêncio Borba Ferreira
Microsoft Most Valuable Professional – Visual C#
Referências:
CLR Via C# 3.0 – Jeffrey Richter
Delegates (C# Programming Guide)
