);
-
-Example:
-
-delegate void PrintDelegate(string output);
-
-This creates a new delegate of type void, named PrintDelegate and one parameter of type string
-
-The referenced method return and parameter types have to match the delegate!
-
-# Referencing a Delegate
-
-After creating the delegate, it can be instantiated and the method assigned to it with the method name:
-
-delegate void PrintDelegate(string output);
-
-static void Main(string[] args)
-
-{
-
-void PrintInLower(string text)
-
-{
-
-Console.WriteLine(text.ToLower());
-
-}
-
-PrintDelegate print = PrintInLower;
-
-print("AaaBbbCcc"); // Outputs "aaabbbccc"
-
-}
-
-# Using Multicast Delegates
-
-Delegates can be __composed of__ multiple methods using the "+" operator
-
-Using the same PrintDelegate delegate as before, we could do this:
-
-delegate void PrintDelegate(string output);
-
-static void Main(string[] args)
-
-{
-
-void PrintInLower(string text)
-
-{
-
-Console.WriteLine(text.ToLower());
-
-}
-
-void PrintInUpper(string text)
-
-{
-
-Console.WriteLine(text.ToUpper());
-
-}
-
-PrintDelegate print = PrintInLower;
-
-print += PrintInUpper;
-
-print("AaaBbbCcc");
-
-}
+### Creating a delegate
+
+* Declare a delegate using the following syntax:
+ ```csharp
+ delegate returnType DelegateName(parameters);
+ ```
+* Example:
+
+ ```csharp
+ delegate void PrintDelegate(string output);
+ ```
+* This creates a new delegate of type `void`, named `PrintDelegate` and one parameter of type `string`
+* The referenced method return and parameter types have to match the delegate!
+
+### Referencing a delegate
+
+* After creating the delegate, it can be instantiated and the method assigned to it with the method name:
+ ```csharp
+ delegate void PrintDelegate(string output);
+
+ static void Main(string[] args)
+ {
+ void PrintInLower(string text)
+ {
+ Console.WriteLine(text.ToLower());
+ }
+
+ PrintDelegate print = PrintInLower;
+ print("AaaBbbCcc"); // Outputs "aaabbbccc"
+ }
+ ```
+
+### Using multicast delegates
+
+* Delegates can be composed of multiple methods using the `+` operator
+* Using the same `PrintDelegate` delegate as before, we could do this:
+
+
+
+ ```csharp
+ delegate void PrintDelegate(string output);
+ static void Main(string[] args)
+ {
+ void PrintInLower(string text)
+ {
+ Console.WriteLine(text.ToLower());
+ }
+ void PrintInUpper(string text)
+ {
+ Console.WriteLine(text.ToUpper());
+ }
+ PrintDelegate print = PrintInLower;
+ print += PrintInUpper;
+ print("AaaBbbCcc");
+ }
+ ```
+
+
+
-# Using Multicast Delegates (continued)
-
-Methods can be removed from the delegate with the "-" operator:
-
-delegate void PrintDelegate(string output);
-
-static void Main(string[] args)
-
-{
-
-...
-
-print -= PrintInLower;
-
-print("AaaBbbCcc"); // Outputs "AAABBBCCC"
-
-...
-
-}
+
+
+
+```csharp
void PrintInLower(string text)
-
{
-
-Console.WriteLine(text.ToLower());
-
+ Console.WriteLine(text.ToLower());
}
-
void PrintInUpper(string text)
-
{
-
-Console.WriteLine(text.ToUpper());
-
+ Console.WriteLine(text.ToUpper());
}
-
// Initialize new delegate which is composed of PrintInLower method
-
PrintDelegate print = PrintInLower;
// Add PrintInUpper method to the delegate
-
print += PrintInUpper;
// Send the delegate to the class constructor
-
DelegateTest delegateTest = new DelegateTest(print);
+```
-
-
-# Anonymous Methods
-
-Delegates can be initialized anonymously (without a specified name)
-
-Anonymous method in variable declaration:
-
-delegate void PrintDelegate(string output);
-
-bool printUpper = true;
-
-PrintDelegate printCheckUpper =
+
+
-delegate (string text)
-
-{
-
-if (printUpper)
-
-Console.WriteLine(text.ToUpper());
-
-else
+Now we can create a new DelegateTest object and pass the delegate to the object constructor:
-Console.WriteLine(text);
+
-};
+
+
+
+
+ ```csharp
+ class Game
+ {
+ Sound gameOverSound;
+ Window gameOverScreen;
+
+ void OnGameOver()
+ {
+ gameOverSound.Play(); // plays some sound
+ gameOverScreen.Show(); // shows a screen
+ }
+ }
+ ...
+ class Program
+ {
+ static void Main()
+ {
+ var game = new Game();
+
+ // somewhere in the game logic...
+ // game.OnGameOver();
+ }
+ }
+ ```
+
+
+
+* Consider a game engine with three classes, `Sound`, `Window` and `Game`.
+* If implemented like this, the `Game` class has to know about the `Sound` and `Window` classes
+* $\Rightarrow$ `Game` is ***tightly coupled***, and thus ***dependent*** on the `Sound` and `Window` classes
+* Changes in either of the classes could break the code!
+
+
+
+
+
+```csharp
+public class Publisher
{
+ public event EventHandler SampleEvent;
+ protected virtual void OnSampleEvent()
+ {
+ SampleEvent?.Invoke(this);
+ }
+}
+```
-static void Main(string[] args)
+
+
+```csharp
+class Program
{
+ static void Main()
+ {
+ var pub = new Publisher();
-// Initialize an empty delegate, add method later...
-
-SomeDelegate myDelegate = new SomeDelegate(delegate { });
-
+ pub.OnSampleEvent(); // ✅ Works fine
+ // pub.SampleEvent(); // ❌ Not allowed!
+ }
}
+```
-}
-
-# Events
-
-* Consider the following Game class:
-* class Game
-* {
-* Sound gameOverSound;
-* Window gameOverScreen;
-* // Some game logic here...
-* // ...
-* void OnGameOver()
-* {
-* gameOverSound.Play(); // This plays some sound
-* gameOverScreen.Show(); // This shows some screen
-* }
-* }
-* This raises a couple of problems:
- * The Game class has to know about the Sound and Window classes
- * Changes in either of the classes could break the code
- * = Game is dependent of Sound and Window classes
----
-
-Tight coupling
+
+
+
+```csharp
+public class Publisher
{
-
-public event GameOver GameOverEventHandler;
-
-// Some game logic here...
-
-// ...
-
+ public event EventHandler SampleEvent;
+ protected virtual void OnSampleEvent()
+ {
+ SampleEvent?.Invoke(this);
+ }
}
+```
-# Exercise 1: A Rudimentary Event System
-
-Create a console application for controlling a plant treatment system, that has three methods which print the following outputs:
+
+
-| void ReleaseWater() | Releasing water... |
-| :-: | :-: |
-| void ReleaseFertilizer() | Releasing fertilizer... |
-| void IncreaseTemperature() | Increasing temperature... |
+```csharp {7-8}
+class Program
+{
+ static void Main()
+ {
+ var pub = new Publisher();
+
+ pub.SampleEvent +=
+ () => Console.WriteLine("Sample event!");
+
+ pub.OnSampleEvent();
+ }
+}
+```
+
+
+
+
+
+ ```csharp
+ public delegate void GameOverHandler();
+ class Game
+ {
+ public event GameOverHandler GameOver;
+
+ protected virtual void OnGameOver()
+ {
+ GameOver?.Invoke(this);
+ }
+ }
+ ...
+ class Program
+ {
+ static void Main()
+ {
+ var game = new Game();
+ Sound gameOverSound;
+ Window gameOverScreen;
+
+ game.GameOver += gameOverSound.Play;
+ game.GameOver += gameOverScreen.Show;
+ }
+ }
+ ```
+
+
+
+
+1) Declare an event handler delegate (`GameOverHandler`)
+2) Declare an instance of the handler with the `event` keyword (`GameOVer`)
+3) Declare a virtual method that invokes the event
+4) Add methods that subscribe to the event
+
+
+