static void Main(string[] args) { // create Delegate object from MyDoubleDelegate // MyDoubleDelegate d1 = new MyDoubleDelegate(GetAverage); // the verbose was or previous version compiler way MyDoubleDelegate d1 = GetAverage; // a short-cut way to instantiate the instance double arg1 = 2, arg2 = 3; double avg = d1(arg1, arg2); // compiler issues the .Invoke method on d1 Console.WriteLine($"The average of { arg1 } and { arg2 } is: { avg }."); // a delegate object referencing an anonymous method (the old way to do it) // conceptually, the dev doesn't need to name every-single-method and why name the method if it's only used // in one place -- by a Delegate // an anonymous method MUST be created already linked to a Delegate so there is a reference (because, its nameless) MyDoubleDelegate d2 = delegate(double aa, double bb) { return(aa * bb); }; // notice the semicolon! // invoke d2 to display the result Console.WriteLine($"The product of { arg1 } and { arg2 } is: { d2(arg1, arg2) }."); MyDoubleDelegate d3 = delegate(double aa, double bb) { return(aa / bb); }; // notice the semicolon! // invoke d3 using d3.invoke method Console.WriteLine($"The divisor of { arg1 } and { arg2 } is: { d3.Invoke(arg1, arg2) }."); // Lambda expression as the method for the Delegate MyDoubleDelegate d4 = (aaa, bbb) => Math.Pow(aaa, bbb); // if more than one statement use curly-brackets around the statement list Console.WriteLine($"The average of { arg1 } and { arg2 } (as a lambda expression) is: { d4(arg1, arg2) }."); // EXERCISE: Define a Delegate type that takes 2 int and returns a bool // create a delegate object to reference a lambda expression that returns true // if both inputs are even, false otherwise int arg3 = 2, arg4 = 4; MyBoolDelegate mbd1 = (xxx, yyy) => (xxx % 2 == 0 && yyy % 2 == 0); Console.WriteLine($"The inputs { arg1 } and { arg2 } are EVEN: { mbd1(arg3, arg4) }."); Console.WriteLine("\n\nPress <Enter> to exit. . ."); Console.ReadLine(); }
static void Main(string[] args) { //If we just use the method's name we get the reference //of the method. We need to save it in a delegate type //that fulfills the signature (return type and argument types) //of the method MyDoubleDelegate squareNormal1 = Square; //The generic delegate Func<Tin, Tout> gives us a //really general delegate that can easily be specified Func <double, double> squareNormal2 = Square; //Now we do the same with a lambda expression Func <double, double> squareLambda = x => x * x; //Question: What is shorter? Console.WriteLine(squareLambda(2)); //There are other generic types like Action for no return value Action <string> printf = str => Console.WriteLine(str); //The method behind a delegate can be accessed by using the delegate //instance like a method (just calling it with some arguments): printf("Hi there!"); printf("how are you?!"); //Another popular generic delegate is the predicate, which //always returns a boolean Predicate <int, int> equal = (l, r) => l == r; if (equal(2, 3)) { printf("The two numbers are equal (how?!)."); } else if (equal(3, 3)) { printf("Now that looks more like it!"); } }
static void Main(string[] args) { Console.WriteLine("Hello Lambda!"); //If we just use the method's name we get the reference //of the method. We need to save it in a delegate type //that fulfills the signature (return type and argument types) //of the method MyDoubleDelegate squareNormal1 = Square; //The generic delegate Func<Tin, Tout> gives us a //really general delegate that can easily be specified Func <double, double> squareNormal2 = Square; //Now we do the same with a lambda expression /* * * A lambda expression is an expression of any of the following two forms: * * Expression Lambda: Has an expression as its body. * (input-parameters) => expression * * Statement Lambda: Has a statement block as its body. * (input-parameters) => { <sequence-of-statements> } * */ Func <double, double> squareLambda = x => x * x; //Question: What is shorter? Console.WriteLine(squareLambda(2)); //There are other generic types like Action for no return value Action <string> printf = str => Console.WriteLine(str); //The method behind a delegate can be accessed by using the delegate //instance like a method (just calling it with some arguments): printf("Hi there!"); printf("how are you>!"); //Another popular generic delegate is the predicate, which //always returns a boolean /* * * Represents the method that defines a set of criteria and * determines whether the specified object meets those criteria. * public delegate bool Predicate<in T>(T obj); * Read More ... * */ //Was unable to do Predicate with two arguments //!!! int r = 10; Predicate <int> equal = (l) => l == r; l = 2; if (equal(l)) { printf("The number is equal"); } else { printf("The number is not equal (how?!).") if (equal(10)) { printf("The number is equal :)"); } } }