基元用户模式构造--互锁构造 Interlocked 实现的异步web请求实例

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace Test
{
    enum CoordinationStatus
    {
        AllDone,
        Cancel,
        Timeout
    }
    class AsyncCoordinator
    {
        private int statusReported = 0;
        private int op_count = 1;

        private Action<CoordinationStatus> callback;
        private Timer timer;

        public void AboutToBegin(int num = 1)
        {
            Interlocked.Add(ref op_count, num);
        }

        public void JustToEnd()
        {
            if (Interlocked.Decrement(ref op_count) == 0)
            {
                ReportStatus(CoordinationStatus.AllDone);
            }
        }

        public void AllBegun(Action<CoordinationStatus> callback, int timeout = Timeout.Infinite)
        {
            this.callback = callback;
            if (timeout != Timeout.Infinite)
            {
                timer = new Timer(Expired, null, timeout, Timeout.Infinite);
            }
            JustToEnd();
        }

        private void Expired(object obj)
        {
            ReportStatus(CoordinationStatus.Cancel);
        }
        public void Cancel()
        {
            ReportStatus(CoordinationStatus.Cancel);
        }
        private void ReportStatus(CoordinationStatus status)
        {
            if (Interlocked.Exchange(ref statusReported, 1) == 0)
            {
                callback(status);
            }
        }



    }

    class MultiWebRequests
    {
        private AsyncCoordinator coordinator = new AsyncCoordinator();

        private Dictionary<string, object> servers = new Dictionary<string, object>(){
            {"http://www.baidu.com",null},
            {"http://www.sina.com",null},
            {"http://www.qq.com",null},
        };

        public MultiWebRequests()
        {

            var http = new HttpClient();
            foreach (var url in servers.Keys)
            {
                //发送了一个请求
                coordinator.AboutToBegin(1);
                http.GetByteArrayAsync(url).ContinueWith(task => GetResult(url, task));
            }
            //所有请求发送完毕
            coordinator.AllBegun(AllDone, Timeout.Infinite);
        }

        private void GetResult(string server, Task<byte[]> task)
        {
            object res;
            if (task.Exception != null)
            {
                res = task.Exception.InnerExceptions;
            }
            else
            {
                res = task.Result.Length;
            }
            servers[server] = res;
            //完成了一个请求
            coordinator.JustToEnd();
        }

        public void Cancel()
        {
            coordinator.Cancel();
        }

        private void AllDone(CoordinationStatus status)
        {
            switch (status)
            {
                case CoordinationStatus.AllDone:
                    Console.WriteLine("allDone: ");

                    foreach (var item in servers)
                    {
                        Console.Write(item.Key);
                        object val = item.Value;
                        if (val is Exception)
                        {
                            Console.WriteLine("Exception: {0}",val.GetType().Name);
                        }
                        else
                        {
                            Console.WriteLine("returned  {0:N0} bytes",val);
                        }
                    }
                    break;
                case CoordinationStatus.Cancel:
                    break;
                case CoordinationStatus.Timeout:
                    break;
                default:
                    break;
            }
        }
    }
}