return_message_from_Queue_with_IAsyncResult, C#

Language: Layout:

//Rextester.Program.Main is the entry point for your code. Don't change it.
//Compiler version 4.0.30319.17929 for Microsoft (R) .NET Framework 4.5

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;
using System.Threading;
using System.Timers;

namespace Rextester
{

/*
		The following code will return (string) result, from <Queue>Messages,
		when this messages will contains in <Queue>Messages,
		or will wait this messages, and don't return nothing.
		
		Only one thread must to be running, to check is there any messages in queue, or not.
		Thread.Sleep(timeout) - not used, because this stopping all program, not the current thread.

Instead this, used currentThread.Suspend(), and currentThread.Resume() and this is triggered, by timer1.

When new request is send, then new thread is opened, and for all previous thread, send the "empty_response".
		
		Else, do not send nothing, and wait the messages in Queue<Messages>, then send this message, and return this as (string) result.
		This string will be added in <Queue>Messages, when timer2 will be triggered, after 2500 milliseconds.

*/
    public class Program
    {
		//	Queue with notification messages. Messages here can be added at any time.
		//	for example, after triggering timer2, after timeout_to_add_messages (2500 milliseconds)
        public static Queue<string> Messages = new Queue<string>();
        
        public static List<Thread> threads = new List<Thread>();     	// Define this List<Thread> threads (new thread for each request).
        public static List<Thread> threads2 = new List<Thread>();     	// Define this List<Thread> threads (new thread for each async method).

public static string result = null;      						// This variable will be used to save the result from wait_result_value() in thread, before return it.

public static bool was_resumed = false;							// This bool variable need to mark the current thread as resumed, after unsuspend the suspended thread.
        
		//first timer will infinity unsuspend the current suspened thread (the last thead in threads list).
		public static System.Timers.Timer aTimer;							//this is a variable with first timer
		public static int timeout_thread_sleep = 500; 						//timeout value to sleep in thread, before check notifications (milliseconds)
		
		public static void SetTimer()	//This method running once, and timer1 will working infinity.
		{								//This need to start timer1, and resume threads, from sleeping, after each OnTimeEvent.
			Console.WriteLine("Set timer1 once");
			aTimer = new System.Timers.Timer(timeout_thread_sleep);					//will working every timeout_thread_sleep milliseconds.
			aTimer.Elapsed += OnTimedEvent;											//run this method, after timeout end.
			aTimer.AutoReset = true;												//try again, and again...
			aTimer.Enabled = true;													//enable timer

//aTimer.Enabled = false;												//or disable
			//aTimer.Start();														//and then, enable by this way
			//aTimer.Stop();														//and disable, by this way...
		}

public static bool use_async_await = true;			//use async-await, using IAsyncResult with BeginInvoke or not? (true/false)
		
		public static void OnTimedEvent(Object source, ElapsedEventArgs e)		//method to unsuspend last thread, when this is suspended.
		{
			List<Thread> thread_list = null;
			
			if(use_async_await == false){
				thread_list = threads;
			}else{
				thread_list = threads2;
			}
			if(thread_list.Count == 0){													//if no any threads in List<Thread> threads
				return;																	//do nothing, and just return;
			}
			if(thread_list[thread_list.Count-1] == null){									//if no any thread, or last thread == null
				return;																	//do nothing and return...
			}
			else{																	//else if there is a thread
				if(was_resumed == false){												//and if this thread not resumed
					thread_list[thread_list.Count-1].Resume();										//try to resume last thread.
					was_resumed = true;														//and mark as resumed.
				}else{																	//if thread already resumed
					return;																	//do nothing, and return;
				}
			}
		}
		
		//________________________________________________________________________________________________________________________
		//BEGIN async-await, using IAsyncResult with BeginInvoke
		public delegate string ReturnHandler(string k);					//Асинхронный делегат, для асинхронизации делегаций асинхронизационалистичных.
		
		public static string async_method()								//Будет ждать, и вернёт res, когда оно появится.
        {
			ReturnHandler handler = new ReturnHandler(long_time_method);		//запускаем 
            IAsyncResult resultObj = handler.BeginInvoke((string)"string1", new AsyncCallback(AsyncCompleted), "Асинхронные вызовы");
			string res = handler.EndInvoke(resultObj);
            return res;
        }
 
		public static string long_time_method(string k)									//метод будет спать, а потом вернёт result
        {
			if(threads2.Count == 0){																						//if no any threads in List<Thread>threads2
				threads2.Add(System.Threading.Thread.CurrentThread);															//add current thread there, as first element.
			}else if(threads2[threads2.Count-1].ManagedThreadId != System.Threading.Thread.CurrentThread.ManagedThreadId){	//if there is already exists some thread.
				threads2.Add(System.Threading.Thread.CurrentThread);															//then add current thread in this list.
				
				foreach(Thread th in threads2.ToArray()){												//And for each old thread
					if(th.ManagedThreadId != System.Threading.Thread.CurrentThread.ManagedThreadId){		//which are not have id of the current thread
						th.Interrupt();																			//interrupt this thread
						th.Abort();																				//abort it
						threads2.Remove(th);																	//and remove this thread from List<Thread>threads2
					}
				}
			}

string result = wait_result_value();		//after this run in the current thread, this recursive method, to return HttpResponse.
			return result;									//and return result, when this result will be returned.
        }
 
		public static void AsyncCompleted(IAsyncResult resObj)							//Сработает, когда result возвращён
        {
            string mes = (string)resObj.AsyncState;
//            Console.WriteLine(mes);
//            Console.WriteLine("Работа асинхронного делегата завершена");
        }
		//END async-await, using IAsyncResult with BeginInvoke
		//________________________________________________________________________________________________________________________

//second timer will add some message in <Queue>Messages, after timeout, to return this.
		public static System.Timers.Timer aTimer2;
		public static int timeout_to_add_messages = 1000; 					//timeout to sleep in thread, before check notifications, milliseconds
		
		public static void SetTimer2()										//timer2 will working once.
		{																	//This need to add some message in <Queue>Messages, afer some time (timeout_to_add_messages).
			Console.WriteLine("Set timer2 once");							//This method running once
			aTimer2 = new System.Timers.Timer(timeout_to_add_messages);		//Will be triggered, after timeout_to_add_messages
			aTimer2.Elapsed += OnTimedEvent2;								//run this method, after timeout end.
			aTimer2.AutoReset = true;										//Do not repead this again and again
			aTimer2.Enabled = true;											//and enable timer
		}
		
        public static int increment_it = 0;
		public static void OnTimedEvent2(Object source, ElapsedEventArgs e)	//Just add some messages in <Queue>Messages
		{
			Messages.Enqueue("This test message"+increment_it+" added in <Queue>Messages, after 2500 milliseconds.");
            increment_it += 1;
		}
		
		public static object _lock = new object();		//lock all variables from modifications, where lock is used.
		
		
		//If previous thread working, and new threads running,
		//need to stop previous thread(s), and return empty_response, there,
		//to leave just one thread, as current, and last in the end of List<Thread> thread;
		//this variable will contains the number of threads to stop this.
		public static int need_stop = 0;

//	This recursive method will wait messages in <Queue>Messages.
		//	When this will be available, method return this.
		//	If new thread started, return "empty response" in old thread(s)
		// 	my_await_method() will wait the end of this recursive method
		public static string wait_result_value(){
			if(Messages.Count > 0){						//if notifications already exists in Messages Queue
				return Messages.Dequeue();					//just return it
			}else{										//else
				if(was_resumed == true){					//if thread was already resumed
					was_resumed = false;						//set this variable as not resumed, and continue
				}else{										//else
					System.Threading.Thread.CurrentThread.Suspend();			//just suspend this thread, to wait resume this, when timer will triggered.
				}
				if(need_stop > 0){							//if need to stop this thread, because many new threads was been already started
					need_stop -= 1;								//decrease this value
					return "empty_response";					//and just return some "empty_reponse".
				}
				return wait_result_value();			//else, try to return message again, after resuming suspended thread, by running this method - recursive.
			}
		}
		
        public static string my_await_method()      //this method will await finish of wait_result_value(), and return this result.
        {
			if(threads.Count==0){					//if no any threads in List<Thread> threads
				threads.Add(null);						//just add one item in List<Thread> threads, with value null
			}
			if(threads[threads.Count-1] != null){	//if last thread in list not null - this thread is still working.
				need_stop += 1;							//so new thread will running, and need to stop that prevous thread(s).
			}

lock(_lock){							//lock variables from modification, when lock-code is still working.
				Thread thread = new Thread(				//run new thread, to return result string, or wait when this value will be updated from Messages Queue.
					() =>
					{
						if( result != null ){			//if (string)result already exists, and not null
							return;							//just return.
						}
						if(use_async_await == false){
							result = wait_result_value();	// Publish the return value, returned from from recursive function wait_result_value()
						}else{
							result = async_method();		// Publish the return value, returned from async_method()
						}
					}
				);
				
				//before after start new thread, check the following thing...
				if(threads[threads.Count-1] == null){	//if last thread is null
					threads[threads.Count-1] = thread;		//this last thread will be the current thread
				}else{									//else
					threads.Add(thread);					//add new thread as new item in list. (just another case)
				}

(threads[threads.Count-1]).Start();			//start last thread
				(threads[threads.Count-1]).Join();			//return value from this thread, after update this value.
				
				//next code will working, after finithing the started thread.
				Console.WriteLine("This code working, after finished the started thread.");
				
				(threads[threads.Count-1]).Interrupt();		//after finish that thread, just interrupt this (maybe no need to do this)

if(threads.Count>1){						//if in the List<Thread> threads, there is more than one thread
					foreach(Thread th in threads){				//for each thread
						th.Abort();									//just abort this all
					}
				}
	
				threads[threads.Count-1] = null;			//set last thread as null, to change this on new thread, when new thread will be started.

string temp_result = result;				//after return result, from previous thread, when this thread will be finished, copy this value
				result = null;								//set result as null again.
				return (string)temp_result;					//and return temp_result as response.
			}
        }

public static void Main(string[] args)
        {
            //Your code goes here
			SetTimer();							//set this timer once, to unsuspend last suspended thread, by timeout.
			SetTimer2();						//some messages will be added in queue, by using this timer.

Console.WriteLine("test request1: "+my_await_method());  //show result, when this will be available.
            //Console.WriteLine("test request2: "+my_await_method());  //2
            //Console.WriteLine("test request3: "+my_await_method());  //3
            //Console.WriteLine("test request4: "+my_await_method());  //4
            //Console.WriteLine("test request5: "+my_await_method());  //5
        }
    }
}

Show compiler warnings [ + ] Show input
Compilation time: 0,16 sec, absolute running time: 1,31 sec, cpu time: 0,11 sec, average memory usage: 24 Mb, average nr of threads: 8, absolute service time: 7,86 sec