C# 對於有使用修飾詞 async 非同步方法內，有沒有使用 await 關鍵字，其這兩種方法會有何差異呢？ 

這篇文章主要是要說明，許多人在使用 C# 撰寫程式碼的時候，經常會寫出 async 修飾詞，設計出一個 async 的方法，不過，在這個方法內卻沒有使用到任何的 await 關鍵字。可是，這樣設計出來的 async 方法是不具備非同步運作的功能喔。

在這篇文章所提到的專案原始碼，可以從 GitHub 下載

關於 async 的使用說明

若在一個 C# 方法內，若有要等候一個非同步工作或者非同步方法的時候，可以使用 await 關鍵字來等候這些作業，不過，當在方法內加入了 await 運算子關鍵字的時候，就需要在該方法簽章中，加入 async。而且，對於 async 修飾詞若加入到方法簽章上的時候，對於該方法的回傳值就僅能夠是 Task, Task, void。

若原先的方法是一個事件 void MyEventHandler(object sender, EventArgs args)，對於 [.NET 標準的事件方法簽章(https://docs.microsoft.com/zh-tw/dotnet/csharp/event-pattern)]，就是使用 void 作為回傳值，因此，對於這樣的方法，需要修正為 async void MyEventHandler(object sender, EventArgs args)。對於該方法不是一個 .NET 標準事件，而且是一般的方法且回傳值為 void : void MyMethod()，這個時候需要將 void 修改成為 Task，其完整的寫法為 async Task MyMethod()。最後，當該方法為一般方法且回傳值為非 void 的型別 : string MyMethod()，當想要修正這個方法為非同步方法的時候，就需要在該方法前面加上 async 修飾詞與使用 Task 的泛型表示方式 async Task<string> MyMethod()

一個沒有使用 await 的非同步方法

在這裡將會檢視兩個範例程式碼，這兩個範例程式碼中，都有設計一個 async Task<string> MyMethodAsync() 方法，不過，其中一個在這個方法內是沒有使用 await 的關鍵字，現在，讓我們來看看這兩種的差別。

第一個就是一個沒有使用 await 的非同步方法，請先觀看底下的範例程式碼，在 MyMethodAsync 非同步方法內，是使用沒有任何的 await 關鍵字，這裡將會使用 Thread.Sleep(3000) 來做到同步休息三秒鐘的行為。

因此，請不要使用任何工具去執行這段範例程式碼，直接觀察看看與模擬執行結果，寫下你認為的輸出結果內容，在這裡僅需要寫下輸出結果是 1,2,3,4 這四個數字的排列順序。

底下是這個 async Task<string> MyMethodAsync() async 方法的實際執行結果，若你所思考的執行結果與這個不同，那麼，這代表你的觀念不正確，簡單的說，若一個有使用 async 的非同步方法，若該方法裡面沒有使用到任何的 await 關鍵字，那麼，這個 async 非同步方法就如同是一個同步方法，也就是我們平常在 .NET C# 程式語言中所設計的方法運作順序相同。而且，從底下的執行結果也看到一個重點，那就是整個執行過程中，並沒有任何非同步的效果，因為，所有程式碼都是在同一個執行緒 Thread 下來運行。

因此，這個範例執行結果為 1 3 4 2

1 (1)
進入到非同步方法
3 (1)
準備離開到非同步方法
4 (1)
2 (1)
呼叫非同步方法結果 My Result
Press any key for continuing...

class Program
{
    static async Task Main(string[] args)
    {
        Console.WriteLine($"1 ({Thread.CurrentThread.ManagedThreadId})");
        var task= MyMethodAsync();
        Console.WriteLine($"2 ({Thread.CurrentThread.ManagedThreadId})");

        string result = await task;
        Console.WriteLine($"呼叫非同步方法結果 {result}");

        Console.WriteLine("Press any key for continuing...");
        Console.ReadKey();
    }
    static async Task<string> MyMethodAsync()
    {
        Console.WriteLine($"進入到非同步方法");
        Console.WriteLine($"3 ({Thread.CurrentThread.ManagedThreadId})");

        Thread.Sleep(3000);

        Console.WriteLine($"準備離開到非同步方法");
        Console.WriteLine($"4 ({Thread.CurrentThread.ManagedThreadId})");

        return "My Result";
    }
}

在 async 非同步方法內使用 await 的執行順序

在第二個範例程式碼與第一個大致完全相同，只不過在 async 非同步方法內，將 Thread.Sleep(3000) 修改成為要使用 await Task.Delay(3000) 表示式。經過這樣修正之後，也就滿足了 async 修飾詞的需求定義，也就是說，要使用到 async 這個修飾詞，該方法內需要有使用到 await 運算子關鍵字。

現在，回想剛剛第一個範例程式碼的執行結果順序內容 : 1 3 4 2，請嘗試觀看底下的程式碼，嘗試自己想像應該是甚麼樣的執行順序，並且請寫下來。

答案似乎有些差異，因為，兩者的輸出內容卻不盡相同，在這個範例中的執行結果為 1 3 2 4，並且看到輸出 4 的時候，所使用到的執行緒與前面三個都不相同；因為這個 async 非同步方法確實是使用非同步的方式來執行，當要等候 await 的工作結束，此時，該async 非同步方法就會立即返回 return 呼叫端，在呼叫端就會繼續往下執行，而在 await 之後的表示式，就會使用非同步的方式來執行相關作業。

一旦非同步工作完成之後，也就是要繼續執行 await 下面的程式碼，因為這是一個 Console 類型專案，所以，將會從執行緒集區 ThreadPool 內取得一個執行緒，繼續往下來執行，這也就是在這裡所看到的結果。

1 (1)
進入到非同步方法
3 (1)
2 (1)
準備離開到非同步方法
4 (4)
呼叫非同步方法結果 My Result
Press any key for continuing...

class Program
{
    static async Task Main(string[] args)
    {
        Console.WriteLine($"1 ({Thread.CurrentThread.ManagedThreadId})");
        var task= MyMethodAsync();
        Console.WriteLine($"2 ({Thread.CurrentThread.ManagedThreadId})");

        string result = await task;
        Console.WriteLine($"呼叫非同步方法結果 {result}");

        Console.WriteLine("Press any key for continuing...");
        Console.ReadKey();
    }
    static async Task<string> MyMethodAsync()
    {
        Console.WriteLine($"進入到非同步方法");
        Console.WriteLine($"3 ({Thread.CurrentThread.ManagedThreadId})");

        await Task.Delay(3000);

        Console.WriteLine($"準備離開到非同步方法");
        Console.WriteLine($"4 ({Thread.CurrentThread.ManagedThreadId})");

        return "My Result";
    }
}

結論與建議

若方法內有使用到 await 關鍵字，要在方法簽章上加入 async 修飾詞，若該方法的回傳值不是 void ，則需要修改回傳值為 Task，若該方法不是一個事件的委派訂閱方法，則需要將 void 替換成為 Task。

若該方法有加入 async 修飾詞，但是裡面卻沒有使用到任何 await 運算子關鍵字，則這個 async 非同步方法，其實就是一個同步方法，並沒有具備非同的運算的效果，而且會有些許的效能損失；這是因為當在這個非同步方法內，不論有沒有使用到 await 關鍵字，只要在方法簽章前面有加上 async修飾詞，在建置這個專案的時候，就會產生該非同步方法需要用到的狀態機類別，而在實際執行這個方法的時候，還是會先產生這個狀態機物件，進行該狀態機的相關初始化設定，接著進入到狀態機內執行，只不過，此時並沒會使用非同步方式來執行，而是使用同步方式執行完成之後，就會離開該狀態機，返回到呼叫端程式碼上。

使用 HttpClient 進行 JWT 身分驗證與呼叫需要授權的 API 和重新更新 Token 權杖的程式設計範例

在這篇文章中，將會使用 HttpClient 這個類別來進行使用者的身分驗證，也就是會呼叫遠端的登入 Web API，一旦使用者輸入的帳號與密碼都正確之後，就會取得一個 JWT 權杖 Token，之後便會使用這個時候取得的 JWT Token來呼叫 Departments 這個 API，取得相關部門清單資訊。

這裡將會產生出許多的問題：當呼叫 Departments API 的時候，若沒有提供 JWT Token，這個時候，後端的 ASP.NET Core Web API 應該會拒絕此次 API 呼叫的請求，另外，對於所提供的 JWT 權杖，若該權杖為一個不正確的權杖或者內容異常，也應該要拒絕此次的 Web API 請求。

另外，一旦使用者身分驗證成功之後，索取的 JWT 權杖僅有 10秒鐘有效期限，在這 10秒內，進行相關需要有授權才能夠呼叫的 API，都沒有問題，可是，超過 10 秒鐘之後，這個 JWT Token 就會失效，沒有作用了，因為時間逾期的原因；這樣的設計都是因為安全上的考量(在這裡設定 10秒鐘，僅僅是為了測試方便之用，若是設計用於行動裝置 App的環境，是可以可慮每次產生一個 JWT Token，將會授與 15分鐘的有效期限)，畢竟，只要使用者取得了 JWT Token，就可以放心、盡情地呼叫需要授權的 API，可是，若該使用者被刪除、或者因為使用者變更密碼，需要請使用者重新登入驗證等各種因素，若發出一個永久有效的 Token，就無法做到這些管控需求。

因此，若 JWT 的有效期限到期之後，此時將會呼叫另外一個可以更新 JWT 權杖的 API，但是，呼叫該 API 也需要提供一個 JWT Token，此時，若傳入剛剛已經逾期的 Token，是無法正常呼叫更新 JWT Token 的 API。所以，在使用者傳入帳號與密碼的身分驗證 API中，若成功的驗證通過其帳號與密碼是正確的，此時，除了會傳會等下要使用呼叫相關 API 的 JWT Token，也會傳回一個 JWT Token，這個 JWT Token 將僅會用於呼叫更新 JWT Token API 之用，無法用於呼叫其他系統內的 API 之用；而且，這個更新用的 JWT Token 的有效期限有比較長，在這個範例中，其有效期限為 7 天。

若使用者超過 7 天都會去呼叫更新 JWT Token的 API，這個時候，這個 Token 也會失效了，這名使用者若想要繼續使用這個系統，唯一的途徑就是重新登入，傳入帳號與密碼，重新進行身分驗證一途。

在這篇文章所提到的專案原始碼，可以從 GitHub 下載

設計符合 RESTful API 設計原則的回傳格式

在這個範例環境中，後端的環境將使用 ASP.NET Core 2.2 來進行開發 Web API 的服務，這個後端的服務設計完全符合 RESTful API 的設計原則，也就是說，每次呼叫這個後端 Web API 服務的時候，不論呼叫是否有成功或者失敗，甚至後端拋出例外異常，都會回傳一致的格式結果，在這裡，不會用戶端傳入的內容，或者回傳的結果內容，都是使用 JSON 的格式。底下是每次呼叫 Web API 之後，後端伺服器回傳結果的標準格式。

從底下的類別 APIResult 類別所定義的屬性，可以透過 APIResult.Status 來判斷這次呼叫 API 的結果是否成果，若該屬性值為 True，則 Payload 屬性內將會為回傳結果的 JSON 內容；而，若呼叫失敗，例如：JWT Token 失效、查不到資料、無法新增或更新等等問題，可以透過 APIResult.Message 這個屬性值來得到此次異常的錯誤訊，並且可以將這個屬性值顯示在螢幕上，通知使用者這次呼叫 API 失敗的原因。

#region APIResult
/// <summary>
/// 呼叫 API 回傳的制式格式
/// </summary>
public class APIResult
{
    /// <summary>
    /// 此次呼叫 API 是否成功
    /// </summary>
    public bool Status { get; set; } = false;
    /// <summary>
    /// 呼叫 API 失敗的錯誤訊息
    /// </summary>
    public string Message { get; set; } = "";
    /// <summary>
    /// 呼叫此API所得到的其他內容
    /// </summary>
    public object Payload { get; set; }
}

#endregion

設計一個進行身分驗證的 Login 服務類別

現在，來了解如何使用 HttpClient 設計出一個可以用於身分驗證的類別服務，底下為使用者登入的服務類別 LoginManager；在這裡會繼承 BaseWebAPI 這個類別 (其會負責處理 HTTP 相關通訊協定要用到的相關 API 呼叫)，並且這個類別將會是一個泛型類別，也就是說，要宣告該 Web API 登入驗證服務類別，其最後的回傳結果的資料型別為何，在這裡將會標明只要登入成功，將會得到 LoginResponseDTO 這個行別物件。

由於這個登入 LoginManager 類別，只會有登入驗證功能，因此，這裡將會設計出一個非同步 PostAsync 方法，並且傳入使用者登入身分驗證使用的帳號與密碼資訊，所以，第一個參數將會是 LoginRequestDTO 型別；一旦取得這個物件之後，經會使用 JSON.NET 類別庫 API， JsonConvert.SerializeObject 將其轉換成為 JSON 字串，並且呼叫 BaseWebAPI 內的 SendAsync 方法，與指定此次 HTTP 要執行的動詞動作為 HttpMethod.Post，請求使用 HTTP Post 方法來呼叫遠端的 Web API。

而在這個類別建構式內，將會宣告這個遠端 Web API 使用的主機資訊、API URL、與資料編碼格式等等資訊；由於這樣的類別服務，是作者通常用於設計 Xamarin App 時候所使用的，因此，大部分的時候，只要 API 成功呼叫完畢，會將當時回傳的資料物件，儲存在本機裝置上，以便下次可以不用再次呼叫 Web API，就可以得到上次呼叫 Web API 的回傳結果。在此，因為只要登入驗證成功之後，接下來要呼叫的其他需要授權的 API要使用到的 Token 值，就會儲存在本機目錄下(使用文字檔案的方式)，所以，可以隨時再度開啟讀取這個檔案內容，就可以得到要使用的 JWT Token 物件值。

還記得這個 API 服務，不論在呼叫端或者伺服器端，都是使用 JSON 資料格式進行傳遞與接收。

public class LoginManager : BaseWebAPI<LoginResponseDTO>
{
    public LoginManager()
        : base()
    {
        this.restURL = "/LoginShort";
        this.host = Constants.HostAPI;
        IsCollectionType = false;
        EncodingType = EnctypeMethod.JSON;
        NeedSaveData = true;
    }

    public async Task<APIResult> PostAsync(LoginRequestDTO loginRequestDTO, CancellationToken cancellationToken = default(CancellationToken))
    {

        #region 要傳遞的參數
        HTTPPayloadDictionary dic = new HTTPPayloadDictionary();

        dic.Add(Constants.JSONDataKeyName, JsonConvert.SerializeObject(loginRequestDTO));
        #endregion

        var mr = await this.SendAsync(dic, HttpMethod.Post, cancellationToken);

        return mr;
    }
}

當要進行使用者登入驗證作業的時候，需要建立一個 LoginRequestDTO 物件，這個類別中有兩個屬性，分別為帳號與密碼，這個 LoginRequestDTO 型別的物件，將會轉換成為 JSON 格式，並且在呼叫 HTTP API 的時候，標明使用 JSON 編碼方式來傳送要呼叫 API 的相關參數內容。

public class LoginRequestDTO
{
    public string Account { get; set; }
    public string Password { get; set; }
}

若該密碼成功登入驗證之後，將會回傳底下 LoginResponseDTO 型別的物件，這裡面將會有使用者的基本資訊，如 ID，帳號、姓名等等，另外，也會有接下來要呼叫其他 API 需要使用到的 JWT Token 資料，這裡會儲存在 LoginResponseDTO.Token 內；對於 LoginResponseDTO.TokenExpireMinutes 將會說明這個 Token 的有效期限是幾分鐘，這樣在用戶端這裡就可以產生一個時間戳記，用來判斷若要呼叫一個 API 的時候，當時的 Token 是否已經失效了，而不用呼叫 API 之後，才知道該 Token已經失效了。若 Token 已經失效的話，就可以使用 LoginResponseDTO.RefreshToken 這個權杖值，用來呼叫更新 JWT 權杖 API，取得新的存取權杖，當然，這裡也會有 LoginResponseDTO.RefershTokenExpireDays 這個更新權杖的有效期限會有幾天，也就是說，若要呼叫更新權杖 API，需要在此規定天數內來執行，否則，就可以請使用者直接進行重新登入驗證的作業。

public class LoginResponseDTO
{
    public int Id { get; set; }
    public string Account { get; set; }
    public string Name { get; set; }
    public string Token { get; set; }
    public int TokenExpireMinutes { get; set; }
    public string RefreshToken { get; set; }
    public int RefreshTokenExpireDays { get; set; }
    public string Image { get; set; }
    public virtual DepartmentDTO Department { get; set; }
}

呼叫 RESTfule API 的基底服務類別

底下是要呼叫 RESTfule API 的基底類別，不論是使用 HTTP 的 Get, Post, Put, Delete，都可以繼承這個類別，達到呼叫遠端 Web API 的功能。在這個基底類別中，除了會將成功呼叫完成的結果內容，從 JSON 格式，轉換(反序列化)成為 .NET 的物件，在這裡將會使用 JsonConvert.DeserializeObject 先將此次 API 呼叫結果轉換成為 .NET 中的 APIResult 物件(還記得這個後端 API環境中，是有規劃符合 RESTfule 設計原則，因此，不論成功或者失敗，都會得到一個 APIResult 的 JSON 物件)，接著對於成功呼叫 API 的結果，將會使用 APIResult.Payload 這個使用值，呼叫 SingleItem = JsonConvert.DeserializeObject 這個 API，其中指的是泛型型別參數，也就是當初在設計 LoginManager 類別時候，指定的泛型參數型別，也就是成功呼叫 API之後，應該得到的物件型別，這裡將會有呼叫各個 API 的 Token 值、更新 JWT Token 要使用到的權杖與使用者資訊等等。

由於這個 API 服務成功呼叫完成之後，將會得到一個物件，而不是一個集合 Collection的物件，所以，會將這個成功取得回來的物件儲存在 SingleItem 屬性內，下在想要取這裡的 Token 或者 RefreshToken，就可以直接取得。若想要讀取已經儲存在檔案內的物件，可以呼叫 ReadFromFileAsync() 方法，就會將檔案內的文字內容讀取出來，使用 JSON.NET 還原成為 .NET 物件，並且存放到 SingleItem 屬性內。

SendAsync 方法內，將會建立一個 HttpClient 物件，若此次呼叫的 API 是需要提供一個 JWT Token 來進行授權驗證之用的話，就會將這個權杖使用這個表示式 client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", this.AuthenticationHeaderBearerTokenValue); 加入到此次 HTTP 通訊協定的 Header 標頭內，這裡使用的是 Basic 基本驗證的規範。

接著就會依據所傳入的參數，也就是型別為 HttpMethod 的參數，判斷其使用的 HTTP 動作是哪一個，分別呼叫 HttpClient 相對應的方法；在這個基底類別中，同樣的也可以支援使用其他類型的資料編碼格式的 API 呼叫，例如，傳統的 QueryString 查詢字串、使用 application/x-www-form-urlencoded 方式來進行傳遞參數的編碼、使用 multipart/form-data 方式來進行傳遞參數的編碼、當然也支援 使用 application/json 方式來進行傳遞參數的編碼。

之後將會得到一個 HttpResponseMessage 型別的物件，就可以使用這個物件的 IsSuccessStatusCode 屬性值來判斷此次 API 呼叫是否有成過，或者是失敗；而整個 SendAsync 方法都會包裹在 Try...Catch 內，當發生了用戶端的網路斷線等問題，導致無法正常呼叫遠端 Web API 的現象時候，也會封裝這個例外異常資訊，可以回報給使用者知道。

若得到的JSON文字無法成功反序列化成為指定的 .NET 行別物件，就會使用 SingleItem = (T)Activator.CreateInstance(typeof(T)); 敘述建立一個新的物件，這樣可以讓 SingleItem 不會是一個空值，最後將會呼叫 await this.WriteToFileAsync() 敘述，把這個物件的 JSON 內容，寫入檔案內。

#region BaseWebAPI
/// <summary>
/// 存取Http服務的Base Class
/// </summary>
/// <typeparam name="T"></typeparam>
public abstract class BaseWebAPI<T>
{
    #region Field
    /// <summary>
    /// WebAPI主機位置
    /// </summary>
    public string host = Constants.HostAPI;

    /// <summary>
    /// WebAPI方法網址 
    /// </summary>
    public string restURL = "";
    //public string AuthenticationHeaderBearerTokenValue = "";
    /// <summary>
    /// 指定 HTTP 標頭 Bearer 內，要放置的 JWT Token 值
    /// </summary>
    public string AuthenticationHeaderBearerTokenValue { get; set; }
    /// <summary>
    /// 要呼叫 REST API 的額外路由路徑
    /// </summary>
    public string RouteURL { get; set; } = "";
    /// <summary>
    /// 成功呼叫完成 API 之後，是否要儲存到本機檔案系統內
    /// </summary>
    public bool NeedSaveData { get; set; }
    /// <summary>
    /// 是否為集合型別的物件
    /// </summary>
    public bool IsCollectionType { get; set; } = true;
    /// <summary>
    /// 要傳遞的 HTTP Payload 使用的編碼格式
    /// </summary>
    public EnctypeMethod EncodingType;
    /// <summary>
    /// 資料夾名稱
    /// </summary>
    //public string CurrentFolderName = "";
    public string CurrentFolderName { get; set; } = "";
    public string SubFolderName { get; set; } = "";
    public string TopDataFolderName { get; set; } = "Data";

    /// <summary>
    /// 檔案名稱
    /// </summary>
    public string DataFileName { get; set; } = "";


    #region 系統用到的訊息字串
    public static readonly string APIInternalError = "System Exception = null, Result = null";
    #endregion

    #endregion

    // =========================================================================================================

    #region protected

    #endregion

    // =========================================================================================================

    #region Public
    /// <summary>
    /// 透過Http取得的資料，也許是一個物件，也許是List
    /// </summary>
    public List<T> Items { get; set; }
    public T SingleItem { get; set; }
    /// <summary>
    /// 此次呼叫的處理結果
    /// </summary>
    public APIResult ManagerResult { get; set; }

    #endregion

    // =========================================================================================================

    /// <summary>
    /// 建構子，經由繼承後使用反射取得類別的名稱當作，檔案名稱及WebAPI的方法名稱
    /// </summary>
    public BaseWebAPI()
    {
        CurrentFolderName = TopDataFolderName;
        restURL = "";
        DataFileName = this.GetType().Name;
        //子資料夾名稱 = 資料檔案名稱;
        this.ManagerResult = new APIResult();
        EncodingType = EnctypeMethod.JSON;
    }

    ///// <summary>
    ///// 建立存取 Web 服務的參數
    ///// </summary>
    ///// <param name="_url">存取服務的URL</param>
    ///// <param name="_DataFileName">儲存資料的名稱</param>
    ///// <param name="_DataFolderName">資料要儲存的目錄</param>
    ///// <param name="_className">類別名稱</param>
    //public void SetWebAccessCondition(string _url, string _DataFileName, string _DataFolderName, string _className = "")
    //{
    //    string className = _className;

    //    this.restURL = string.Format("{0}{1}", _url, _className);
    //    this.資料檔案名稱 = _DataFileName;
    //    this.現在資料夾名稱 = _DataFolderName;
    //    this.managerResult = new APIResult();
    //}

    /// <summary>
    /// 從網路取得相對應WebAPI的資料
    /// </summary>
    /// <param name="dic">所要傳遞的參數 Dictionary </param>
    /// <param name="httpMethod">Get Or Post</param>
    /// <returns></returns>
    protected virtual async Task<APIResult> SendAsync(Dictionary<string, string> dic, HttpMethod httpMethod,
        CancellationToken token = default(CancellationToken))
    {
        this.ManagerResult = new APIResult();
        APIResult mr = this.ManagerResult;
        string jsonPayload = "";

        //檢查網路狀態
        //if (UtilityHelper.IsConnected() == false)
        //{
        //    mr.Status = false;
        //    mr.Message = "無網路連線可用，請檢查網路狀態";
        //    return mr;
        //}

        if (dic.ContainsKey(Constants.JSONDataKeyName))
        {
            jsonPayload = dic[Constants.JSONDataKeyName];
            dic.Remove(Constants.JSONDataKeyName);
        }

        HttpClientHandler handler = new HttpClientHandler();

        using (HttpClient client = new HttpClient(handler))
        {
            try
            {
                //client.Timeout = TimeSpan.FromMinutes(3);
                string fooQueryString = dic.ToQueryString();
                string fooUrl = $"{host}{restURL}{RouteURL}" + fooQueryString;
                UriBuilder ub = new UriBuilder(fooUrl);
                HttpResponseMessage response = null;

                #region 檢查是否要將 JWT Token 放入 HTTP 標頭 Bearer 內
                if (string.IsNullOrEmpty(this.AuthenticationHeaderBearerTokenValue) == false)
                {
                    client.DefaultRequestHeaders.Authorization =
                        new AuthenticationHeaderValue("Bearer", this.AuthenticationHeaderBearerTokenValue);
                }
                #endregion

                #region  執行 HTTP 動詞 (Action) : Get, Post, Put, Delete
                if (httpMethod == HttpMethod.Get)
                {
                    // 使用 Get 方式來呼叫
                    response = await client.GetAsync(ub.Uri, token);
                }
                else if (httpMethod == HttpMethod.Post)
                {
                    // 使用 Post 方式來呼叫
                    switch (EncodingType)
                    {
                        case EnctypeMethod.MULTIPART:
                            // 使用 MULTIPART 方式來進行傳遞資料的編碼
                            response = await client.PostAsync(ub.Uri, dic.ToMultipartFormDataContent(), token);
                            break;
                        case EnctypeMethod.FORMURLENCODED:
                            // 使用 FormUrlEncoded 方式來進行傳遞資料的編碼
                            response = await client.PostAsync(ub.Uri, dic.ToFormUrlEncodedContent(), token);
                            break;
                        case EnctypeMethod.JSON:
                            client.DefaultRequestHeaders.Accept.TryParseAdd("application/json");
                            response = await client.PostAsync(ub.Uri, new StringContent(jsonPayload, Encoding.UTF8, "application/json"));
                            break;
                        default:
                            throw new Exception("不正確的 HTTP Payload 編碼設定");
                                break;
                        }
                }
                else if (httpMethod == HttpMethod.Put)
                {
                    // 使用 Post 方式來呼叫
                    switch (EncodingType)
                    {
                        case EnctypeMethod.MULTIPART:
                            // 使用 MULTIPART 方式來進行傳遞資料的編碼
                            response = await client.PutAsync(ub.Uri, dic.ToMultipartFormDataContent(), token);
                            break;
                        case EnctypeMethod.FORMURLENCODED:
                            // 使用 FormUrlEncoded 方式來進行傳遞資料的編碼
                            response = await client.PutAsync(ub.Uri, dic.ToFormUrlEncodedContent(), token);
                            break;
                        case EnctypeMethod.JSON:
                            client.DefaultRequestHeaders.Accept.TryParseAdd("application/json");
                            response = await client.PutAsync(ub.Uri, new StringContent(jsonPayload, Encoding.UTF8, "application/json"));
                            break;
                        default:
                            throw new Exception("不正確的 HTTP Payload 編碼設定");
                                break;
                        }
                }
                else if (httpMethod == HttpMethod.Delete)
                {
                    response = await client.DeleteAsync(ub.Uri, token);
                }
                else
                {
                    throw new NotImplementedException("Not Found HttpMethod");
                }
                #endregion

                #region Response
                if (response != null)
                {
                    String strResult = await response.Content.ReadAsStringAsync();

                    if (response.IsSuccessStatusCode == true)
                    {
                        mr = JsonConvert.DeserializeObject<APIResult>(strResult, new JsonSerializerSettings { MetadataPropertyHandling = MetadataPropertyHandling.Ignore });
                        if (mr.Status == true)
                        {
                            var fooDataString = mr.Payload.ToString();
                            if (IsCollectionType == false)
                            {
                                SingleItem = JsonConvert.DeserializeObject<T>(fooDataString, new JsonSerializerSettings { MetadataPropertyHandling = MetadataPropertyHandling.Ignore });
                                if (NeedSaveData == true)
                                {
                                    if (SingleItem == null)
                                    {
                                        SingleItem = (T)Activator.CreateInstance(typeof(T));
                                    }
                                    await this.WriteToFileAsync();
                                }
                            }
                            else
                            {
                                Items = JsonConvert.DeserializeObject<List<T>>(fooDataString, new JsonSerializerSettings { MetadataPropertyHandling = MetadataPropertyHandling.Ignore });
                                if (NeedSaveData == true)
                                {
                                    if (Items == null)
                                    {
                                        Items = (List<T>)Activator.CreateInstance(typeof(List<T>));
                                    }
                                    await this.WriteToFileAsync();
                                }
                            }
                        }
                    }
                    else
                    {
                        APIResult fooAPIResult = JsonConvert.DeserializeObject<APIResult>(strResult, new JsonSerializerSettings { MetadataPropertyHandling = MetadataPropertyHandling.Ignore });
                        if (fooAPIResult != null)
                        {
                            mr = fooAPIResult;
                        }
                        else
                        {
                            mr.Status = false;
                            mr.Message = string.Format("Error Code:{0}, Error Message:{1}", response.StatusCode, response.Content);
                        }
                    }
                }
                else
                {
                    mr.Status = false;
                    mr.Message = APIInternalError;
                }
                #endregion
            }
            catch (Exception ex)
            {
                mr.Status = false;
                mr.Message = ex.Message;
            }
        }

        return mr;
    }

    /// <summary>
    /// 將物件資料從檔案中讀取出來
    /// </summary>
    public virtual async Task ReadFromFileAsync()
    {
        #region 先將建立該資料模型的物件，避免檔案讀取不出來之後， Items / SingleItem 的物件值為 null
        if (IsCollectionType == false)
        {
            SingleItem = (T)Activator.CreateInstance(typeof(T));
        }
        else
        {
            Items = (List<T>)Activator.CreateInstance(typeof(List<T>));
        }
        #endregion

        string data = await StorageUtility.ReadFromDataFileAsync(this.CurrentFolderName, this.DataFileName);
        if (string.IsNullOrEmpty(data) == true)
        {

        }
        else
        {
            try
            {
                if (IsCollectionType == false)
                {
                    this.SingleItem = JsonConvert.DeserializeObject<T>(data, new JsonSerializerSettings { MetadataPropertyHandling = MetadataPropertyHandling.Ignore });
                }
                else
                {
                    this.Items = JsonConvert.DeserializeObject<List<T>>(data, new JsonSerializerSettings { MetadataPropertyHandling = MetadataPropertyHandling.Ignore });
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.Message);
            }
        }

    }

    /// <summary>
    /// 將物件資料寫入到檔案中
    /// </summary>
    public virtual async Task WriteToFileAsync()
    {
        string data = "";
        if (IsCollectionType == false)
        {
            data = JsonConvert.SerializeObject(this.SingleItem);
        }
        else
        {
            data = JsonConvert.SerializeObject(this.Items);
        }
        await StorageUtility.WriteToDataFileAsync(this.CurrentFolderName, this.DataFileName, data);
    }

}
#endregion

開始進行測試

在底下的 Console 類型專案，將會先進行使用者的帳號與密碼驗證，當驗證成功之後，就會使用剛剛取得的 JWT Token 值(loginManager.SingleItem.Token) 呼叫 Departments 這個 API。底下將會是成功完成使用者身分驗證之後，關於這個使用者的 JSON 物件資訊。

{
  "id": 25,
  "account": "user50",
  "name": "Account50",
  "token": "eyJhbGciOiJIUzUxMiIsInR5cCI6IkpXVCJ9.eyJzaWQiOiIyNSIsImh0dHA6Ly9zY2hlbWFzLnhtbHNvYXAub3JnL3dzLzIwMDUvMDUvaWRlbnRpdHkvY2xhaW1zL25hbWUiOiJ1c2VyNTAiLCJodHRwOi8vc2NoZW1hcy5taWNyb3NvZnQuY29tL3dzLzIwMDgvMDYvaWRlbnRpdHkvY2xhaW1zL3JvbGUiOlsiVXNlciIsIkRlcHQxIl0sImh0dHA6Ly9zY2hlbWFzLm1pY3Jvc29mdC5jb20vd3MvMjAwOC8wNi9pZGVudGl0eS9jbGFpbXMvdmVyc2lvbiI6IjAiLCJleHAiOjE1NjQzOTk5OTUsImlzcyI6IlhhbWFyaW5Gb3Jtc1dTLnZ1bGNhbi5uZXQiLCJhdWQiOiJYYW1hcmluLkZvcm1zIEFwcCJ9.XpO0wCvNVBvNpZT4AaBz83VK-xFMvVMjxTSQ0MMSOVycz-LwVk71BQT25c1OPRcnxhX4B0jBNBRlbmAJT4WldQ",
  "tokenExpireMinutes": 15,
  "refreshToken": "eyJhbGciOiJIUzUxMiIsInR5cCI6IkpXVCJ9.eyJzaWQiOiIyNSIsImh0dHA6Ly9zY2hlbWFzLnhtbHNvYXAub3JnL3dzLzIwMDUvMDUvaWRlbnRpdHkvY2xhaW1zL25hbWUiOiJ1c2VyNTAiLCJodHRwOi8vc2NoZW1hcy5taWNyb3NvZnQuY29tL3dzLzIwMDgvMDYvaWRlbnRpdHkvY2xhaW1zL3JvbGUiOlsiVXNlciIsIlJlZnJlc2hUb2tlbiJdLCJodHRwOi8vc2NoZW1hcy5taWNyb3NvZnQuY29tL3dzLzIwMDgvMDYvaWRlbnRpdHkvY2xhaW1zL3ZlcnNpb24iOiIwIiwiZXhwIjoxNTY1MDA1MDg1LCJpc3MiOiJYYW1hcmluRm9ybXNXUy52dWxjYW4ubmV0IiwiYXVkIjoiWGFtYXJpbi5Gb3JtcyBBcHAifQ.Gisq0bSRTRIzci19nNy83wfi0fMJyVPvBjyoRfWNWbca2maQwC0lWsvpBKKu5ZlZQBWWVH7JMrKH_CpvI5Tksw",
  "refreshTokenExpireDays": 7,
  "image": "",
  "level": 0,
  "department": {
    "id": 1
  }
}

因為這個 loginManager.SingleItem.Token JWT Token 值 (eyJhbGciOiJIUzUxMiIsInR5cCI6IkpXVCJ9.eyJzaWQiOiIyNSIsImh0dHA6Ly9zY2hlbWFzLnhtbHNvYXAub3JnL3dzLzIwMDUvMDUvaWRlbnRpdHkvY2xhaW1zL25hbWUiOiJ1c2VyNTAiLCJodHRwOi8vc2NoZW1hcy5taWNyb3NvZnQuY29tL3dzLzIwMDgvMDYvaWRlbnRpdHkvY2xhaW1zL3JvbGUiOlsiVXNlciIsIkRlcHQxIl0sImh0dHA6Ly9zY2hlbWFzLm1pY3Jvc29mdC5jb20vd3MvMjAwOC8wNi9pZGVudGl0eS9jbGFpbXMvdmVyc2lvbiI6IjAiLCJleHAiOjE1NjQzOTk5OTUsImlzcyI6IlhhbWFyaW5Gb3Jtc1dTLnZ1bGNhbi5uZXQiLCJhdWQiOiJYYW1hcmluLkZvcm1zIEFwcCJ9.XpO0wCvNVBvNpZT4AaBz83VK-xFMvVMjxTSQ0MMSOVycz-LwVk71BQT25c1OPRcnxhX4B0jBNBRlbmAJT4WldQ) 為正確合法的，且還在有效期限內，因此，可以成功地取得相關部門資訊。

在這個測試環境中，所取得 JWT Token 有效期限將會僅有 10 秒鐘有效期限，因此，這個測試程式將會休息 10 秒鐘，再度使用同樣一個相同 JWT Token 來呼叫同一個 API，不過，此時將會得到錯誤回報

錯誤代碼 1, 存取權杖可用期限已經逾期超過

現在使用登入完成後的 RefreshToken (eyJhbGciOiJIUzUxMiIsInR5cCI6IkpXVCJ9.eyJzaWQiOiIyNSIsImh0dHA6Ly9zY2hlbWFzLnhtbHNvYXAub3JnL3dzLzIwMDUvMDUvaWRlbnRpdHkvY2xhaW1zL25hbWUiOiJ1c2VyNTAiLCJodHRwOi8vc2NoZW1hcy5taWNyb3NvZnQuY29tL3dzLzIwMDgvMDYvaWRlbnRpdHkvY2xhaW1zL3JvbGUiOlsiVXNlciIsIlJlZnJlc2hUb2tlbiJdLCJodHRwOi8vc2NoZW1hcy5taWNyb3NvZnQuY29tL3dzLzIwMDgvMDYvaWRlbnRpdHkvY2xhaW1zL3ZlcnNpb24iOiIwIiwiZXhwIjoxNTY1MDA1MDg1LCJpc3MiOiJYYW1hcmluRm9ybXNXUy52dWxjYW4ubmV0IiwiYXVkIjoiWGFtYXJpbi5Gb3JtcyBBcHAifQ.Gisq0bSRTRIzci19nNy83wfi0fMJyVPvBjyoRfWNWbca2maQwC0lWsvpBKKu5ZlZQBWWVH7JMrKH_CpvI5Tksw) 來呼叫更新 JWT 權杖的 API，這個時候，將會得到新的可以存取各個 API 使用的 Token，底下是成功呼叫完成更新 JWT Token 權杖的回傳結果內容

{
  "id": 25,
  "account": "user50",
  "name": "Account50",
  "token": "eyJhbGciOiJIUzUxMiIsInR5cCI6IkpXVCJ9.eyJzaWQiOiIyNSIsImh0dHA6Ly9zY2hlbWFzLnhtbHNvYXAub3JnL3dzLzIwMDUvMDUvaWRlbnRpdHkvY2xhaW1zL25hbWUiOiJ1c2VyNTAiLCJodHRwOi8vc2NoZW1hcy5taWNyb3NvZnQuY29tL3dzLzIwMDgvMDYvaWRlbnRpdHkvY2xhaW1zL3JvbGUiOlsiVXNlciIsIkRlcHQxIl0sImh0dHA6Ly9zY2hlbWFzLm1pY3Jvc29mdC5jb20vd3MvMjAwOC8wNi9pZGVudGl0eS9jbGFpbXMvdmVyc2lvbiI6IjAiLCJleHAiOjE1NjQ0MDAwMTUsImlzcyI6IlhhbWFyaW5Gb3Jtc1dTLnZ1bGNhbi5uZXQiLCJhdWQiOiJYYW1hcmluLkZvcm1zIEFwcCJ9.0oJSRSu0zqFuE66HRRB_ulJlT8y8dcTJj01p-t7htngMtODmVCn8XUfvD3PMz0CN8F7tPOwJfqveJUFD3Xezvw",
  "tokenExpireMinutes": 15,
  "refreshToken": "eyJhbGciOiJIUzUxMiIsInR5cCI6IkpXVCJ9.eyJzaWQiOiIyNSIsImh0dHA6Ly9zY2hlbWFzLnhtbHNvYXAub3JnL3dzLzIwMDUvMDUvaWRlbnRpdHkvY2xhaW1zL25hbWUiOiJ1c2VyNTAiLCJodHRwOi8vc2NoZW1hcy5taWNyb3NvZnQuY29tL3dzLzIwMDgvMDYvaWRlbnRpdHkvY2xhaW1zL3JvbGUiOlsiVXNlciIsIlJlZnJlc2hUb2tlbiJdLCJodHRwOi8vc2NoZW1hcy5taWNyb3NvZnQuY29tL3dzLzIwMDgvMDYvaWRlbnRpdHkvY2xhaW1zL3ZlcnNpb24iOiIwIiwiZXhwIjoxNTY1MDA1MTA1LCJpc3MiOiJYYW1hcmluRm9ybXNXUy52dWxjYW4ubmV0IiwiYXVkIjoiWGFtYXJpbi5Gb3JtcyBBcHAifQ.Zxy_f5A3JY20c5XsQp5vUJlm901dy0jwW-rbOfOQXWld6TaCh4oPp-NuiavWdcjyt9oV8B8CtLHzxeZLVDsbhw",
  "refreshTokenExpireDays": 7,
  "image": "",
  "level": 0,
  "department": {
    "id": 1
  }
}

static async Task Main(string[] args)
{
    LoginManager loginManager = new LoginManager();
    Output("進行登入身分驗證");
    APIResult result = await loginManager.PostAsync(new LoginRequestDTO()
    {
        Account = "user50",
        Password = "password50"
    });
    if (result.Status == true)
    {
        Console.WriteLine($"登入成功");
        Console.WriteLine($"{result.Payload}");
    }
    else
    {
        Console.WriteLine($"登入失敗");
        Console.WriteLine($"{result.Message}");
    }
    Thread.Sleep(2000);

    Output("利用取得的 JTW Token 呼叫取得部門資訊 Web API");
    DepartmentsManager departmentsManager = new DepartmentsManager();
    result = await departmentsManager.GetAsync(loginManager.SingleItem.Token);
    if (result.Status == true)
    {
        Console.WriteLine($"取得部門資料成功");
        Console.WriteLine($"{result.Payload}");
    }
    else
    {
        Console.WriteLine($"取得部門資料失敗");
        Console.WriteLine($"{result.Message}");
    }

    Console.WriteLine("等候10秒鐘，等待 JWT Token 失效");
    await Task.Delay(10000);

    departmentsManager = new DepartmentsManager();
    Output("再次呼叫取得部門資訊 Web API，不過，該 JWT Token已經失效了");
    result = await departmentsManager.GetAsync(loginManager.SingleItem.Token);
    if (result.Status == true)
    {
        Console.WriteLine($"取得部門資料成功");
        Console.WriteLine($"{result.Payload}");
    }
    else
    {
        Console.WriteLine($"取得部門資料失敗");
        Console.WriteLine($"{result.Message}");
    }
    Thread.Sleep(2000);

    RefreshTokenService refreshTokenService = new RefreshTokenService();
    Output("呼叫更新 JWT Token API，取得更新的 JWT Token");
    result = await refreshTokenService.GetAsync(loginManager.SingleItem.RefreshToken);
    if (result.Status == true)
    {
        Console.WriteLine($"更新 JWT Token 成功");
        Console.WriteLine($"{result.Payload}");
    }
    else
    {
        Console.WriteLine($"更新 JWT Token 失敗");
        Console.WriteLine($"{result.Message}");
    }
    Thread.Sleep(2000);

    departmentsManager = new DepartmentsManager();
    Output("再次呼叫取得部門資訊 Web API，不過，使用剛剛取得的更新 JWT Token");
    result = await departmentsManager.GetAsync(refreshTokenService.SingleItem.Token);
    if (result.Status == true)
    {
        Console.WriteLine($"取得部門資料成功");
        Console.WriteLine($"{result.Payload}");
    }
    else
    {
        Console.WriteLine($"取得部門資料失敗");
        Console.WriteLine($"{result.Message}");
    }
    Thread.Sleep(2000);

    Console.WriteLine("Press any key for continuing...");
    Console.ReadKey();
}