C# Async/Await 异步操作

异步编程的核心是使用多线程，通过让不同的线程执行不同的任务，从而实现异步编程。

Demo:

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

namespace DemoAsync
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Task Start !");
            //DotaskWithThread();
            DOTaskWithAsync();
            Console.WriteLine("Task End !");
            Console.ReadLine();

        }

        public static async void DOTaskWithAsync()
        { 
            Console.WriteLine("Await Taskfunction Start");
            await Task.Run(()=> {
                Dotaskfunction();
                }); 
        }
        public static void Dotaskfunction()
            {
            for (int i = 0; i <= 5; i++) {

                Console.WriteLine("task {0}  has been done!",i);
            } 
            } 

    }
}

应用实例：

public static void InterfaceTest() //OperationResult InterfaceTest()
{
OperationResult returnResult = new OperationResult();
var request = new Request(); 
string user = "{ "UserName":"admin","Password":"admin"}";
string url = "http://127.0.0.1:8010/api/admin/auth/login";
var r = Multek.Net.Request.Send(url, HttpMethod.POST, user);
if (r.Success)
{
dynamic obj = r.Data.ToString().ToDynamicObject();
if (obj.msg == "success")
{
var objd = obj.data as dynamic;
string accToken = objd.accessToken;
string url2 = "http://127.0.0.1:8010/api/cu_int_equipment";
Dictionary<string, string> headers = new Dictionary<string, string>();
//headers.Add("Authorization", "1e90618fc-2e3db-4f36-983a-6c7258b720e5");
headers.Add("Authorization","Bearer " + accToken);
BaseManager bm = new BaseManager();
DataTable dt = bm.FillTable("SELECT * FROM [dbo].[t_EquipMaster] "); 
var data = JsonConvert.SerializeObject(dt);

var data = new[] { new { equipment = EquipID, equipmentType = "", status = BDorPM, remark = "" }, };
var datajson = JsonConvert.SerializeObject(data);

DOTaskWithAsync(data);   //异步调用另外一个操作
returnResult = Request.Send(url2, HttpMethod.POST, data, headers, "application/json");
}
}
//return returnResult;
}

public static async void DOTaskWithAsync(object data)
{
Console.WriteLine("Await Taskfunction Start");
await Task.Run(() => {
InterfacePortal.EventDistributorAPI eda = new InterfacePortal.EventDistributorAPI();
var res = eda.FireEvent<dynamic>("Equipment", data);
});
}

 /// <summary>
        /// 使用GET方式发送一个HTTP请求并返回其响应
        /// </summary>
        /// <param name="url">请求路径</param>
        /// <returns>如果请求成功，请求结果通过OperationResult.Data返回（注意检查调用目标的返回结果）。</returns>
        public static OperationResult Send(string url)
        {
            return Send(url, HttpMethod.GET, new JsonParameters(), null,"");
        }

        /// <summary>
        /// 使用GET方式发送一个HTTP请求并返回其响应
        /// </summary>
        /// <param name="url">请求路径</param>
        /// <param name="parameters">参数</param>
        /// <returns>如果请求成功，请求结果通过OperationResult.Data返回（注意检查调用目标的返回结果）。</returns>
        public static OperationResult Send(string url, JsonParameters parameters)
        {
            return Send(url, HttpMethod.GET, parameters, null,"");
        }

        /// <summary>
        /// 使用指定的方式发送一个请求
        /// </summary>
        /// <param name="url">请求路径</param>
        /// <param name="method">请求方式</param>
        /// <param name="parameters">参数</param>
        /// <returns>如果请求成功，请求结果通过OperationResult.Data返回（注意检查调用目标的返回结果）。</returns>
        public static OperationResult Send(string url,HttpMethod method, JsonParameters parameters)
        {
            return Send(url, method, parameters, null, "");
        }

        /// <summary>
        /// 使用指定的方式发送一个请求
        /// </summary>
        /// <param name="url">请求路径</param>
        /// <param name="method">请求方式</param>
        /// <param name="parameters">参数</param>
        /// <param name="headers">请求头设置</param>
        /// <param name="contentType">参数内容类型</param>
        /// <returns>如果请求成功，请求结果通过OperationResult.Data返回（注意检查调用目标的返回结果）。</returns>
        public static OperationResult Send(string url, HttpMethod method, JsonParameters parameters, Dictionary<string, string> headers, ContentType contentType)
        {
            return Send(url, method, parameters, headers, GetContentType(contentType));
        }

        /// <summary>
        /// 使用指定的方式发送一个请求
        /// </summary>
        /// <param name="url">请求路径</param>
        /// <param name="method">请求方式</param>
        /// <param name="jsonparameter">JSON格式的参数</param>
        /// <returns>如果请求成功，请求结果通过OperationResult.Data返回（注意检查调用目标的返回结果）。</returns>
        public static OperationResult Send(string url, HttpMethod method, string jsonparameter)
        {
            return Send(url, method, jsonparameter, null, GetContentType(ContentType.JSON));
        }

        /// <summary>
        /// 使用指定的方式发送一个请求
        /// </summary>
        /// <param name="url">请求路径</param>
        /// <param name="method">请求方式</param>
        /// <param name="headers">请求头设置</param>
        /// <param name="jsonparameter">JSON格式的参数</param>
        /// <returns></returns>
        public static OperationResult Send(string url, HttpMethod method,Dictionary<string,string> headers, string jsonparameter)
        {
            return Send(url, method, jsonparameter,headers, GetContentType(ContentType.JSON));
        }

        /// <summary>
        /// 使用指定的方式发送一个请求
        /// </summary>
        /// <param name="url">请求路径</param>
        /// <param name="method">请求方式</param>
        /// <param name="jsonparameter">JSON格式的参数</param>
        /// <param name="headers">请求头设置</param>
        /// <param name="contentType">参数内容类型</param>
        /// <returns>如果请求成功，请求结果通过OperationResult.Data返回（注意检查调用目标的返回结果）。</returns>
        public static OperationResult Send(string url, HttpMethod method, string jsonparameter, Dictionary<string, string> headers, string contentType)
        {
            OperationResult result = new OperationResult();
            var httpStatus = HttpStatusCode.ServiceUnavailable;
            Encoding Charset = Encoding.UTF8;
            string responseContext = "";
            HttpWebResponse response = null;
            try
            {
                var requesturl = method != HttpMethod.POST && jsonparameter.Length>0? url + "?json=" +jsonparameter : url;
                ServicePointManager.ServerCertificateValidationCallback = new RemoteCertificateValidationCallback(CheckValidationResult);
                var request = (HttpWebRequest)WebRequest.Create(requesturl);
                request.Method = method.ToString();
                request.ContentType = contentType;
                request.PreAuthenticate = true;
                request.UseDefaultCredentials = true;
                if (headers != null)
                {
                    foreach (var h in headers.Keys)
                    {
                        request.Headers.Add(h, headers[h]);
                    }
                }
                if (method == HttpMethod.POST)
                {
                    Byte[] body = Charset.GetBytes(jsonparameter);
                    request.ContentLength = body.Length;
                    using (Stream os = request.GetRequestStream())
                    {
                        os.Write(body, 0, body.Length);
                    }
                }
                else request.ContentLength = 0;
                response = (HttpWebResponse)request.GetResponse();
                httpStatus = response.StatusCode;
                using (Stream stream = response.GetResponseStream())
                {
                    StreamReader sr = new StreamReader(stream, Charset);
                    responseContext = sr.ReadToEnd().Trim();
                    result.Data = responseContext;
                }
                response.Close();
            }
            catch (WebException we)
            {
                HttpWebResponse httpResp = (HttpWebResponse)we.Response;
                result.Errors.Add("内部错误:" + httpStatus + ",message:" + we.Message);
            }
            return result;
        }
        
        /// <summary>
        /// 发送一个HTTP请求并返回其响应
        /// </summary>
        /// <param name="url">请求路径</param>
        /// <param name="method">请求方式</param>
        /// <param name="parameters">参数</param>
        /// <param name="headers">请求头设置</param>
        /// <returns>如果请求成功，请求结果通过OperationResult.Data返回（注意检查调用目标的返回结果）。</returns>
        public static OperationResult Send(string url, HttpMethod method, JsonParameters parameters, Dictionary<string, string> headers,string contentType)
        {
            OperationResult result = new OperationResult();
            if (parameters == null)
                parameters = new JsonParameters();
            var httpStatus = HttpStatusCode.ServiceUnavailable;
            Encoding Charset = Encoding.UTF8;
            string responseContext = "";
            HttpWebResponse response = null;
            try
            {
                var requesturl = method != HttpMethod.POST && parameters.Count>0 ? url +"?"+ parameters.ToString() : url;
                ServicePointManager.ServerCertificateValidationCallback = new RemoteCertificateValidationCallback(CheckValidationResult);
                var request = (HttpWebRequest)WebRequest.Create(requesturl);
                request.Method = method.ToString();
                request.ContentType = contentType;
                request.PreAuthenticate = true;
                request.UseDefaultCredentials = true;
                if (headers != null)
                {
                    foreach (var h in headers.Keys)
                    {
                        request.Headers.Add(h, headers[h]);
                    }
                }
                if (method == HttpMethod.POST && parameters.Count > 0)
                {
                    Byte[] body = Charset.GetBytes(parameters.ToJsonString());
                    request.ContentLength = body.Length;
                    using (Stream os = request.GetRequestStream())
                    {
                        os.Write(body, 0, body.Length);
                    }
                }
                else request.ContentLength = 0;
                response = (HttpWebResponse)request.GetResponse();
                httpStatus = response.StatusCode;
                using (Stream stream = response.GetResponseStream())
                {
                    StreamReader sr = new StreamReader(stream, Charset);
                    responseContext = sr.ReadToEnd().Trim();
                    result.Data = responseContext;
                }
                response.Close();
            }
            catch (WebException we)
            {
                HttpWebResponse httpResp = (HttpWebResponse)we.Response;
                result.Errors.Add("内部错误:" + httpStatus + ",message:" + we.Message);
            }
            return result;
        }