static void Main(string[] args)
{
double a = 10;
double b = 12;
BinaryNumericOperation opMax = CalculationService.Sum;
double resultMax = opMax(a, b);
Console.WriteLine("Max: " + resultMax);
BinaryNumericOperation opSum = CalculationService.Sum;
double resultSum = opSum(a, b);
Console.WriteLine("Sum: " + resultSum);
/*
* Com o método Square não funcionar pq a assinatura do delegate é diferente da assinatura do próprio Square. Qtde de parametros diferentes
* BinaryNumericOperation opSquare = CalculationService.Square;
* double resultSquare = opSquare(a);
* Console.WriteLine("Square: " + resultSquare);
*/
/*Multicast Delegate guardando referência para duas funções:
* BinaryNumericOperation Op = CalculationService.ShowSum;
* Op += CalculationService.ShowMax;
* op.Invoke(a, b);
*/
Console.ReadLine();
}
static void Main(string[] args)
{
//Block with no using of DELEGATE
double a = 10;
double b = 12;
double sum1 = CalculationService.Sum(a, b);
double max1 = CalculationService.Max(a, b);
double sqr1 = CalculationService.Square(a);
double sqr2 = CalculationService.Square(b);
Console.WriteLine("Sum with no DELEGATE: " + sum1);
Console.WriteLine("Max with no DELEGATE: " + max1);
Console.WriteLine("First square with no DELEGATE: " + sqr1);
Console.WriteLine("Second square with no DELEGATE: " + sqr2); Console.WriteLine();
//Block with using of DELEGATE
NumericOperation sqr3 = CalculationService.Square;
BinaryNumericOperation sum = CalculationService.Sum;
BinaryNumericOperation max2 = CalculationService.Max;
//BinaryNumericOperation
Console.WriteLine("Sum with DELEGATE: " + sum(a, b));
Console.WriteLine("Max with DELEGATE: " + max2(a, b));
Console.WriteLine("Square 1 with DELEGATE: " + sqr3(a));
Console.WriteLine("Square 2 with DELEGATE: " + sqr3(b));
}
static void Main(string[] args)
{
/*
* É uma referencia (com type safety) para um ou mais metodos
* uso comum em comunicacao entre objetos de forma flexivel e extensivel(eventos/callbacks)
* parametrizacao de operacao por metodos(programacao funcional)
*
* Action, Func, Predicate
*
* Multicast delegates: guardam a referencia para mais de um metodo
* para adicionar uma referencia, pode-se usar o +=
* a chamada Invoke(ou sintaxe reduzida) executa todos os metodos na ordem em que foram adicionados
* Seu uso faz sentido para metodos void
*/
double a = 10;
double b = 12;
// BinaryNumericOperation op = CalculationService.Sum;
BinaryNumericOperation op = CalculationService.ShowSum;
op += CalculationService.ShowMAx;
double result = CalculationService.Square(a);
Console.WriteLine(result);
op.Invoke(a, b);
// Console.WriteLine(op(a, b));
}
static void Main(string[] args)
{
// Example 1 Delegates
//double a = 10;
//double b = 12;
//// delegate op é uma referencia para CalculationService.Sum
//BinaryNumericOperation op = CalculationService.Sum;
////BinaryNumericOperation op = new BinaryNumericOperation(CalculationService.Sum);
////double result = op(a, b);
//double result = op.Invoke(a, b);
//Console.WriteLine(result);
// Multicas Delegate
double a = 10;
double b = 12;
BinaryNumericOperation op = CalculationService.ShowSum;
op += CalculationService.ShowMax;
//op.Invoke(a, b);
op(a, b);
}
static void Main(string[] args)
{
double a = 10;
double b = 12;
BinaryNumericOperation op = CalculationService.Sum;
//BinaryNumericOperation op = new BinaryNumericOperation(CalculationService.Sum);
double result2 = CalculationService.Square(a);
Console.WriteLine(result2);
// double result = op(a, b);
double result = op.Invoke(a, b);
Console.WriteLine(result);
//Multicast Delegate
BinaryNumericOperation_2 op2 = CalculationService.ShowSum;
op2 += CalculationService.ShowMax;
op2(a, b);
}
static void Main(string[] args)
{
double a = 10, b = 12;
BinaryNumericOperation op = CalculationService.ShowSum;
op += CalculationService.ShowMax;
op(a, b);
}
static void Main(string[] args)
{
// Referenciando mais de uma função com um delegate.
BinaryNumericOperation b = CalculationService.ShowMax;
b += CalculationService.ShowSum;
b(10, 12);
}
static void Main(string[] args)
{
double a = 10;
double b = 12;
BinaryNumericOperation op = CalculationService.Sum;
double result = op(a, b);
Console.WriteLine(result);
}
static void Main(string[] args)
{
double a = 234;
double b = 432;
BinaryNumericOperation op = CalculationService.ShowMax;
op += CalculationService.ShowSum;
op.Invoke(a, b);
}
static void Main(string[] args)
{
double a = 10, b = 12;
BinaryNumericOperation op = CalculationService.Max;
//double result = op(a, b);
double result = op.Invoke(a, b);
Console.WriteLine(result);
}
static void Main(string[] args)
{
double a = 10;
double b = 12;
BinaryNumericOperation op = CalculationService.ShowSum;
op += CalculationService.ShowMax;
op.Invoke(a, b); // vai mostrar 22 e depois 12
}
delegate void BinaryNumericOperation(double n1, double n2); // referencia da função
static void Main(string[] args)
{
double a = 10;
double b = 12;
BinaryNumericOperation op = CalculationServices.ShowSum;
op += CalculationServices.ShowMax; // delegate agora guarda a referencia para duas funções
op.Invoke(a, b);
}
delegate void BinaryNumericOperation(double n1, double n2); // Multicast Delegate - Um Delegate que pode servir de referência para mais de um Método, porém, seu uso faz sentido para Métodos 'void'
static void Main(string[] args)
{
double a = 12;
double b = 10;
BinaryNumericOperation op = CalculationService.ShowSum; // Declarando um objeto do tipo Delegate e usando-o como referência para um Método Static
op += CalculationService.ShowMax; // Acrescentando outro Método Static para o Delegate declarado
op(a, b); // Os Métodos são feitos na ordem que foram acrescentados
}
delegate double BinaryNumericOperation(double n1, double n2); // Delegate - Referência para uma Função que recebe dois 'double's' e retorna um número double
static void Main(string[] args)
{
double a = 12;
double b = 10;
BinaryNumericOperation op = CalculationService.Sum; // Declaração de um objeto, do Tipo do Delegate criado, usado como referência para o Método Static
double r1 = op(a, b); // Usando o Método Static através do objeto tipo Delegate declarado
Console.WriteLine(r1);
}
static void x()
{
double a = 10;
double b = 12;
BinaryNumericOperation op = CalculationService.ShowMax;
op += CalculationService.ShowSum;
op.Invoke(a, b);
}
static void TesteDelegate()
{
int a = 10;
int b = 12;
BinaryNumericOperation op = CalculationServices.ShowSum;
op += CalculationServices.ShowMax;
op(a, b);
}
static void Main(string[] args)
{
double a = 10;
double b = 12;
// Referência para função que recebe dois parâmetros double e retorna um double.
BinaryNumericOperation op = CalculationService.Sum;
Console.WriteLine(op(a, b));
op = CalculationService.Max;
Console.WriteLine(op(a, b));
}
static void Main(string[] args)
{
double a = 10;
double b = 12;
BinaryNumericOperation op = CalculationService.ShowSum;
op += CalculationService.ShowMax;
op.Invoke(a, b);
//op(a, b); -- esta sintaxe também poderia ser usada
}
static void Main(string[] args)
{
double a = 10;
double b = 12;
BinaryNumericOperation op = CalculationService.ShowSum;
op += CalculationService.ShowMax;
//BinaryNumericOperation op = new BinaryNumericOperation(CalculationService.Sum);
op.Invoke(a, b);
//op(a, b);
}
static void Main(string[] args)
{
double a = 10;
double b = 12;
BinaryNumericOperation operation = CalculationService.ShowSum;
operation += CalculationService.ShowMax;
operation(a, b);
//double result = operation(a, b);
//Console.WriteLine(result);
}
static void Main(string[] args)
{
double a = 10;
double b = 12;
BinaryNumericOperation op = CalculationService.Sum;
double resultSum = op(a, b);
double resultMax = CalculationService.Max(a, b);
double resultSqr = CalculationService.Square(a);
Console.WriteLine("Sum:" + resultSum + " " + "Max:" + resultMax + " " + "Sqr:" + resultSqr);
}
static void Main(string[] args)
{
double a = 10;
double b = 12;
BinaryNumericOperation op = CalculationService.Sum;
// BinaryNumericOperation op = new BinaryNumericOperation(CalculationService.Sum); -> Forma mais verbosa!
double result = op(a, b);
// double result = op.Invoke(a, b); -> Forma alternativa!
Console.WriteLine(result);
}
static void Main(string[] args)
{
double a = 10;
double b = 12;
BinaryNumericOperation op = CalculationService.Max;
double result = CalculationService.Square(a);
Console.WriteLine(op(a, b));
}
static void Main(string[] args)
{
double a = 10.0;
double b = 12.0;
//BinaryNumericOperation op = CalculationService.Max;
/////////////////////////////////////////////////Sum
BinaryNumericOperation op = new BinaryNumericOperation(CalculationService.Sum);
double result = op.Invoke(a, b);
Console.WriteLine(result);
}
static void Main(string[] args)
{
double a = 10;
double b = 12;
//BinaryNumericOperation op = CalculationService.Sum;
BinaryNumericOperation op = CalculationService.ShowSum;
op += CalculationService.ShowMax;
//BinaryNumericOperation op = new BinaryNumericOperation(CalculationService.Sum);
// double result = op(a, b);
//double result = op.Invoke(a, b);
op(a, b);
//Console.WriteLine(result);
}
static void Main(string[] args)
{
double a = 10;
double b = 12;
BinaryNumericOperation op = CalculationService.ShowSum;
op += CalculationService.ShowMax;
double result2 = CalculationService.Square(a);
op(a, b);
Console.ReadLine();
}
static void Main(string[] args)
{
double a = 10;
double b = 12;
//Referenciando dois métodos
BinaryNumericOperation op = CalculationService.ShowSum;
op += CalculationService.ShowMax;
//Como ele não tem retorno, então não posso recebê-lo na variável
op.Invoke(a, b);
//Pode ser também op(a, b)
}
static void Main(string[] args)
{
double a = 10;
double b = 12;
// BinaryNumericOperation op = CalculationService.Sum;
BinaryNumericOperation op = new BinaryNumericOperation(CalculationService.Sum);
double result1 = op(a, b);
double result2 = op.Invoke(a, b);
Console.WriteLine(result1);
Console.WriteLine(result2);
//O método Square não casa com a assintatura delegate definida acima
//BinaryNumericOperation op = new BinaryNumericOperation(CalculationService.Square);
}
static void Main(string[] args)
{
double a = 10;
double b = 12;
BinaryNumericOperation op = CalculationService.Sum;
BinaryNumericOperation op2 = CalculationService.Max;
double result = op(a, b);
double max = op2.Invoke(a, b);
double square = CalculationService.Square(a);
Console.WriteLine("Result = " + result);
Console.WriteLine("Max = " + max);
Console.WriteLine("Square = " + square);
}
static void Main(string[] args)
{
double a = 10;
double b = 12;
// BinaryNumericOperation op = new BinaryNumericOperation(CalcutationService.Max);
BinaryNumericOperation op = CalcutationService.Max;
op += CalcutationService.Sum;
// double result =
//op.Invoke(a, b);
op(a, b);
// Console.WriteLine(result);
Console.ReadKey(true);
}
