Merge branch 'develop' of https://github.com/ReferenceType/NetworkExperiments into develop

Author: ReferenceType

AsyncAutoResetEvent.cs

@@ -0,0 +1,62 @@
+    public class AsyncAutoResetEvent
+    {
+        private readonly static Task completed = Task.FromResult(true);
+        private readonly ConcurrentQueue<TaskCompletionSource<bool>> waiters = new ConcurrentQueue<TaskCompletionSource<bool>>();
+        private bool signaled;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AsyncAutoResetEvent"/>
+        /// class with a Boolean value indicating whether to set the initial state to signaled.
+        /// </summary>
+        /// <param name="signaled">if set to <c>true</c> [signaled].</param>
+        public AsyncAutoResetEvent(bool signaled = false)
+        {
+            this.signaled = signaled;
+        }
+
+        
+        /// <summary>
+        ///    Switches state machine of the current task until the event is signaled,
+        ///    a signal.
+        /// </summary>
+        /// <returns></returns>
+        public Task WaitAsync()
+        {
+            lock (waiters)
+            {
+                if (signaled)
+                {
+                    signaled = false;
+                    return completed;
+                }
+                else
+                {
+                    var tcs = new TaskCompletionSource<bool>();
+                    waiters.Enqueue(tcs);
+                    return tcs.Task;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Sets the state of the event to signaled, allowing one or more waiting tasks to proceed.
+        /// </summary>
+        public void Set()
+        {
+            TaskCompletionSource<bool> toRelease = null;
+            lock (waiters)
+            {
+                if (waiters.Count > 0)
+                {
+                    waiters.TryDequeue(out toRelease);
+                }
+
+                else if (!signaled)
+                    signaled = true;
+
+                if (toRelease != null)
+                    toRelease.SetResult(true);
+            }
+          
+        }
+    }

AsyncManualResetEvent.cs

@@ -0,0 +1,40 @@
+  public class AsyncManualResetEvent
+    {
+        private volatile TaskCompletionSource<bool> completionSource = new TaskCompletionSource<bool>();
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AsyncManualResetEvent"/> class with
+        /// a Boolean value indicating whether to set the initial state to signaled.
+        /// </summary>
+        /// <param name="signaled">if set to <c>true</c> [signaled].</param>
+        public AsyncManualResetEvent( bool signaled )
+        {
+            if (signaled)
+                completionSource.TrySetResult(true);
+        }
+
+        /// <summary>
+        /// Waits the asynchronous.
+        /// </summary>
+        /// <returns></returns>
+        public Task WaitAsync() { return completionSource.Task; }
+
+        /// <summary>
+        ///  Sets the state of the event to signaled, allowing one or more waiting tasks to proceed.
+        /// </summary>
+        public void Set() { completionSource.TrySetResult(true); }
+
+        /// <summary>
+        ///  Sets the state of the event to  non signaled, allowing one or more waiting tasks to await.
+        /// </summary>
+        public void Reset()
+        {
+            while (true)
+            {
+                var tcs = completionSource;
+                if (!tcs.Task.IsCompleted ||
+                    Interlocked.CompareExchange(ref completionSource, new TaskCompletionSource<bool>(), tcs) == tcs)
+                    return;
+            }
+        }
+    }

Clock.cs

@@ -0,0 +1,26 @@
+  public class Clock
+    {
+        public Action OnTick;
+        private System.Threading.Timer timer;
+        private readonly int tickFrequency;
+        public Clock(int tickFrequency)
+        {
+           timer = new System.Threading.Timer(Tick,null,tickFrequency,tickFrequency);
+           this.tickFrequency = tickFrequency;
+        }
+
+        private void Tick(object state)
+        {
+            OnTick?.Invoke();
+        }
+
+        public void Awake()
+        {
+            timer.Change(tickFrequency, tickFrequency);
+        }
+        public void Pause()
+        {
+            timer.Change(Timeout.Infinite, tickFrequency);
+        }
+
+    }

Temp.cs

@@ -0,0 +1,118 @@
+using System;
+using System.Collections.Concurrent;
+using System.Diagnostics;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace ExpressionTree
+{
+    public class Timer
+    {
+        static readonly ConcurrentDictionary<TimerInstance, string> activeTimers = new ConcurrentDictionary<TimerInstance, string>();
+        static readonly ConcurrentBag<TimerInstance> timerPool =  new ConcurrentBag<TimerInstance>();
+
+        static readonly AutoResetEvent a = new AutoResetEvent(false);
+        static int Number = 0;
+        static Timer()
+        {
+            TimerInstance.rec = activeTimers;
+            StartTimerThread();
+        }
+
+        private static void StartTimerThread()
+        {
+            Thread t = new Thread(() => 
+            {
+                SpinWait sw = new SpinWait();
+                Stopwatch stopwatch = new Stopwatch();
+                while (true)
+                {
+                    a.WaitOne();
+                    stopwatch.Restart();
+                    Thread.Sleep(10);
+                    //sw.SpinOnce();
+                    //stopwatch.Stop();
+
+                    Tick(stopwatch);
+                }
+            });
+
+            // t.Start();
+            Looper();
+            
+        }
+        private async static void Looper()
+        {
+            Stopwatch stopwatch = new Stopwatch();
+            while (true)
+            {
+             
+                stopwatch.Restart();
+                await Task.Delay(10).ConfigureAwait(false);
+                Tick(stopwatch);
+            }
+        }
+
+        private static void Tick(Stopwatch sw)
+        {
+            if(activeTimers.Count == 0)
+                return;
+
+            a.Set();
+            foreach (var item in activeTimers)
+            {
+                item.Key.Tick((int)sw.ElapsedMilliseconds);
+            }
+        }
+
+        private static TimerInstance GetTimer()
+        {
+            var timer = new TimerInstance();
+            timer.number = Interlocked.Increment(ref Number);
+            return timer;
+        }
+
+        public static void Wait(int miliseconds,Action OnCompleted)
+        {
+            var timer = GetTimer();
+            timer.remaining = miliseconds;
+            timer.Completed += OnCompleted;
+            activeTimers.TryAdd(timer, null);
+            a.Set();
+        }
+
+        class TimerInstance
+        {
+            public int remaining;
+            public Action Completed;
+            public static ConcurrentDictionary<TimerInstance, string> rec;
+            public static ConcurrentBag<TimerInstance> timerPool;
+            public int number;
+            public void Tick(int dt)
+            {
+                remaining -= dt;
+                if (remaining <= 0)
+                {
+                    Complete();
+                }
+            }
+
+            private void Complete()
+            {
+                rec.TryRemove(this, out _);
+                Completed?.Invoke();
+                Reset();
+            }
+
+            public void Reset()
+            {
+                //remaining = 1000;
+                Completed = null;
+            }
+            public override int GetHashCode()
+            {
+                return number;
+            }
+        }
+    }
+}