using System;

using System.Net;

using System.Threading;

using System.Threading.Tasks;

using RSG;

​

//

// Example of downloading text from a URL using a promise.

//

​

namespace Example

{

    public class Program

    {

        public static void Main(string[] args)

        {

            var running = true;

​

            //var promTaskGoogle = PromiseTask(() => PromiseDownloadAsync<dynamic>("http://www.google.com"));

            var promTaskBroken = PromiseTask(() => DownloadAsync<string>("http://www.kjkjhkjhkjhkh.com"));

            promTaskBroken.Catch(exception =>

                       {

                           Console.WriteLine("Async operation errored.");

                           Console.WriteLine("Error: " + exception.Message);

                           running = false;

                       })

                .Done(result =>

                      {

                          Console.WriteLine("Async operation completed.");

                          Console.WriteLine("Result: " + result);

                          running = false;

                      });

​

            Console.WriteLine("Waiting");

​

            while(running)

            {

                Console.WriteLine("Sleeping...");

                Thread.Sleep(100);

            }

​

            Console.WriteLine("Exiting...");

        }

​

        /// <summary>

        ///     Download text from a URL.

        ///     A promise is returned that is resolved when the download has completed.

        ///     The promise is rejected if an error occurs during download.

        /// </summary>

        private static async Task<IPromise<T>> PromiseDownloadAsync<T>(string url) where T : class

        {

            Console.WriteLine("Downloading " + url + " ...");

​

            var promise = new Promise<T>();

​

            using(var client = new WebClient())

            {

                var task = client.DownloadStringTaskAsync(new Uri(url));

                try

                {

                    var result = await task;

                    // Downloaded completed successfully, resolve the promise with anonymous object.

                    promise.Resolve(result as T);

                    Console.WriteLine("... Download completed.");

                } catch(Exception ex)

                {

                    Console.WriteLine("An error occurred... rejecting the promise.");

​

                    // Error during download, reject the promise.

                    promise.Reject(ex);

                }

            }

​

            return promise;

        }

        private static async Task<T> DownloadAsync<T>(string url) where T : class

        {

            Console.WriteLine("Downloading " + url + " ...");

            using(var client = new WebClient())

            {

                var task = client.DownloadStringTaskAsync(new Uri(url));

                try

                {

                    var result = await task;

                    Console.WriteLine("Download completed.");                                       

                    // Downloaded completed successfully, resolve the promise with anonymous object.

                    return result as T;

                } catch(Exception)                {

                    Console.WriteLine("An error occurred....");

                    return null;           

                }

            }

        }

​

​

        /// <summary>

        ///     Wraps awaitable async tasks in a Promise

        /// </summary>

        public static IPromise<T> PromiseTask<T>(Func<Task<IPromise<T>>> asyncTask) where T : class

        {

            var promise = new Promise<T>();

            // Wait for the async task to complete then resolve or reject the promise.

            asyncTask().ContinueWith(result =>

                                {

                                    result.Result

                                        .Then(res => { promise.Resolve(res); })

                                        .Catch(err => { promise.Reject(err); });

                                });

​

             return promise;

        }

         /// <summary>

        ///     Wraps awaitable async tasks in a Promise

        /// </summary>

        public static IPromise<T> PromiseTask<T>(Func<Task<T>> asyncTask) where T : class

        {

            var promise = new Promise<T>();

            // Wait for the async task to complete then resolve or reject the promise.

            asyncTask().ContinueWith(result =>

                                {

                                    var resultAsRask = result as Task<T>;

                                    if(resultAsRask.Status == TaskStatus.RanToCompletion && resultAsRask.Result != null){

                                        promise.Resolve(resultAsRask.Result);

                                    }else{

                                        promise.Reject(new Exception("Task failed"));

                                    }                                    

                                });

​

             return promise;

        }

    }

}