Promises in C# | C# Online Compiler

Promises in C# by GFoley83

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

public class Program
{
	public static void Main()
	{
		Action<string> callbackThatWillUseTheResolvedString = Console.WriteLine;
		Action<string> callbackWithAHardCodedString = i => Console.WriteLine("Here is the hard coded string.");
		
		var callbackList = new List<Action<string>>
		{
			callbackThatWillUseTheResolvedString, callbackWithAHardCodedString
		};
		
		var deferred = new Deferred<string>();
		var promise = deferred.Promise();
		
		
		promise.Done(callbackList);
		promise.Fail(i => Console.WriteLine(i));
		promise.Always(() => Console.WriteLine("Finished."));
		
		// Do something here...
		
		// And then later...
		deferred.Resolve("This string was passed into the resolved method.");
		//deferred.Reject("Got rejected");
	}
	
	
	// PROMISE LIBRARY - https://gist.github.com/cuppster/3612000

	public interface Promise
	{
		Promise Done(Action callback);
		Promise Fail(Action callback);
		Promise Always(Action callback);
		bool IsRejected
		{
			get;
		}

		bool IsResolved
		{
			get;
		}

		bool IsFulfilled
		{
			get;
		}
	}

	public interface Promise<T> : Promise
	{
		Promise<T> Done(Action<T> callback);
		Promise<T> Done(IEnumerable<Action<T>> callbacks);
		Promise<T> Fail(Action<T> callback);
		Promise<T> Fail(IEnumerable<Action<T>> callbacks);
		Promise<T> Always(Action<T> callback);
		Promise<T> Always(IEnumerable<Action<T>> callbacks);
	}

	public class Deferred : Deferred<object>
	{
	// generic object
	}

	public class Deferred<T> : Promise<T>
	{
		private List<Callback> callbacks = new List<Callback>();
		protected bool _isResolved = false;
		protected bool _isRejected = false;
		private T _arg;
		public static Promise When(IEnumerable<Promise> promises)
		{
			var count = 0;
			var masterPromise = new Deferred();
			foreach (var p in promises)
			{
				count++;
				p.Fail(() =>
				{
					masterPromise.Reject();
				}

				);
				p.Done(() =>
				{
					count--;
					if (0 == count)
					{
						masterPromise.Resolve();
					}
				}

				);
			}

			return masterPromise;
		}

		public static Promise When(object d)
		{
			var masterPromise = new Deferred();
			masterPromise.Resolve();
			return masterPromise;
		}

		public static Promise When(Deferred d)
		{
			return d.Promise();
		}

		public static Promise<T> When(Deferred<T> d)
		{
			return d.Promise();
		}

		public Promise<T> Promise()
		{
			return this;
		}

		public Promise Always(Action callback)
		{
			if (_isResolved || _isRejected)
				callback();
			else
				callbacks.Add(new Callback(callback, Callback.Condition.Always, false));
			return this;
		}

		public Promise<T> Always(Action<T> callback)
		{
			if (_isResolved || _isRejected)
				callback(_arg);
			else
				callbacks.Add(new Callback(callback, Callback.Condition.Always, true));
			return this;
		}

		public Promise<T> Always(IEnumerable<Action<T>> callbacks)
		{
			foreach (Action<T> callback in callbacks)
				this.Always(callback);
			return this;
		}

		public Promise Done(Action callback)
		{
			if (_isResolved)
				callback();
			else
				callbacks.Add(new Callback(callback, Callback.Condition.Success, false));
			return this;
		}

		public Promise<T> Done(Action<T> callback)
		{
			if (_isResolved)
				callback(_arg);
			else
				callbacks.Add(new Callback(callback, Callback.Condition.Success, true));
			return this;
		}

		public Promise<T> Done(IEnumerable<Action<T>> callbacks)
		{
			foreach (Action<T> callback in callbacks)
				this.Done(callback);
			return this;
		}

		public Promise Fail(Action callback)
		{
			if (_isRejected)
				callback();
			else
				callbacks.Add(new Callback(callback, Callback.Condition.Fail, false));
			return this;
		}

		public Promise<T> Fail(Action<T> callback)
		{
			if (_isRejected)
				callback(_arg);
			else
				callbacks.Add(new Callback(callback, Callback.Condition.Fail, true));
			return this;
		}

		public Promise<T> Fail(IEnumerable<Action<T>> callbacks)
		{
			foreach (Action<T> callback in callbacks)
				this.Fail(callback);
			return this;
		}

		public bool IsRejected
		{
			get
			{
				return _isRejected;
			}
		}

		public bool IsResolved
		{
			get
			{
				return _isResolved;
			}
		}

		public bool IsFulfilled
		{
			get
			{
				return _isRejected || _isResolved;
			}
		}

		public Promise Reject()
		{
			if (_isRejected || _isResolved) // ignore if already rejected or resolved
				return this;
			_isRejected = true;
			DequeueCallbacks(Callback.Condition.Fail);
			return this;
		}

		public Deferred<T> Reject(T arg)
		{
			if (_isRejected || _isResolved) // ignore if already rejected or resolved
				return this;
			_isRejected = true;
			this._arg = arg;
			DequeueCallbacks(Callback.Condition.Fail);
			return this;
		}

		public Promise Resolve()
		{
			if (_isRejected || _isResolved) // ignore if already rejected or resolved
				return this;
			this._isResolved = true;
			DequeueCallbacks(Callback.Condition.Success);
			return this;
		}

		public Deferred<T> Resolve(T arg)
		{
			if (_isRejected || _isResolved) // ignore if already rejected or resolved
				return this;
			this._isResolved = true;
			this._arg = arg;
			DequeueCallbacks(Callback.Condition.Success);
			return this;
		}

		private void DequeueCallbacks(Callback.Condition cond)
		{
			foreach (Callback callback in callbacks)
			{
				if (callback.Cond == cond || callback.Cond == Callback.Condition.Always)
				{
					if (callback.IsReturnValue)
						callback.Del.DynamicInvoke(_arg);
					else
						callback.Del.DynamicInvoke();
				}
			}

			callbacks.Clear();
		}
	}

	class Callback
	{
		public enum Condition
		{
			Always,
			Success,
			Fail
		}

		;
		public Callback(Delegate del, Condition cond, bool returnValue)
		{
			Del = del;
			Cond = cond;
			IsReturnValue = returnValue;
		}

		public bool IsReturnValue
		{
			get;
			private set;
		}

		public Delegate Del
		{
			get;
			private set;
		}

		public Condition Cond
		{
			get;
			private set;
		}
	}
}

​x
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
​
public class Program
{
    public static void Main()
    {
        Action<string> callbackThatWillUseTheResolvedString = Console.WriteLine;
        Action<string> callbackWithAHardCodedString = i => Console.WriteLine("Here is the hard coded string.");
        
        var callbackList = new List<Action<string>>
        {
            callbackThatWillUseTheResolvedString, callbackWithAHardCodedString
        };
        
        var deferred = new Deferred<string>();
        var promise = deferred.Promise();
        
        
        promise.Done(callbackList);
        promise.Fail(i => Console.WriteLine(i));
        promise.Always(() => Console.WriteLine("Finished."));
        
        // Do something here...
        
        // And then later...
        deferred.Resolve("This string was passed into the resolved method.");
        //deferred.Reject("Got rejected");
    }
    
    
    // PROMISE LIBRARY - https://gist.github.com/cuppster/3612000
​
    public interface Promise
    {
        Promise Done(Action callback);
        Promise Fail(Action callback);
        Promise Always(Action callback);
        bool IsRejected
        {
            get;
        }
​
        bool IsResolved
        {
            get;
        }
​
        bool IsFulfilled
        {
            get;
        }
    }
​
    public interface Promise<T> : Promise
    {
        Promise<T> Done(Action<T> callback);
        Promise<T> Done(IEnumerable<Action<T>> callbacks);
        Promise<T> Fail(Action<T> callback);
        Promise<T> Fail(IEnumerable<Action<T>> callbacks);
        Promise<T> Always(Action<T> callback);
        Promise<T> Always(IEnumerable<Action<T>> callbacks);
    }
​
    public class Deferred : Deferred<object>
    {
    // generic object
    }
​
    public class Deferred<T> : Promise<T>
    {
        private List<Callback> callbacks = new List<Callback>();
        protected bool _isResolved = false;
        protected bool _isRejected = false;
        private T _arg;
        public static Promise When(IEnumerable<Promise> promises)
        {
            var count = 0;
            var masterPromise = new Deferred();
            foreach (var p in promises)
            {
                count++;
                p.Fail(() =>
                {
                    masterPromise.Reject();
                }
​
                );
                p.Done(() =>
                {
                    count--;
                    if (0 == count)
                    {
                        masterPromise.Resolve();
                    }
                }
​
                );
            }
​
            return masterPromise;
        }
​
        public static Promise When(object d)
        {
            var masterPromise = new Deferred();
            masterPromise.Resolve();
            return masterPromise;
        }
​
        public static Promise When(Deferred d)
        {
            return d.Promise();
        }
​
        public static Promise<T> When(Deferred<T> d)
        {
            return d.Promise();
        }
​
        public Promise<T> Promise()
        {
            return this;
        }
​
        public Promise Always(Action callback)
        {
            if (_isResolved || _isRejected)
                callback();
            else
                callbacks.Add(new Callback(callback, Callback.Condition.Always, false));
            return this;
        }
​
        public Promise<T> Always(Action<T> callback)
        {
            if (_isResolved || _isRejected)
                callback(_arg);
            else
                callbacks.Add(new Callback(callback, Callback.Condition.Always, true));
            return this;
        }
​
        public Promise<T> Always(IEnumerable<Action<T>> callbacks)
        {
            foreach (Action<T> callback in callbacks)
                this.Always(callback);
            return this;
        }
​
        public Promise Done(Action callback)
        {
            if (_isResolved)
                callback();
            else
                callbacks.Add(new Callback(callback, Callback.Condition.Success, false));
            return this;
        }
​
        public Promise<T> Done(Action<T> callback)
        {
            if (_isResolved)
                callback(_arg);
            else
                callbacks.Add(new Callback(callback, Callback.Condition.Success, true));
            return this;
        }
​
        public Promise<T> Done(IEnumerable<Action<T>> callbacks)
        {
            foreach (Action<T> callback in callbacks)
                this.Done(callback);
            return this;
        }
​
        public Promise Fail(Action callback)
        {
            if (_isRejected)
                callback();
            else
                callbacks.Add(new Callback(callback, Callback.Condition.Fail, false));
            return this;
        }
​
        public Promise<T> Fail(Action<T> callback)
        {
            if (_isRejected)
                callback(_arg);
            else
                callbacks.Add(new Callback(callback, Callback.Condition.Fail, true));
            return this;
        }
​
        public Promise<T> Fail(IEnumerable<Action<T>> callbacks)
        {
            foreach (Action<T> callback in callbacks)
                this.Fail(callback);
            return this;
        }
​
        public bool IsRejected
        {
            get
            {
                return _isRejected;
            }
        }
​
        public bool IsResolved
        {
            get
            {
                return _isResolved;
            }
        }
​
        public bool IsFulfilled
        {
            get
            {
                return _isRejected || _isResolved;
            }
        }
​
        public Promise Reject()
        {
            if (_isRejected || _isResolved) // ignore if already rejected or resolved
                return this;
            _isRejected = true;
            DequeueCallbacks(Callback.Condition.Fail);
            return this;
        }
​
        public Deferred<T> Reject(T arg)
        {
            if (_isRejected || _isResolved) // ignore if already rejected or resolved
                return this;
            _isRejected = true;
            this._arg = arg;
            DequeueCallbacks(Callback.Condition.Fail);
            return this;
        }
​
        public Promise Resolve()
        {
            if (_isRejected || _isResolved) // ignore if already rejected or resolved
                return this;
            this._isResolved = true;
            DequeueCallbacks(Callback.Condition.Success);
            return this;
        }
​
        public Deferred<T> Resolve(T arg)
        {
            if (_isRejected || _isResolved) // ignore if already rejected or resolved
                return this;
            this._isResolved = true;
            this._arg = arg;
            DequeueCallbacks(Callback.Condition.Success);
            return this;
        }
​
        private void DequeueCallbacks(Callback.Condition cond)
        {
            foreach (Callback callback in callbacks)
            {
                if (callback.Cond == cond || callback.Cond == Callback.Condition.Always)
                {
                    if (callback.IsReturnValue)
                        callback.Del.DynamicInvoke(_arg);
                    else
                        callback.Del.DynamicInvoke();
                }
            }
​
            callbacks.Clear();
        }
    }
​
    class Callback
    {
        public enum Condition
        {
            Always,
            Success,
            Fail
        }
​
        ;
        public Callback(Delegate del, Condition cond, bool returnValue)
        {
            Del = del;
            Cond = cond;
            IsReturnValue = returnValue;
        }
​
        public bool IsReturnValue
        {
            get;
            private set;
        }
​
        public Delegate Del
        {
            get;
            private set;
        }
​
        public Condition Cond
        {
            get;
            private set;
        }
    }
}

View IL Code