以前研究過c#的async和await關鍵字，幕後幹了什麼，可是不知道爲何找不到相關資料了。如今從新研究一遍，順便記錄下來，方便之後查閱。

基礎知識

async 關鍵字標註一個方法，該方法返回值是一個Task、或者Task<TResult>、void、包含GetAwaiter方法的類型。該方法一般包含一個await表達式。該表達式標註一個點，將被某個異步方法回跳到該點。而且，當前函數執行到該點，將馬上返回控制權給調用方。

以上描述了async方法想幹的事情，至於如何實現，這裏就不涉獵了。

我的看法

由此能夠知道，async 和await關鍵字主要目的是爲了控制異步線程的同步，讓一個異步過程，表現得好像同步過程同樣。

好比async 方法分n個任務去下載網頁並進行處理：先await下載，而後馬上返回調用方，以後的處理就由異步線程完成下載後調用。這時候調用方能夠繼續執行它的任務，不過，若是調用方馬上就須要async的結果，那麼應該就只能等待，不過大多數狀況：他暫時不須要這個結果，那麼就能夠並行處理這些代碼。

可見，並行性體如今await 上，若是await 點和最終的數據結果距離越遠，那麼並行度就越高。若是await的點越多，相信也會改善並行性。

資料顯示，async 和await 關鍵字並不會建立線程，這是很關鍵的一點。他們只是建立了一個返回點，提供給須要他的線程使用。那麼線程到底是誰建立？注意await 表達式的組成，他須要一個Task，一個Task並不表明必定要建立線程，也能夠是另外一個async方法，可是層層包裹最裏面的方法，極可能就是一個原生的Task，好比await Task.Run(()=>Thread.Sleep(0)); ，這個真正產生線程的語句，就會根據前面那些await點，逐個回調。

從這點來看，async 方法，未必就是一個異步方法，他在語義上更加貼近「非阻塞」, 當遇到阻塞操做，馬上用await定點返回，至於其餘更深一層的解決手段，它就不關心了。這是程序員須要關心的，程序員須要用真正的建立線程代碼，來完成異步操做（固然這一步可由庫程序員完成）。

注意async的幾個返回值類型，這表明了不一樣的使用場景。若是是void，說明客戶端不關心數據同步問題，它只須要線程的控制權馬上返回。能夠用在ui 等場合，若是是Task，客戶端也不關心數據，可是它但願可以控制異步線程，這多是對任務執行順序有必定的要求。固然，最多見的是Task<TResult>。

綜上，async和await並非爲了多任務而設計的，若是追求高併發，應該在async函數內部用Task好好設計一番。在使用async 和await的時候，只須要按照非阻塞的思路去編寫代碼就能夠了，至於幕後怎麼處理就交給真正的多線程代碼建立者吧。

示範代碼

並行編碼方法

並行執行有幾個方法，第一個是建立n個Task，一塊兒啓動。問題是怎麼處理await點。每一個task寫一個await點是不行的，由於遇到第一個await就馬上返回，而不會開啓全部任務並行執行。所以await不能隨便放。那麼如何爲一組Task設定await點呢？能夠經過Task.WhenAll 這個方法，他會等待一組Task執行完畢返回。

特定狀況下，能夠用Parallel.For 來開啓一組任務，可是這個類並無實現async模式，也就是它會阻塞當前線程，因此須要用一個Task來包裹它。

C# Task用法

一、Task的優點
　　ThreadPool相比Thread來講具有了不少優點，可是ThreadPool卻又存在一些使用上的不方便。好比：
　　◆ ThreadPool不支持線程的取消、完成、失敗通知等交互性操做；
　　◆ ThreadPool不支持線程執行的前後次序；
　　以往，若是開發者要實現上述功能，須要完成不少額外的工做，如今，FCL中提供了一個功能更強大的概念：Task。Task在線程池的基礎上進行了優化，並提供了更多的API。在FCL4.0中，若是咱們要編寫多線程程序，Task顯然已經優於傳統的方式。
　　如下是一個簡單的任務示例：

using System;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            Task t = new Task(() =>
            {
                Console.WriteLine("任務開始工做……");
                //模擬工做過程
                Thread.Sleep(5000);
            });
            t.Start();
            t.ContinueWith((task) =>
            {
                Console.WriteLine("任務完成，完成時候的狀態爲：");
                Console.WriteLine("IsCanceled={0}\tIsCompleted={1}\tIsFaulted={2}", task.IsCanceled, task.IsCompleted, task.IsFaulted);
            });
            Console.ReadKey();
        }
    }
}

二、Task的用法
　　2.一、建立任務
　　無返回值的方式
　　方式1:
　　var t1 = new Task(() => TaskMethod("Task 1"));
　　t1.Start();
　　Task.WaitAll(t1);//等待全部任務結束
　　注:
　　任務的狀態:
　　Start以前爲:Created
　　Start以後爲:WaitingToRun

　　方式2:
　　Task.Run(() => TaskMethod("Task 2"));

　　方式3:
　　Task.Factory.StartNew(() => TaskMethod("Task 3")); 直接異步的方法
　　或者
　　var t3=Task.Factory.StartNew(() => TaskMethod("Task 3"));
　　Task.WaitAll(t3);//等待全部任務結束
　　注:
　　任務的狀態:
　　Start以前爲:Running
　　Start以後爲:Running

using System;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            var t1 = new Task(() => TaskMethod("Task 1"));
            var t2 = new Task(() => TaskMethod("Task 2"));
            t2.Start();
            t1.Start();
            Task.WaitAll(t1, t2);
            Task.Run(() => TaskMethod("Task 3"));
            Task.Factory.StartNew(() => TaskMethod("Task 4"));
            //標記爲長時間運行任務,則任務不會使用線程池,而在單獨的線程中運行。
            Task.Factory.StartNew(() => TaskMethod("Task 5"), TaskCreationOptions.LongRunning);

            #region 常規的使用方式
            Console.WriteLine("主線程執行業務處理.");
            //建立任務
            Task task = new Task(() =>
            {
                Console.WriteLine("使用System.Threading.Tasks.Task執行異步操做.");
                for (int i = 0; i < 10; i++)
                {
                    Console.WriteLine(i);
                }
            });
            //啓動任務,並安排到當前任務隊列線程中執行任務(System.Threading.Tasks.TaskScheduler)
            task.Start();
            Console.WriteLine("主線程執行其餘處理");
            task.Wait();
            #endregion

            Thread.Sleep(TimeSpan.FromSeconds(1));
            Console.ReadLine();
        }

        static void TaskMethod(string name)
        {
            Console.WriteLine("Task {0} is running on a thread id {1}. Is thread pool thread: {2}",
                name, Thread.CurrentThread.ManagedThreadId, Thread.CurrentThread.IsThreadPoolThread);
        }
    }
}

　　async/await的實現方式:

using System;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    class Program
    {
        async static void AsyncFunction()
        {
            await Task.Delay(1);
            Console.WriteLine("使用System.Threading.Tasks.Task執行異步操做.");
            for (int i = 0; i < 10; i++)
            {
                Console.WriteLine(string.Format("AsyncFunction:i={0}", i));
            }
        }

        public static void Main()
        {
            Console.WriteLine("主線程執行業務處理.");
            AsyncFunction();
            Console.WriteLine("主線程執行其餘處理");
            for (int i = 0; i < 10; i++)
            {
                Console.WriteLine(string.Format("Main:i={0}", i));
            }
            Console.ReadLine();
        }
    }
}

　　帶返回值的方式
　　方式4:
　　Task<int> task = CreateTask("Task 1");
　　task.Start();
　　int result = task.Result;

using System;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    class Program
    {
        static Task<int> CreateTask(string name)
        {
            return new Task<int>(() => TaskMethod(name));
        }

        static void Main(string[] args)
        {
            TaskMethod("Main Thread Task");
            Task<int> task = CreateTask("Task 1");
            task.Start();
            int result = task.Result;
            Console.WriteLine("Task 1 Result is: {0}", result);

            task = CreateTask("Task 2");
            //該任務會運行在主線程中
            task.RunSynchronously();
            result = task.Result;
            Console.WriteLine("Task 2 Result is: {0}", result);

            task = CreateTask("Task 3");
            Console.WriteLine(task.Status);
            task.Start();

            while (!task.IsCompleted)
            {
                Console.WriteLine(task.Status);
                Thread.Sleep(TimeSpan.FromSeconds(0.5));
            }

            Console.WriteLine(task.Status);
            result = task.Result;
            Console.WriteLine("Task 3 Result is: {0}", result);

            #region 常規使用方式
            //建立任務
            Task<int> getsumtask = new Task<int>(() => Getsum());
            //啓動任務,並安排到當前任務隊列線程中執行任務(System.Threading.Tasks.TaskScheduler)
            getsumtask.Start();
            Console.WriteLine("主線程執行其餘處理");
            //等待任務的完成執行過程。
            getsumtask.Wait();
            //得到任務的執行結果
            Console.WriteLine("任務執行結果：{0}", getsumtask.Result.ToString());
            #endregion
        }

        static int TaskMethod(string name)
        {
            Console.WriteLine("Task {0} is running on a thread id {1}. Is thread pool thread: {2}",
                name, Thread.CurrentThread.ManagedThreadId, Thread.CurrentThread.IsThreadPoolThread);
            Thread.Sleep(TimeSpan.FromSeconds(2));
            return 42;
        }

        static int Getsum()
        {
            int sum = 0;
            Console.WriteLine("使用Task執行異步操做.");
            for (int i = 0; i < 100; i++)
            {
                sum += i;
            }
            return sum;
        }
    }
}

async/await的實現:

using System;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    class Program
    {
        public static void Main()
        {
            var ret1 = AsyncGetsum();
            Console.WriteLine("主線程執行其餘處理");
            for (int i = 1; i <= 3; i++)
                Console.WriteLine("Call Main()");
            int result = ret1.Result;                  //阻塞主線程
            Console.WriteLine("任務執行結果：{0}", result);
        }

        async static Task<int> AsyncGetsum()
        {
            await Task.Delay(1);
            int sum = 0;
            Console.WriteLine("使用Task執行異步操做.");
            for (int i = 0; i < 100; i++)
            {
                sum += i;
            }
            return sum;
        }
    }
}

　　2.二、組合任務.ContinueWith
　　簡單Demo:

Program

　　任務的串行:

Program

　　子任務:

Program

　　動態並行(TaskCreationOptions.AttachedToParent) 父任務等待全部子任務完成後整個任務纔算完成

Program

　　2.三、取消任務 CancellationTokenSource

Program

　　2.四、處理任務中的異常
　　單個任務:

Program

　　多個任務:

Program

async/await的方式:

Program

　　2.五、Task.FromResult的應用

Program

　　2.六、使用IProgress實現異步編程的進程通知
　　IProgress<in T>只提供了一個方法void Report(T value)，經過Report方法把一個T類型的值報告給IProgress,而後IProgress<in T>的實現類Progress<in T>的構造函數接收類型爲Action<T>的形參，經過這個委託讓進度顯示在UI界面中。

Program

　　2.七、Factory.FromAsync的應用 (簡APM模式(委託)轉換爲任務)(BeginXXX和EndXXX)
　　帶回調方式的

Program

　　不帶回調方式的

Program

c#源碼的執行過程

我想也許要寫些東西，記錄我作程序員的日子吧

================================================

要講到C#源碼的執行過程首先要提下程序集，由於Clr並非和託管摸塊打交道的，而是和程序集（dll，exe）

一、從哪裏來

程序集是由一個或者多個託管模塊以及資源文件等共同組成的，C#編譯器（csc.exe）再把源碼編程成IL代碼和元數據的時候，會進一步連同資源文件合併成程序集，

實際上就是個PE32文件，裏面包含一個清單文件和多個託管模塊和資源（如圖），另外程序集中還有一些自描述信息。

二、執行過程

　　編譯器生成好程序集之後，若是是可執行的程序集，會在Main方法執行以前，window會預先讀取程序集的頭文件（pe32），若是是x86則開一個32位的進程，x64的就開一個64位的進程

而後在進程空間裏面加載MSCOREE.DLL的x86 或者x64版本或者arm版本，而後進程的主線程會調用MSCOREE.DLL的一個方法，初始化Clr,而Clr會加載程序集exe,再調用其入口方法Main。

3.Main方法內部執行

　在Main執行以前，Clr 會檢測出方法引用的全部類型，（Console）,而後在內存中分配對應數據類型的空間，這個地址裏面包含着這個類型全部的方法聲名，每一項都對應着Clr裏面的一個未編檔函數（JITCompiler）

首次運行Main方法的試試JITCompiler會被調用，在這個方法裏面1，負責在方法的實現類型中（console）程序集元數據中查詢該方法的IL方法 2，動態分配內存塊 3，把IL編譯成本機Cpu的指令，存儲到動態分配的空間裏面

4,修改這個條目的地址，使它指向動態分配的地址 5.跳轉到內存塊中的本機代碼執行，這時候執行的就是IL代碼的cpu機器碼

5.在次執行Console.WriteLine的時候，就不會運行JITCompiler,直接運行機器碼

反爬蟲：利用ASP.NET MVC的Filter和緩存（入坑出坑） C#中緩存的使用 C#操做redis WPF 控件庫——可拖動選項卡的TabControl 【Bootstrap系列】詳解Boots

反爬蟲：利用ASP.NET MVC的Filter和緩存（入坑出坑）

C#中緩存的使用

C#操做redis

WPF 控件庫——可拖動選項卡的TabControl

【Bootstrap系列】詳解Bootstrap-table

AutoFac

C# MVC 基於From的身份驗證

event 和delegate的分別

常見的異步方式async 和 await

基礎知識

我的看法

示範代碼

並行編碼方法

C# Task用法

c#源碼的執行過程