Shalom!
Since my completion of the course (read here) I have turned my focus onto delegates and events. All in order to fully comprehend the MVVM pattern. This post will be mainly about delegates and events, but I will also write a bit some of the related topics (Lambda expressions, callbacks and Func, Action and Predicate delegates).
Delegates
In short words delegates are types that can hold a reference to methods. Those methods must be consistent with delegate type signature. They can hold a named methods, anonymous methods and Lambda expressions. Interesting feature of a delegate is that its instance can hold references to more than one method which can be added/removed simply by using + or – operator. Here’s an example of delegate signature:
|
|
//delegates are types that can hold references to methods delegate int IntDelegate(int arg); /*the signature above means that IntDelegate type has been create which can hold references to methods that return int value and take one int argument*/ |
To create an instance of a delegate:
|
|
//create new instance of IntDelegate and attaching Square method IntDelegate delegateInstance = Square; //short way IntDelegate delegateInstance = new IntDelegate(Square); //long way |
To invoke methods referenced in the delegate simply invoke it exactly the same way as regular methods or use Invoke(); method.
|
|
delegateInstance(); delegateInstance.Invoke(); int i = delegate(); //if a delegate returns a value |
Delegate can hold references to more than one method. These methods will be invoked in the same order as they were added. If a delegate returns a value it will return value from the very last method in its invocation list.
|
|
IntDelegate delegateInstance = new IntDelegate(Square); //create new instance of IntDelegate and attaching Square method delegateInstance += Double; //attaching another method to the invokation list for this instance of IntDelegate int results = delegateInstance(5); //creating new int variable and assiging results of delegateInstance Console.WriteLine("Results: {0}", results); //displaying results of delegateInstance(5) running; /*if a delegate returns a value, in case of multipe methods assigned to the delegate, the delegate will return value from the last method in its invocation list*/ |
Anonymous methods and Lambda expressions
Anonymous method is a method which is declared and its body is defined when assigning it to a delegate. Lambda expressions (introduced in C# version 3.0) are more or less the same as anonymous methods but with simplified syntax.
|
|
//delegate declarations delegate int intDelegate(int arg); delegate void voidDelegate(string arg); //anonymous method that returns square value of an int intDelegate intInstance = delegate (int input) { return input*input; }; //anonymous method that doesn't return any value but prints given value to console voidDelegate voidInstance = delegate (string text) { Console.WriteLine(text); }; |
Lambda expressions use ‘=>‘ operator. It can be understood as ‘becomes’ or ‘goes to’. In other words what’s before the operator is inputs and what’s after the operator it output. Input and output has to be consistent with delegate type to which you want to assign the expression. If there is only one instruction after the operator and the delegate returns a value it is not necessary to use ‘return‘ keyword.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
//delagate with Lambda expresion that returns int intDelegate intLambda = (int input) => input * input; //delegate with extended Lambda expresion that returns int intDelegate intExtLambda = (int input) => { int buffer; buffer = input * input; buffer = (int)Math.PI * buffer; return buffer; }; //delgate with Lambda expression that returns nothing voidDelegate voidLambda = (string text) => Console.WriteLine(text); //delegate with extended Lambda expression that return nothing voidDelegate voidExtLambda = (string text) => { Console.WriteLine("Given text: {0}", text); Console.WriteLine("Length: {0}", text.Length); Console.WriteLine("Capitalizad text: {0}", text.ToUpper()); }; |
Func, Action, Predicate
These are ‘built-in’ generic delegate types introduced in C# 3.0. Generic parameters represents type of arguments and type of returned value (if any).
|
|
//Func<T,R> - generic delegate that takes T type argument and returns R type value Func<string, int> GetLength = (string input) => input.Length; /Action<T> - generic delegate that takes T type argument and doesn't return anything Action<string> WriteBackwards = (string text) => { char[] stringChars = text.ToCharArray(); Array.Reverse(stringChars); Console.WriteLine( new string(stringChars)); }; //Predicate<T> - generic delegate that checks a specified condition and returns boolean Predicate<int> IsEven = (int input) => input % 2 == 0; |
One of the purpose where you can use predicates is filtering a collection. For example, you can use RemoveAll(Predicate<T> match); method to remove from a list all elements that satisfy the condition.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
Predicate<int> IsEven = (int input) => input % 2 == 0; //Predicates can be used to eleminate specified items in collections (for instance in Lists); List<int> Numbers = new List<int> { 3, 4, 5, 6, 7, 8, 9, 10, 11 }; Console.Write("\nInitial content of the list: "); foreach(int i in Numbers) { Console.Write("{0} ", i); } //removing all even numbers from the list using IsEven predicate Numbers.RemoveAll(IsEven); //List<T>.RemoveAll(Predicate<T> match) removes all items that returns true value when used with the predicate Console.Write("\nContent of the list after filtering: "); foreach(int i in Numbers) { Console.Write("{0} ", i); } |
Callbacks
While doing research about delegates it was often claimed that main purpose of delegates is allowing communication between two classes. Original meaning of ‘delegate’ noun is someone who is sent to other party with a message. And this is how delegates should also be comprehended in C# and programming.
Imagine that there is a class with a method that takes a significant amount of time to execute. To keep application responsive it would be worth to have some feedback about the status or progress of this time-costly method. It is possible to achieve via callbacks.
Here’s a Calculation class with a method simulating some lengthy calculations:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 |
using System.Threading; namespace DelegateCallbacks { public class Calculation { private int cycles; public int Cycles { get { return cycles; } set { cycles = value; } } //default constructor public Calculation(int _cycles) { Cycles = _cycles; } //running this method will call back to main each iteration of for loop public void Process(CallBack callBackMethod) { for(int i = 1; i <= cycles; i++) { //immitation of some calculations that takes 1/10 of second Thread.Sleep(100); //in miliseconds //point of calling back callBackMethod(i); } } //delegate that determines methods of what signatures can be used as call backs public delegate void CallBack(int i); } } |
This class defines CallBack delegate type which takes one integer argument and doesn’t return any value. This delegate is also an argument in our Process method that want’s to send feedback to another class which is achieved by invoking that argument somewhere in the method.
UI for this example is a WPF window. It consists of a textbox where user gives number of cycles that Process method will run and a button that executes that method. There is also a numeric indicator of current cycle and a progress bar. Those two controls receive feedback from Process method. There is also a text box to witness that the UI is responsive while the Process method is runnind. Here’s XAML code:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
<Window x:Class="DelegateCallbacks.MainWindow" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:d="http://schemas.microsoft.com/expression/blend/2008" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" xmlns:local="clr-namespace:DelegateCallbacks" mc:Ignorable="d" Title="Callbacks" Height="200" Width="200" Background="DarkGray" ResizeMode="NoResize"> <Grid Margin="5"> <Grid.RowDefinitions> <RowDefinition Height="auto"/> <RowDefinition Height="*"/> <RowDefinition Height="auto"/> <RowDefinition Height="auto"/> </Grid.RowDefinitions> <StackPanel Grid.Row="0" Orientation="Horizontal"> <TextBlock Text="Iterations: "/> <TextBox x:Name="iterationsQTY" Width="50" MaxLength="5"/> <Button x:Name="runProcess" Content="Run!" Margin="15,0,0,0" Width="50" Click="runProcess_Click"/> </StackPanel> <TextBlock x:Name="iterationNo" Foreground="DarkBlue" Grid.Row="1" HorizontalAlignment="Center" VerticalAlignment="Center" FontSize="60" FontWeight="Bold" Text="0" /> <ProgressBar x:Name="progress" HorizontalAlignment="Stretch" Height="20" Grid.Row="2" IsEnabled="False" Minimum="0"/> <TextBox Margin="0,2,0,0" HorizontalAlignment="Stretch" Grid.Row="3" Text="Responsive textbox"/> </Grid> </Window> |
Code-behind the main window consists of Click event for a button that starts the process and UpdateUI method.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 |
using System.Threading.Tasks; using System.Windows; namespace DelegateCallbacks { /// <summary> /// Interaction logic for MainWindow.xaml /// </summary> public partial class MainWindow :Window { public MainWindow() { InitializeComponent(); } private void runProcess_Click(object sender, RoutedEventArgs e) { int itr; if(!int.TryParse(iterationsQTY.Text, out itr)) { MessageBox.Show("Cannot convert input itereation number to integer!", "Upsss..."); } else { runProcess.IsEnabled = false; iterationsQTY.IsEnabled = false; runProcess.IsEnabled = false; progress.Maximum = itr; progress.IsEnabled = true; progress.Value = 0; //creating new instance of Calculation class Calculation thisCalc = new Calculation(itr); //creating new task for the Process method to keep the UI responsive Task processTask = new Task(() => thisCalc.Process(UpdateUI)); processTask.Start(); // continueTask specifies what happens when processTask is completed Task continueTask = processTask.ContinueWith((a) => { MessageBox.Show("Process compeleted after " + itr + " iterations.", "Process finished"); }); } } //call back method that gets current iteration in Process method and updates the UI public void UpdateUI(int i) { //updating the UI is achieved through dispatcher to allow processTask to update values in root thread this.Dispatcher.Invoke(() => { iterationNo.Text = i.ToString(); progress.Value = i; if(i == int.Parse(iterationsQTY.Text)) { iterationsQTY.IsEnabled = true; runProcess.IsEnabled = true; progress.IsEnabled = false; runProcess.IsEnabled = true; } }); } } } |
Process method is started as a new Task to keep the UI responsive. UpdateUI method must have signature consistent with CallBack delegate defined in Calculation class as this method is used as an argument in Process method.
Events
Concept of events enables a programmer to use a kind of notification system between objects. To depicts that I prepared small program that imitates a wallet and adding money to it. Here’s listing of Wallet class:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 |
using System; namespace Events { public class Wallet { //declaring delegate signature that will be used for event handler public delegate void GotSomeMoney(object sender, EventArgs e); //declaring an event public event GotSomeMoney OnGotSomeMoney; //booleans used to help with firing events private bool reached100, reached500, reached1000, reached2000 = false; private string owner; public string Owner { get { return owner; } set { owner = value; } } private int money; public int Money { get { return money; } set { money = value; //creating circumstances in which the event will be fired if((money >= 2000)&&(!reached2000)) { FireEvent(2000); reached2000 = true; } else { if((money >= 1000)&&(!reached1000)) { FireEvent(1000); reached1000 = true; } else { if((money >= 500)&&(!reached500)) { FireEvent(500); reached500 = true; } else { if((money >= 100)&&(!reached100)) { FireEvent(100); reached100 = true; } } } } } } public Wallet() { Owner = ""; Money = 0; } //declaring a private method which will be used to fire the event //it creates an instance of event arguments class (in this case MoneyEventArgs) //it checks if there are any subscriptions to the event before firing it private void FireEvent(int valueCrossed) { MoneyEventArgs e = new MoneyEventArgs(); e.Money = Money; e.ValueCrossed = valueCrossed; if(OnGotSomeMoney != null) //checking if there are subscriptions { OnGotSomeMoney(this, e); //if there are the event will be fired with 'this' object and e EventArgs as arguments } //no action if there are no subscriptions } } //declaring class for event arguments. This class must be derived form EventArgs class //more on EventArgs: https://msdn.microsoft.com/en-us/library/system.eventargs(v=vs.110).aspx public class MoneyEventArgs :EventArgs { public int Money { get; set; } public int ValueCrossed { get; set; } } } |
First of all it has a delegate GotSomeMoney declared that defines event handler signature. Event handler is a method that is executed when an event occurs. It takes two parameters: object sender (which is an object that fires the event) and EventArgs e (object of an EventArgs class that holds argument that you want to pass with the event).
At the very end of the file above I declared a new class MoneyEventArgs which is derived form EventArgs class. This class has two properties that will be passed with the event.
Having these two parameters in event handler is to follow the .NET guidelines. It is not necessary but if you take a look at all the events for all of the controls (in WinForms and in WPF as well) you’ll see that they follow the same guidelines.
Now, if you analyse setter for Money property in Wallet class you will notice that FireEvent method is executed in some particular circumstances. This method takes one integer argument. Now, if we move on the the code of this method that it creates new instance of MoneyEventArgs class and assign certain values to its properties. Then, it checks if there are any subscriber for the OnGotSomeMoney event and if affirmative it fires the event with this as an object argument and that newly created instance of MoneyEventArgs class.
Now, let’s move to the UI. It has a text box to provide owner’s name and a button that initializes new instance of Wallet class. It also has a counter that displays content of the wallet and buttons that allows a user to add some money. The are disabled until the initialize button is clicked. Here’s XAML code:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 |
<Window x:Class="Events.MainWindow" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:d="http://schemas.microsoft.com/expression/blend/2008" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" xmlns:local="clr-namespace:Events" mc:Ignorable="d" Title="Events DEMO" Height="230" Width="250" ResizeMode="NoResize" Background="Gray"> <Window.Resources> <local:Wallet x:Key="myWallet"/> </Window.Resources> <Grid> <Grid.RowDefinitions> <RowDefinition Height="auto"/> <RowDefinition Height="auto"/> <RowDefinition Height="auto"/> <RowDefinition Height="auto"/> </Grid.RowDefinitions> <StackPanel Orientation="Horizontal" Grid.Row="0" Margin="5"> <TextBlock Text="Owner: " VerticalAlignment="Center"/> <TextBox x:Name="ownerName" HorizontalAlignment="Center" Width="110" Height="25" VerticalAlignment="Center" Margin="3" VerticalContentAlignment="Center" TextChanged="ownerName_TextChanged"/> <Button x:Name="initializeOwner" Content="Initialize" Height="25" Width="65" Click="initializeOwner_Click" IsEnabled="False"/> </StackPanel> <TextBlock x:Name="walletMoney" Text="00" FontSize="60" Foreground="Blue" Grid.Row="1" HorizontalAlignment="Center"/> <TextBlock Text="Add to wallet: " Grid.Row="2" Margin="5"/> <StackPanel Orientation="Horizontal" Grid.Row="3" Margin="5" HorizontalAlignment="Center"> <Button x:Name="Add1" Height="25" Width="25" Content="1" Click="ButtonAdd_Click" IsEnabled="False" Margin="2"/> <Button x:Name="Add2" Height="25" Width="25" Content="2" Click="ButtonAdd_Click" IsEnabled="False" Margin="2"/> <Button x:Name="Add5" Height="25" Width="25" Content="5" Click="ButtonAdd_Click" IsEnabled="False" Margin="2"/> <Button x:Name="Add10" Height="25" Width="25" Content="10" Click="ButtonAdd_Click" IsEnabled="False" Margin="2"/> <Button x:Name="Add20" Height="25" Width="25" Content="20" Click="ButtonAdd_Click" IsEnabled="False" Margin="2"/> <Button x:Name="Add50" Height="25" Width="25" Content="50" Click="ButtonAdd_Click" IsEnabled="False" Margin="2"/> <Button x:Name="Add100" Height="25" Width="25" Content="100" Click="ButtonAdd_Click" IsEnabled="False" Margin="2"/> <Button x:Name="Add200" Height="25" Width="25" Content="200" Click="ButtonAdd_Click" IsEnabled="False" Margin="2"/> </StackPanel> </Grid> </Window> |
This XAML code also defines myWallet instance of Wallet class. It all happens in <Window.Resources>. This instance will be available also in code-behind.
Now, let’s take a look at code-behind:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 |
using System; using System.Collections.Generic; using System.Windows; using System.Windows.Controls; namespace Events { /// <summary> /// Interaction logic for MainWindow.xaml /// </summary> public partial class MainWindow :Window { public MainWindow() { InitializeComponent(); } private void ButtonAdd_Click(object sender, RoutedEventArgs e) { Wallet thisWallet = this.Resources["myWallet"] as Wallet; Button buttonClicked = sender as Button; thisWallet.Money += int.Parse(buttonClicked.Content.ToString()); walletMoney.Text = thisWallet.Money.ToString(); } private void initializeOwner_Click(object sender, RoutedEventArgs e) { if(ownerName.Text != "") { Wallet thisWallet = this.Resources["myWallet"] as Wallet; thisWallet.Owner = ownerName.Text; //adding method from MainWindow class that will execute when the event occurs thisWallet.OnGotSomeMoney += ThisWallet_OnGotSomeMoney; List<Button> buttons = new List<Button> { Add1, Add2, Add5, Add10, Add20, Add50, Add100, Add200 }; foreach(Button btn in buttons) { btn.IsEnabled = true; } ownerName.IsEnabled = false; initializeOwner.IsEnabled = false; } else { MessageBox.Show("Provide owner name!","Missing owner name"); } } private void ThisWallet_OnGotSomeMoney(object sender, EventArgs e) { Wallet thisWallet = sender as Wallet; MoneyEventArgs args = e as MoneyEventArgs; string _name = thisWallet.Owner; int _cash = args.Money; int _crossed = args.ValueCrossed; MessageBox.Show("You have reached "+_crossed+" in your wallet!\nTotal amount in your wallet is "+_cash+"!", "Kudos " + _name+"!"); } private void ownerName_TextChanged(object sender, TextChangedEventArgs e) { TextBox thisTextBox = sender as TextBox; if(thisTextBox.Text != "") { initializeOwner.IsEnabled = true; } else { initializeOwner.IsEnabled = false; } } } } |
Code-behind has ThisWallet_OnGotSomeMoney method which signature is consistent with GotSomeMoney delegate in Wallet class. This method will be assigned as a subscriber to OnGotSomeMoney event of thisWallet instance by clicking Initialize button. Note, that this assignment is achieved by using ‘+=’ operator. To avoid clearing all subscribes it is not possible to use ‘=’ operator event. You can only subscribe to event by using ‘+=’ or unsubscribe by using ‘-=’ operator.
ThisWallet_OnGotSomeMoney method takes some values from sender and MoneyEventArgs and creates some strings that will be displayed in a message box when the event occurs.
Understanding all of these concepts required to be quite focused and multiple reading or watching of the sources I had available. If I were to recommend something that helps to understand these aspects of programming here are some links:
Jesse Dietrichson: https://www.youtube.com/channel/UCiA3tURI8dwCOUzCeM90c2g
https://www.youtube.com/watch?v=8e2GEFNctwQ&t=1466s
.NET Interview Preparation Videos
https://www.youtube.com/channel/UCHI5xgQujSyqz_UyKdLFaqw
https://www.youtube.com/watch?v=ifbYA8hyvjc&t=416s
All of the code presented in this post can be found here:
https://github.com/mickaj/DelegatesLambda
Feel free to test it!
That’s it for today. Next, I will post something about interfaces. Hopefully, shortly…
Regards, Michal
So, that’s it for today. I know that styling in WPF is much more vast topic and surely I will come back to it, but this basic introduction is sufficient for me for the time being.