Q6 - Delegate Async: asynchronous delegate invocation the BeginInvoke…

… method with callback procedures

README.md

@@ -64,7 +64,7 @@ Repeat the exercise using a lambda expression instead of a class.
 
 Modify the code to create a thread that takes an argument ("Hi") and displays it in the console using a lambda expression.
 
-```C#
+```csharp
 Console.WriteLine("Q4 - =======Thread & Thread Param=======");
 Console.WriteLine();
 
@@ -132,10 +132,60 @@ When the async result is completed, it will display "callback end" in red on the
 
 Observe the provided code and understand its functionality.
 
+```csharp
+using System; 
+using System.Collections.Generic; 
+using System.Linq; 
+using System.Text; 
+
+namespace NS_MAIN 
+{ 
+    class Program 
+    { 
+        private delegate void DELG(object o); 
+        static void Main(string[] args) 
+        { 
+            Console.ForegroundColor = ConsoleColor.Yellow; 
+            Console.WriteLine("Initialisation du thread principal...ok"); 
+            DELG delg; 
+            NS_SERVER.CLserver server = new NS_SERVER.CLserver(); 
+            NS_CLIENT.CLclient client1 = new NS_CLIENT.CLclient(server, "C1"); 
+            NS_CLIENT.CLclient client2 = new NS_CLIENT.CLclient(server, "C2"); 
+            string[] messages = {"msg1","msg2","msg3"}; 
+            delg = (o) => 
+                { 
+                    for (int i = 0; i < messages.Length; i++) 
+                    { 
+                        server.Msg = messages[i]; 
+                        System.Threading.Thread.Sleep(4000); 
+                    } 
+                }; 
+            Console.WriteLine("Début traitement asynchrone...ok"); 
+            IAsyncResult asr = delg.BeginInvoke(((object)("nostate")), 
+                (asR)=> 
+                { 
+                    delg.EndInvoke(asR); 
+                    Console.ForegroundColor = ConsoleColor.Yellow; 
+                    Console.WriteLine("Fin traitement asynchrone...ok"); 
+                },delg); 
+            while (!asr.IsCompleted) 
+            { 
+                Console.ForegroundColor = ConsoleColor.Green; 
+                Console.WriteLine("Traitement en cours sur le thread principal"); 
+                System.Threading.Thread.Sleep(3000); 
+            } 
+            Console.Read(); 
+        } 
+    }   
+}
+```
+
 #### B. Display Observation:
 
 Describe the expected output of the code.
 
+![image.png](console-output.png)
+
 #### C. Class Implementation:
 
 Create the CLclient and CLserver classes to achieve the same output as observed in point B.

concurency-workshop/Program.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Runtime.Remoting.Messaging;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
@@ -15,6 +16,8 @@ internal class Program
         delegate int MySecondDelegateMethod(int i2);
         public delegate void ParameterizedDelegate(Object message);
 
+        public delegate void AsyncDelegate(object obj);
+
         /// Q5 pool thread
         public delegate void DelegateThreadFive(Object obj);
 
@@ -188,12 +191,57 @@ static void Main(string[] args)
 
             // Wait for background threads to finish
             mre.WaitOne(); // Block the main thread until the event is signaled
-
+
+            Console.WriteLine();
             Console.WriteLine("Q5 - ==============END=============");
+            Console.WriteLine();
 
-            Console.WriteLine("Main thread terminating...");
 
+            /// -------------------------------
+
+            /// <summary>
+            ///     Q6 - Delegate Async
+            /// </summary>
+
+            Console.WriteLine("Q6 - =======Delegate Async=======");
+
+            AsyncDelegate asyncDelegate = (obj) =>
+            {
+                string msg = obj.ToString();
+                for (int i = 0; i <= 9; i++)
+                {
+                    Thread.Sleep(1000);
+                    Console.WriteLine("Message :" + msg + " #" + (i + 1));
+                }
+            };
+
+            // BeginInvoke method
+            AsyncCallback callback = (IAsyncResult ar) =>
+            {
+                AsyncDelegate delegateInstance = (AsyncDelegate)((AsyncResult)ar).AsyncDelegate;
+                delegateInstance.EndInvoke(ar);
+                Console.ForegroundColor = ConsoleColor.Yellow;
+                Console.WriteLine("Callback completed");
+                Console.ResetColor();
+            };
+
+            // BeginInvoke with callback
+            IAsyncResult asyncResult = asyncDelegate.BeginInvoke("T1", callback, null);
+
+            // asyncResult.AsyncWaitHandle.WaitOne();
+            while (!asyncResult.IsCompleted)
+            {
+                Console.WriteLine("The main thread is waiting for the call back end");
+                Thread.Sleep(2000);
+            }
+            Console.ForegroundColor = ConsoleColor.Red;
+            Console.WriteLine("Callback end");
+            Console.ResetColor();
+
+            Console.WriteLine("Q6 - ==============END=============");
+            Console.WriteLine();
 
+            Console.WriteLine("Main thread terminating...");
         }
     }
 }