.NET Core 快速指南

.NET Core - 概述

.NET Core 是微軟維護的最新通用開發平臺。它可在不同平臺上執行，並且經過重新設計，使 .NET 變得快速、靈活和現代。這恰好是微軟做出的主要貢獻之一。開發人員現在可以使用 .NET 構建 Android、iOS、Linux、Mac 和 Windows 應用程式，所有這些都在開源環境中。

在本教程中，我們將介紹 .NET Core 和一些新的創新，包括 .NET Framework 更新、.NET Standard 和通用 Windows 平臺更新等。

.NET Core 的特性

以下是 .NET Core 的主要特性：

開源

.NET Core 是一個開源實現，使用 MIT 和 Apache 2 許可證。
.NET Core 是一個 .NET Foundation 專案，可在 GitHub 上獲取。
作為一個開源專案，它促進了更透明的開發流程，並促進了積極且參與度高的社群。

跨平臺

在 .NET Core 中實現的應用程式可以執行，並且其程式碼可以重用，而不管您的目標平臺是什麼。
它目前支援三個主要作業系統 (OS)
- Windows
- Linux
- MacOS
隨著時間的推移，微軟、其他公司和個人提供的受支援的作業系統 (OS)、CPU 和應用程式場景將不斷增加。

靈活的部署

.NET Core 應用程式可以有兩種部署型別：
- 框架依賴型部署
- 自包含部署
使用框架依賴型部署，您的應用程式依賴於系統範圍內的 .NET Core 版本，您的應用程式和第三方依賴項都安裝在此版本上。
使用自包含部署，用於構建應用程式的 .NET Core 版本也與您的應用程式和第三方依賴項一起部署，並且可以與其他版本並行執行。

命令列工具

所有產品場景都可以在命令列中使用。

相容

.NET Core 透過 .NET Standard 庫與 .NET Framework、Xamarin 和 Mono 相容

模組化

.NET Core 透過 NuGet 以較小的程式集包的形式釋出。
.NET Framework 是一個包含大多數核心功能的大型程式集。
.NET Core 以較小的以功能為中心的包的形式提供。
這種模組化方法使開發人員能夠透過僅包含應用程式中需要的那些 NuGet 包來最佳化其應用程式。
較小的應用程式表面積的好處包括更嚴格的安全、減少的服務、改進的效能以及按使用付費模型中的成本降低。

.NET Core 平臺

.NET Core 平臺包含以下主要部分：

.NET 執行時 - 它提供型別系統、程式集載入、垃圾回收器、本機互操作和其他基本服務。
基礎庫 - 一組框架庫，提供原始資料型別、應用程式組合型別和基本實用程式。
SDK 和編譯器 - 一組 SDK 工具和語言編譯器，支援基本開發人員體驗，可在 .NET Core SDK 中使用。
“dotnet”應用程式宿主 - 用於啟動 .NET Core 應用程式。它選擇執行時並託管執行時，提供程式集載入策略並啟動應用程式。相同的宿主也以幾乎相同的方式用於啟動 SDK 工具。

.NET Core - 先決條件

在本章中，我們將討論您需要部署和執行的各種依賴項。這些包括使用 Visual Studio 開發並在 Windows 機器上執行的 .NET Core 應用程式。

支援的 Windows 版本

.NET Core 在以下版本的 Windows 上受支援：

Windows 7 SP1
Windows 8.1
Windows 10
Windows Server 2008 R2 SP1（完整伺服器或伺服器核心）
Windows Server 2012 SP1（完整伺服器或伺服器核心）
Windows Server 2012 R2 SP1（完整伺服器或伺服器核心）
Windows Server 2016（完整伺服器、伺服器核心或 Nano 伺服器）

依賴項

如果您在低於 Windows 10 和 Windows Server 2016 的 Windows 版本上執行 .NET Core 應用程式，則還需要 Visual C++ Redistributable。
如果您使用 .NET Core 安裝程式，則此依賴項會自動為您安裝。
如果您透過安裝程式指令碼安裝 .NET Core 或部署自包含的 .NET Core 應用程式，則需要手動安裝 Visual Studio 2015 的 Visual C++ Redistributable。
對於 Windows 7 和 Windows Server 2008 機器，您需要確保您的 Windows 安裝是最新的，並且還包括透過 Windows 更新安裝的修補程式 KB2533623。

使用 Visual Studio 的先決條件

要使用 .NET Core SDK 開發 .NET Core 應用程式，您可以使用任何您選擇的編輯器。
但是，如果您想在 Windows 上使用 Visual Studio 開發 .NET Core 應用程式，則可以使用以下兩個版本：
- Visual Studio 2015
- Visual Studio 2017 RC
使用 Visual Studio 2015 建立的專案預設情況下將基於 project.json，而使用 Visual Studio 2017 RC 建立的專案將始終基於 MSBuild。

.NET Core - 環境設定

在本章中，我們將討論 .NET Core 的環境設定。它是 .NET Framework 的重大重新設計。要在應用程式中使用 .NET Core，您可以使用兩個版本：

Visual Studio 2015
Visual Studio 2017 RC

Visual Studio 2015

要使用 Visual Studio 2015，您必須已安裝以下內容：

Microsoft Visual Studio 2015 Update 3
Microsoft .NET Core 1.0.1 - VS 2015 工具預覽版 2

Microsoft 提供了 Visual Studio 的免費版本，其中還包含 SQL Server，可以從 https://www.visualstudio.com/en-us/downloads/download-visual-studio-vs.aspx 下載，並且 Microsoft .NET Core 1.0.1 - VS 2015 工具預覽版 2 可以從 https://www.visualstudio.com/downloads/ 下載

您也可以按照以下網址上的安裝指南進行操作 https://www.microsoft.com/net/core/#windowsvs2017

Visual Studio 2015 的安裝

請按照以下步驟安裝 Visual Studio 2015：

步驟 1 - 下載完成後，執行安裝程式。將顯示以下對話方塊。

步驟 2 - 單擊安裝以啟動安裝過程。

步驟 3 - 安裝完成後，您將看到以下對話方塊。

步驟 4 - 關閉此對話方塊，並在需要時重新啟動計算機。

步驟 5 - 從“開始”選單開啟 Visual Studio；您將收到以下對話方塊。載入可能需要幾分鐘時間，最後才能首次使用。

步驟 6 - 載入完成後，您將看到以下螢幕。

步驟 7 - 完成 Visual Studio 安裝後，關閉 Visual Studio 並啟動 Microsoft .NET Core - VS 2015 工具預覽版 2。

步驟 8 - 選中複選框並單擊安裝。

步驟 9 - 安裝完成後，您將看到以下對話方塊。

您現在可以使用 .NET Core 啟動應用程式了。

Visual Studio 2017

在本教程中，我們將使用 Visual Studio 2015，但如果您想使用 Visual Studio 2017，則 Visual Studio 2017 RC 中包含 .NET Core 工具的實驗性版本，您可以在此處檢視安裝指南 https://www.microsoft.com/net/core/#windowsvs2017

.NET Core - 入門

Visual Studio 2015 為開發 .NET Core 應用程式提供了一個功能齊全的開發環境。在本章中，我們將建立 Visual Studio 中的新專案。安裝 Visual Studio 2015 工具後，您可以開始構建新的 .NET Core 應用程式。

在新建專案對話方塊的模板列表中，展開Visual C#節點並選擇.NET Core，您應該會看到以下三個新的專案模板

類庫 (.NET Core)
控制檯應用程式 (.NET Core)
ASP.NET Core Web 應用程式 (.NET Core)

在“新建專案”對話方塊的中間窗格中，選擇“控制檯應用程式 (.NET Core)”並將其命名為“FirstApp”，然後單擊“確定”。

Visual Studio 將開啟新建立的專案，您將在“解決方案資源管理器”視窗中看到此專案中的所有檔案。

要測試 .NET core 控制檯應用程式是否正常工作，讓我們新增以下行。

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Threading.Tasks; 
  
namespace FirstApp { 
   public class Program { 
      public static void Main(string[] args) { 
         Console.WriteLine("Hello guys, welcome to .NET Core world!"); 
      } 
   } 
}

現在，執行應用程式。您應該會看到以下輸出。

.NET Core - 數值

.NET Core 支援標準數值整數和浮點基元。它還支援以下型別：

System.Numerics.BigInteger，它是一個沒有上限或下限的整數型別。
System.Numerics.Complex 是表示複數的型別。
System.Numerics 名稱空間中的一組啟用單指令多資料 (SIMD) 的向量型別。

整數型別

.NET Core 支援長度從一個位元組到八個位元組的不同範圍的有符號和無符號整數。所有整數都是值型別。

下表顯示了整數型別及其大小；

型別	有符號/ 無符號	大小（位元組）	最小值	最大值
位元組	無符號	1	0	255
Int16	有符號	2	−32,768	32,767
Int32	有符號	4	−2,147,483,648	2,147,483,647
Int64	有符號	8	−9,223,372,036,854,775,808	9,223,372,036,854,775,807
SByte	有符號	1	-128	127
UInt16	無符號	2	0	65,535
UInt32	無符號	4	0	4,294,967,295
UInt64	無符號	8	0	18,446,744,073,709,551,615

每種整數型別都支援一組標準的算術運算子、比較運算子、相等運算子、顯式轉換運算子和隱式轉換運算子。

您還可以使用 System.BitConverter 類處理整數中的各個位。

浮點型別

.NET Core 包含三種原始浮點型別，如下表所示。

型別	大小（位元組）	最小值	最大值
Double	8	−1.79769313486232e308	1.79769313486232e308
Single	4	−3.402823e38	3.402823e38
Decimal	16	−79,228,162,514,264,337,593,543,950,335	79,228,162,514,264,337,593,543,9 50,335

每種浮點型別都支援一組標準的算術運算子、比較運算子、相等運算子、顯式轉換運算子和隱式轉換運算子。
您還可以使用 BitConverter 類處理 Double 和 Single 值中的各個位。
Decimal 結構有其自身的方法，Decimal.GetBits 和 Decimal.Decimal(Int32())，用於處理十進位制值的各個位，以及用於執行一些其他數學運算的自身方法集。

BigInteger

System.Numerics.BigInteger 是一個不可變型別，表示一個任意大的整數，理論上其值沒有上限或下限。
BigInteger 型別的方法與其他整數型別的方法非常相似。

Complex

System.Numerics.Complex 型別表示一個複數，即一個具有實數部分和虛數部分的數。
它支援一組標準的算術運算子、比較運算子、相等運算子、顯式轉換運算子和隱式轉換運算子，以及數學、代數和三角函式方法。

SIMD

Numerics 名稱空間包含一組用於 .NET Core 的支援 SIMD 的向量型別。
SIMD 允許在硬體級別並行化某些操作，從而在執行向量計算的數學、科學和圖形應用程式中帶來巨大的效能改進。
.NET Core 中支援 SIMD 的向量型別包括以下內容 -
- System.Numerics.Vector2、System.Numerics.Vector3 和 System.Numerics.Vector4 型別，它們分別是型別為 Single 的 2 維、3 維和 4 維向量。
- Vector 結構，允許您建立任何原始數值型別的向量。原始數值型別包括 System 名稱空間中的所有數值型別，除了 Decimal。
- 兩種矩陣型別，System.Numerics.Matrix3×2，表示一個 3×2 矩陣；以及 System.Numerics.Matrix4×4，表示一個 4×4 矩陣。
- System.Numerics.Plane 型別，表示一個三維平面，以及 System.Numerics.Quaternion 型別，表示一個用於編碼三維物理旋轉的向量。

.NET Core - 垃圾回收

在本章中，我們將介紹垃圾回收的概念，它是 .NET 託管程式碼平臺最重要的功能之一。垃圾回收器 (GC) 管理記憶體的分配和釋放。垃圾回收器充當自動記憶體管理器。

您不需要知道如何分配和釋放記憶體，或者管理使用該記憶體的物件的生命週期。
每次使用“new”關鍵字宣告物件或值型別裝箱時，都會進行分配。分配通常非常快。
當沒有足夠的記憶體來分配物件時，GC 必須收集和處理垃圾記憶體，以便為新的分配提供記憶體。
此過程稱為垃圾回收。

垃圾回收的優點

垃圾回收提供以下好處 -

在開發應用程式時，您無需手動釋放記憶體。
它還在託管堆上有效地分配物件。
當不再使用物件時，它將透過清除其記憶體來回收這些物件，並使記憶體可用於將來的分配。
託管物件自動獲得乾淨的內容以開始使用，因此它們的建構函式不必初始化每個資料欄位。
它還透過確保物件無法使用另一個物件的內容來提供記憶體安全。

垃圾回收的條件

當以下任一條件為真時，將發生垃圾回收。

系統物理記憶體不足。
託管堆上已分配物件使用的記憶體超過可接受的閾值。此閾值在程序執行時會不斷調整。
呼叫了GC.Collect方法，並且在幾乎所有情況下，您都不必呼叫此方法，因為垃圾回收器會持續執行。此方法主要用於唯一情況和測試。

代

.NET 垃圾回收器有 3 代，每代都有自己的用於儲存已分配物件的堆。有一個基本原則，即大多數物件要麼是短壽命的，要麼是長壽命的。

第一代 (0)

在第 0 代中，首先分配物件。
在本代中，物件通常不會在第一代之後存活，因為在下一次垃圾回收發生時，它們不再使用（超出範圍）。
第 0 代收集速度很快，因為其關聯的堆很小。

第二代 (1)

在第 1 代中，物件有第二次機會空間。
短壽命但存活過第 0 代收集的物件（通常基於偶然的時機）將進入第 1 代。
第 1 代收集速度也很快，因為其關聯的堆也很小。
前兩個堆保持較小，因為物件要麼被收集，要麼被提升到下一代堆。

第三代 (2)

在第 2 代中，所有長物件都是存活的，並且其堆可以增長到非常大。
本代中的物件可以存活很長時間，並且沒有下一代堆來進一步提升物件。
垃圾回收器還有一個用於大型物件的堆，稱為大型物件堆 (LOH)。
它保留給大小為 85,000 位元組或更大的物件。
大型物件不會分配到分代堆，而是直接分配到 LOH。
第 2 代和 LOH 收集對於運行了很長時間或處理大量資料的程式來說可能需要花費明顯的時間。
眾所周知，大型伺服器程式的堆大小為 10 GB 或更大。
GC 使用各種技術來減少其阻塞程式執行的時間量。
主要方法是在後臺執行緒上儘可能多地執行垃圾回收工作，而不干擾程式執行。
GC 還提供了一些方法供開發人員影響其行為，這對於提高效能非常有用。

.NET Core - 程式碼執行

在本章中，我們將瞭解 .NET Core 的執行過程，並將其與 .NET Framework 進行比較。託管執行過程包括以下步驟。

選擇編譯器
將您的程式碼編譯為 MSIL
將 MSIL 編譯為本機程式碼
執行程式碼

選擇編譯器

這是一個多語言執行環境，執行時支援各種資料型別和語言特性。
要獲得公共語言執行時提供的優勢，您必須使用一個或多個針對執行時的語言編譯器。

將您的程式碼編譯為 MSIL

編譯會將您的原始碼轉換為 Microsoft 中間語言 (MSIL) 並生成所需的元資料。
元資料描述了程式碼中的型別，包括每個型別的定義、每個型別成員的簽名、程式碼引用的成員以及執行時在執行時使用的其他資料。
執行時根據需要在執行期間從檔案中以及從框架類庫 (FCL) 中查詢並提取元資料。

將 MSIL 編譯為本機程式碼

在執行時，即時 (JIT) 編譯器會將 MSIL 轉換為本機程式碼。
在此編譯過程中，程式碼必須透過一個驗證過程，該過程檢查 MSIL 和元資料以確定程式碼是否可以確定為型別安全。

執行程式碼

公共語言執行時提供了支援執行的基礎結構以及可在執行期間使用的服務。
在執行期間，託管程式碼會接收諸如垃圾回收、安全、與非託管程式碼的互操作性、跨語言除錯支援以及增強的部署和版本控制支援等服務。

.NET Core 程式碼執行過程

現在讓我們瞭解程式碼如何與 .NET Core 相比 .NET Framework 執行。在 .NET Core 中，這些元件的許多替換都是 .NET Framework 的一部分。

在 .NET Core 中，我們現在有一系列新的編譯器，例如我們有用於 C# 和 VB 的 Roslyn。
如果您想將 F# 與 .NET Core 一起使用，也可以使用新的 F# 4.1 編譯器。
實際上，這些工具是不同的，如果我們使用的是 C# 6 或更高版本，我們也可以將 Roslyn 與 .NET Framework 一起使用，因為 C# 編譯器只能支援到 C# 5。
在 .NET Core 中，我們沒有框架類庫 (FCL)，因此使用一組不同的庫，我們現在有 CoreFx。
CoreFx 是 .NET Core 類庫的重新實現。
我們還有一個新的執行時與 .NET Core 一起使用，稱為 CoreCLR，並利用 JIT 編譯器。
現在問題是我們為什麼要重新實現我們在 .NET Framework 中已經擁有的所有這些元件。
所以答案與 Microsoft 為什麼實現 .NET Core 相同。

.NET Core - 模組化

這是 .NET Core 的另一個考慮因素，用於構建和實現模組化應用程式。您的應用程式現在只需安裝所需的內容，而不是安裝整個 .NET Framework。讓我們轉到 Visual Studio 並檢視模組化。

這是我們的簡單 .NET Core 應用程式，位於解決方案資源管理器中。讓我們展開“引用”，您將看到對 .NETCoreApp 的引用。

在 .NETCoreApp 內部，您將看到對 NuGet 的包引用；讓我們展開它。

您將看到整個系列的 NuGet 包引用。如果您在 .NET Framework 中工作過，那麼其中許多名稱空間看起來會很熟悉，因為您習慣於在 .NET Framework 中使用它。

.NET Framework 分為許多不同的部分，並使用 CoreFx 重新實現；這些部分進一步作為單獨的包分發。

現在，如果您展開 NETStandard.Library，您將看到其他引用。您甚至會注意到我們在此應用程式中使用的 System.Console。
現在您不必將 .NET Framework 中的所有內容都引入，而只需引入應用程式所需的內容即可。
還有一些其他好處；例如，如果需要，可以單獨更新這些模組。

模組化帶來了效能優勢，您的應用程式可以執行得更快，尤其是 ASP.NET Core 應用程式。

.NET Core - 專案檔案

在本章中，我們將討論 .NET Core 專案檔案以及如何在專案中新增現有檔案。

讓我們瞭解一個簡單的示例，其中我們有一些已建立的檔案；我們必須將這些檔案新增到我們的 FirstApp 專案中。

以下是Student.cs檔案的實現。

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Threading.Tasks; 
  
namespace FirstApp { 
   public class Student { 
      public int ID { get; set; } 
      public string LastName { get; set; } 
      public string FirstMidName { get; set; } 
      public DateTime EnrollmentDate { get; set; } 
   } 
}

以下是Course.cs檔案的實現。

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Threading.Tasks; 
  
namespace FirstApp { 
   public class Course { 
      public int CourseID { get; set; } 
      public string Title { get; set; } 
      public int Credits { get; set; } 
   } 
}

現在讓我們將這三個檔案儲存在您的磁碟上以及專案的原始檔夾中。

現在，如果您熟悉 .NET，並且這是一個傳統的 .NET Framework 控制檯應用程式，那麼瞭解如何在 Visual Studio 中的專案中新增這些檔案非常重要。
首先，您需要將檔案拖到解決方案資源管理器中，以將其複製到您的專案資料夾中，因為您的專案需要引用這些檔案。
.NET Core 的優點之一是採用專案檔案（project.json）的方法；我們只需將檔案放到專案的根目錄中，然後它們就會自動包含在我們的專案中。
我們不必像過去在 Visual Studio 中的傳統 .NET Framework 應用程式中那樣手動引用檔案。

現在讓我們開啟專案的根目錄。

現在讓我們將這三個檔案全部複製到專案的根目錄中。

您現在可以看到所有檔案都複製到了根資料夾中。

現在讓我們轉到 Visual Studio；您將收到以下對話方塊。

單擊**全部是**以重新載入您的專案。

您現在會發現檔案已自動包含在您的專案中。

.NET Core - 包引用

在本節中，我們將討論如何在 .NET Core 應用程式中新增包以及如何查詢特定包。我們可以直接轉到 NuGet 並新增包，但這裡我們將介紹其他一些地方。

現在讓我們轉到 .NET Core 的原始碼，它位於此處 - https://github.com/dotnet/corefx

在 CoreFx 儲存庫中，開啟**src**資料夾 -

您將看到與不同包相對應的整個資料夾列表。現在讓我們搜尋 Json -

還有另一種查詢包的方法，如果您熟悉 .NET Framework，您可能知道各種型別，但 .NET Core 中包的組裝方式完全不同，您將不知道這些包在哪裡。

如果您知道型別，則可以使用 https://packagesearch.azurewebsites.net/ 搜尋反向包搜尋。

在這裡，您可以輸入任何您想查詢的包型別。然後，此網站將掃描 NuGet 併為您找到相關的包。

現在讓我們搜尋**DataContractJson**。

您現在會看到我們獲得了相同的包；讓我們單擊該包。

您現在將看到 NuGet 頁面；您需要確認您需要此包。您可以使用幾種方法將其新增到您的應用程式中。

讓我們開啟 project.json 檔案。

{ 
   "version": "1.0.0-*", 
   "buildOptions": { 
      "emitEntryPoint": true 
   }, 
   "dependencies": { 
      "Microsoft.NETCore.App": { 
         "type": "platform", 
         "version": "1.0.1" 
      } 
   }, 
   "frameworks": { 
      "netcoreapp1.0": { 
         "imports": "dnxcore50" 
      } 
   } 
}

這是新的專案格式，在此檔案中，您將看到依賴項部分。讓我們新增一個新的依賴項，如下所示。

{ 
   "version": "1.0.0-*", 
   "buildOptions": { 
      "emitEntryPoint": true 
   }, 
   "dependencies": { 
      "Microsoft.NETCore.App": { 
         "type": "platform", 
         "version": "1.0.1" 
      }, 
      "System.Runtime.Serialization.Json": "4.0.2" 
   }, 
   "frameworks": { 
      "netcoreapp1.0": { 
         "imports": "dnxcore50" 
      } 
   } 
}

現在，如果您檢視您的引用，那麼您將看到**System.Runtime.Serialization.Json**包已新增到您的專案中。

另一種方法是轉到 NuGet 管理器並瀏覽您要新增的包。

.NET Core - 建立 UWP 應用程式

在本節中，我們將討論如何使用 .NET Core 建立 UWP 應用程式。UWP 也稱為 Windows 10 UWP 應用程式。此應用程式不會在先前版本的 Windows 上執行，而只會執行在未來版本的 Windows 上。

以下是一些 UWP 將順利執行的例外情況。

如果您想在本地執行它，則必須擁有 Windows 10，您也可以在 Windows 8 上開發，然後您需要在模擬器上執行它，但建議使用 Windows 10。
對於 UWP 應用程式，您還需要 Windows 10 SDK。讓我們開啟 Visual Studio 2015 安裝程式，然後修改 Visual Studio。
在“選擇功能”頁面上，向下滾動，您將看到“通用 Windows 應用開發工具”，選中該選項，如下所示。

在這裡，您可以看到 SDK 的不同版本以及工具的最新更新，單擊“下一步”。

現在，單擊**安裝**按鈕。

安裝完成後，您需要重新啟動系統。

現在讓我們按照以下步驟實現 UWP。

首先，啟動 Visual Studio 2015。
單擊“檔案”選單，然後選擇“新建”→“專案”；將顯示“新建專案”對話方塊。您可以在對話方塊的左側窗格中看到不同型別的模板。

在左側窗格中，您可以看到樹形檢視，現在從“模板”→“Visual C#”→“Windows”中選擇“通用”模板。
在中間窗格中，選擇“空白應用（通用 Windows）”模板。
透過在“名稱”欄位中鍵入**UWPFirstApp**並單擊“確定”來為專案命名。

將顯示目標版本/最低版本對話方塊。預設設定對於本教程來說是可以的，因此選擇“確定”以建立專案。

在這裡，我們有一個可以針對所有 Windows 10 裝置的單個專案，您會注意到 .NET Core 和 UWP 都是多目標的簡化。
當新專案開啟時，其檔案將顯示在解決方案資源管理器窗格的右側。您可能需要選擇解決方案資源管理器選項卡而不是屬性選項卡才能檢視您的檔案。
儘管“空白應用（通用視窗）”是一個最小的模板，但它仍然包含許多檔案。這些檔案對於所有使用 C# 的 UWP 應用都是必不可少的。您在 Visual Studio 中建立的每個專案都包含這些檔案。
要檢視正在執行的示例，讓我們開啟 MainPage.XAML 並新增以下程式碼。

<Page 
   x:Class = "UWPFirstApp.MainPage" 
   xmlns = "http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
   xmlns:x = "http://schemas.microsoft.com/winfx/2006/xaml" 
   xmlns:local = "using:UWPFirstApp" 
   xmlns:d = "http://schemas.microsoft.com/expression/blend/2008" 
   xmlns:mc = "http://schemas.openxmlformats.org/markup-compatibility/2006" 
   mc:Ignorable = "d">  
   
   <Grid Background = "{ThemeResource ApplicationPageBackgroundThemeBrush}"> 
      <StackPanel HorizontalAlignment = "Center"> 
         <TextBlock Text = "Hello, world!"  
            Margin = "20" 
            Width = "200" 
            HorizontalAlignment = "Left"/> 
         <TextBlock Text = "Write your name." 
            Margin = "20" 
            Width = "200" 
            HorizontalAlignment = "Left"/> 
         <TextBox x:Name = "txtbox"  
            Width = "280" 
            Margin = "20" 
            HorizontalAlignment = "Left"/> 
         <Button x:Name = "button" Content = "Click Me" 
            Margin = "20" 
            Click = "button_Click"/> 
         <TextBlock x:Name = "txtblock"  
            HorizontalAlignment = "Left" 
            Margin = "20"/> 
      </StackPanel> 
   </Grid> 

</Page>

以下是 C# 中按鈕的單擊事件。

using System; 
using System.Collections.Generic; 
using System.IO; 
using System.Linq; 
using System.Runtime.InteropServices.WindowsRuntime; 

using Windows.Foundation; 
using Windows.Foundation.Collections; 

using Windows.UI.Xaml; 
using Windows.UI.Xaml.Controls; 
using Windows.UI.Xaml.Controls.Primitives; 
using Windows.UI.Xaml.Data; 
using Windows.UI.Xaml.Input; 
using Windows.UI.Xaml.Media; 
using Windows.UI.Xaml.Navigation;  

// The Blank Page item template is documented at 
// http://go.microsoft.com/fwlink/?LinkId=402352&clcid=0x409  

namespace UWPHellowWorld { 
   /// <summary> 
   /// An empty page that can be used on its own or navigated to within a Frame. 
   /// </summary> 
   public sealed partial class MainPage : Page { 
      public MainPage() { 
         this.InitializeComponent(); 
      }  
      private void button_Click(object sender, RoutedEventArgs e) { 
         if (txtbox.Text != "") 
            txtblock.Text = "Hello: " + txtbox.Text; 
         else 
            txtblock.Text = "You have not write your name"; 
      } 
   } 
}

現在讓我們在本地計算機上執行上述程式碼，您將看到以下視窗。現在在文字框中鍵入任何名稱，然後按**單擊我**按鈕。

.NET Core - MSBuild

在本節中，我們將討論什麼是 MSBuild 以及它如何與 .NET Core 協同工作。MSBuild 是 Microsoft 和 Visual Studio 的構建平臺。在 UWP 應用程式中，如果您開啟專案資料夾，則會看到 project.json 和 *.csproj 檔案。

但是，如果您開啟我們之前的 .NET Core 控制檯應用程式，則會看到 project.json 和 *.xproj 檔案。

.NET Core 構建系統或 project.json 構建系統不足以滿足 UWP 的需求；這就是為什麼 UWP 仍在使用 *.csproj（MSBuild）構建系統。
但是，就構建系統而言，project.json 將被淘汰。
現在，如果您想將一些現有檔案新增到您的 UWP 應用程式中，就像我們在控制檯應用程式中新增的那樣，則需要將這些檔案新增到專案資料夾中。此外，您還需要在解決方案資源管理器中的專案中包含它們。

現在讓我們考慮以下檔案；將這些檔案複製到您的專案資料夾中。

讓我們回到 Visual Studio 並開啟解決方案資源管理器。

您現在可以看到，僅複製檔案對於 UWP 應用程式來說是不夠的，因為在解決方案資源管理器中，我們看不到這些檔案。
現在我們還必須包含這些檔案，方法是單擊上面螢幕截圖中突出顯示的**顯示所有檔案**圖示，您現在將看到專案資料夾中的所有檔案。

這兩個檔案仍未包含在我們的專案中。要包含這些檔案，請選擇這些檔案，右鍵單擊任何檔案，然後選擇**包含在專案中**。

現在這些檔案也被包含進來了。可以預見的一件好事是，project.json 的檔案放置方法將在未來版本的 SKD 工具以及 Visual Studio 中用於 *.csproj。

.NET Core - 元包

在本節中，我們將討論控制檯應用程式和 UWP 應用程式之間的引用。如果您檢視控制檯應用程式的解決方案資源管理器中的“引用”，您將看到 .NETCoreApp，如下所示。

.NETCoreApp 是一個針對 .NET Core 應用程式的新框架。現在，如果您檢視 UWP 應用程式的“引用”，它看起來會有點不同，如下所示。

造成這種情況的主要原因是，在這裡，在 UWP 中，我們有 *.csproj，因此我們回到了舊的引用樣式，並且我們只能使用此專案型別來定位一個框架。
引用雖然相似。您現在可以看到，在 UWP 應用程式中，Miscrosoft.NETCore.UniversalWindowsPlatform NuGet 包引用類似於控制檯應用程式中的 Microsoft.NETCore.App NuGet 引用。
Miscrosoft.NETCore.UniversalWindowsPlatform 和 Microsoft.NETCore.App 都是元包，這意味著它們由其他包組成。
在控制檯應用程式中，我們可以深入並檢視 Microsoft.NETCore.App 內的其他包，但我們無法在解決方案資源管理器中對 Miscrosoft.NETCore.UniversalWindowsPlatform 執行相同的操作。
但是，我們可以使用另一個工具 NuGet Package Explorer 來檢視它。現在讓我們在瀏覽器中開啟此 URL - https://npe.codeplex.com/downloads/get/clickOnce/NuGetPackageExplorer.application，您將看到一個小實用程式正在下載。
下載完成後，雙擊該檔案。

單擊**安裝**以開始在 NuGet Package Explorer 上安裝。

安裝完成後，您將看到以下對話方塊。

現在讓我們單擊**從聯機源開啟包**選項。

預設情況下，它將搜尋 nuget.org 源。現在讓我們在搜尋框中搜索 Microsoft.NETCore.UniversalWindowsPlatform，您將看到 1 個結果，如下所示。

單擊**開啟**連結，它將開啟此元包的頂級依賴項。

現在讓我們並排開啟 .NETCore 應用程式的 .NETCore 元包和 UWP 應用程式端的元包。

您現在可以看到每個元包都由不同的包集組成。
.NET Core 至少在目前是 .NET Framework 中可用類的子集，但它正在發展，並且將作為 .NET Framework 的基類的標準。
UWP 基於 .NET Core，它是 Windows 應用商店開發中可用 API 的超集。

由於 .NET Core，我們現在有更多可用於開發的 API。

Windows 執行時和擴充套件 SDK

Windows 執行時元件是您可以從任何語言（包括 C#、Visual Basic、JavaScript 和 C++）例項化和使用的自包含物件。除了我們在上一節中看到的 .NET Core 元包之外，UWP 應用程式預設情況下還引用了通用 Windows SDK。

通用 Windows 是對 Windows 執行時的引用，它已被分解成一系列 API 合同。

裝置系列中的 API 集被細分為稱為 API 合同的細分。您可以在此處找到不同 API 合同的列表 https://msdn.microsoft.com/en-us/library/windows/apps/dn706135.aspx

Windows 執行時內部的大多數 API 都被分解成一個合同。現在讓我們在 API 合同頁面上搜索 Universal 關鍵字。

您可以看到指向各種 API 的連結，您還可以看到通用系列非常龐大，有 12 頁文件。

您也可以在此頁面上搜索電話 API 合同。

現在讓我們單擊**Windows.Phone.PhoneContract**並向下滾動；您現在將看到手機或移動裝置的電池資訊。

如果您想在您已經擁有的內容之上新增此資訊，則應手動新增引用。現在讓我們轉到 Visual Studio 並右鍵單擊解決方案資源管理器中的“引用”。

選擇**新增引用…**

現在您可以看到通用 Windows 的新參考類別；在此類別下，有一個 Core，它指的是核心通用 Windows API 合同。

擴充套件允許我們擴充套件功能，您將看到不同的引用 Mobile、Desktop 和其他擴充套件。
有不同的 SKD 擴充套件，您可以新增更多 API。
您還可以看到不同的版本。因此，請確保您獲取最新版本以獲取更新的 API，然後單擊“確定”。

您現在可以看到用於 UWP 的 Windows Mobile 擴充套件已新增為引用。

.NET Core - 建立 .NET 標準庫

類庫定義了可以從任何應用程式呼叫的型別和方法。

使用 .NET Core 開發的類庫支援 .NET 標準庫，這允許您的庫被支援該版本的 .NET 標準庫的任何 .NET 平臺呼叫。
完成類庫後，您可以決定是將其作為第三方元件分發，還是將其作為與一個或多個應用程式捆綁在一起的元件包含。

讓我們從在控制檯應用程式中新增類庫專案開始；在解決方案資源管理器中右鍵單擊src資料夾，然後選擇新增→新建專案…

在新增新專案對話方塊中，選擇 .NET Core 節點，然後選擇類庫 (.NET Core) 專案模板。

在“名稱”文字框中，輸入“UtilityLibrary”作為專案名稱，如下所示。

單擊“確定”以建立類庫專案。建立專案後，讓我們新增一個新類。在解決方案資源管理器中右鍵單擊專案，然後選擇新增→類...

在中間窗格中選擇類，並在名稱和欄位中輸入 StringLib.cs，然後單擊新增。新增類後，將 StringLib.cs 檔案中的以下程式碼替換。

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Threading.Tasks; 
  
namespace UtilityLibrary { 
   public static class StringLib { 
      public static bool StartsWithUpper(this String str) { 
         if (String.IsNullOrWhiteSpace(str)) 
         return false; 
         Char ch = str[0]; 
         return Char.IsUpper(ch); 
      } 
      public static bool StartsWithLower(this String str) { 
         if (String.IsNullOrWhiteSpace(str)) 
         return false; 
         Char ch = str[0]; 
         return Char.IsLower(ch); 
      } 
      public static bool StartsWithNumber(this String str) { 
         if (String.IsNullOrWhiteSpace(str)) 
         return false;  
         Char ch = str[0]; 
         return Char.IsNumber(ch); 
      } 
   } 
}

類庫UtilityLibrary.StringLib包含一些方法，例如StartsWithUpper、StartsWithLower和StartsWithNumber，這些方法返回一個布林值，指示當前字串例項是否分別以大寫、小寫和數字開頭。
在 .NET Core 中，Char.IsUpper方法如果字元是大寫則返回 true，Char.IsLower 方法如果字元是小寫則返回 true，類似地，Char.IsNumber 方法如果字元是數字則返回 true。
在選單欄上，選擇生成，生成解決方案。專案應該能夠在沒有錯誤的情況下編譯。
我們的 .NET Core 控制檯專案無法訪問我們的類庫。
現在，要使用此類庫，我們需要在控制檯專案中新增此類庫的引用。

為此，展開 FirstApp 並右鍵單擊引用，然後選擇新增引用…

在引用管理器對話方塊中，選擇 UtilityLibrary（我們的類庫專案），然後單擊確定。

現在讓我們開啟控制檯專案的 Program.cs 檔案，並將所有程式碼替換為以下程式碼。

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

namespace FirstApp { 
   public class Program { 
      public static void Main(string[] args) { 
         int rows = Console.WindowHeight; 
         Console.Clear(); 
         do { 
            if (Console.CursorTop >= rows || Console.CursorTop == 0) { 
               Console.Clear(); 
               Console.WriteLine("\nPress <Enter> only to exit; otherwise, enter a string and press <Enter>:\n"); 
            } 
            string input = Console.ReadLine(); 
            
            if (String.IsNullOrEmpty(input)) break; 
            Console.WriteLine("Input: {0} {1,30}: {2}\n", input, "Begins with uppercase? ", 
            input.StartsWithUpper() ? "Yes" : "No"); 
         } while (true); 
      } 
   } 
}

現在讓我們執行您的應用程式，您將看到以下輸出。

為了更好地理解，讓我們在專案中使用類庫的其他擴充套件方法。

.NET Core - 可移植類庫

在本章中，我們將討論什麼是 PCL（可移植類庫），以及為什麼我們需要 PCL。為了理解這個概念，讓我們開啟我們在上一章中建立的類庫專案資料夾。

在此資料夾中，您可以看到除了 project.json 和 CS 檔案外，我們還有 *.xproj 檔案，這是因為 Visual Studio 將 .NET Core 專案型別設定為 *.xproj 而不是 *.csproj。

正如 Microsoft 所述，*.xproj 將消失，但它仍然存在於預覽版 2 工具中。正如我們所述，UWP 應用程式使用 *.csproj。

現在，實際上無法讓 *.csproj 引用 *.xproj，並且該功能不會被實現，因為 *.xproj 將被移除。

因此，我們需要一個可以在控制檯應用程式和 UWP 應用程式之間共享的類庫，這就是 PCL 的作用。

什麼是 PCL

現在讓我們瞭解什麼是 PCL -

可移植類庫專案使您能夠編寫和構建可在多個 .NET Framework 平臺上執行的託管程式集。
您可以建立包含您希望在多個專案中共享的程式碼（例如共享業務邏輯）的類，然後從不同型別的專案中引用這些類。
它還可以幫助您快速輕鬆地為 Microsoft 平臺構建跨平臺應用程式和庫。
可移植類庫可以幫助您減少開發和測試程式碼的時間和成本。
使用此專案型別編寫和構建可移植 .NET Framework 程式集，然後從面向多個平臺（如 Windows 和 Windows Phone 等）的應用程式中引用這些程式集。

現在讓我們從解決方案資源管理器中刪除我們建立的類庫。同時，將其從解決方案資料夾中刪除，並進一步新增新的專案項。

在左側窗格中選擇Visual C#→Windows模板，並在中間窗格中選擇類庫（可移植）。

在名稱欄位中輸入 StringLibrary，然後單擊確定以建立此專案。

現在我們需要選擇要引用的目標框架。讓我們暫時選擇 Windows 通用和 ASP.NET Core，然後我們將重新定位它。單擊確定。

您可以看到它已建立了一個 PCF 格式的新專案。現在讓我們在解決方案資源管理器中右鍵單擊 StringLibrary 專案，然後選擇屬性。

單擊目標 .NET 平臺標準。

單擊是；它現在是同一個類庫，只有一個細微的差別。不同之處在於它也可以被 UWP 使用，因為它包含 *.csproj 檔案而不是 *.xproj 檔案。

現在讓我們新增一個新類；為此，您需要在解決方案資源管理器中右鍵單擊專案，然後選擇新增→類...

在中間窗格中選擇類，並在名稱欄位中輸入StringLib.cs，然後單擊新增。新增類後，將 StringLib.cs 檔案中的以下程式碼替換。

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using System.Threading.Tasks; 
  
namespace StringLibrary { 
   public static class StringLib { 
      public static bool StartsWithUpper(this String str) { 
         if (String.IsNullOrWhiteSpace(str)) 
            return false; 
         Char ch = str[0]; 
         return Char.IsUpper(ch); 
      } 
      public static bool StartsWithLower(this String str) { 
         if (String.IsNullOrWhiteSpace(str)) 
            return false; 
         Char ch = str[0]; 
         return Char.IsLower(ch); 
      } 
      public static bool StartsWithNumber(this String str) { 
         if (String.IsNullOrWhiteSpace(str)) 
            return false; 
         Char ch = str[0]; 
         return Char.IsNumber(ch); 
      } 
   } 
}

讓我們構建此可移植類庫專案，它應該能夠在沒有錯誤的情況下編譯。現在我們需要在控制檯專案中新增此可移植類庫的引用。因此，展開 FirstApp 並右鍵單擊引用，然後選擇新增引用…

在引用管理器對話方塊中，選擇 StringLibrary（我們的可移植類庫專案），然後單擊確定。

您可以看到 StringLibrary 引用已新增到控制檯專案中，並且它也可以在 project.json 檔案中看到。

您現在可以再次執行應用程式，您將看到相同的輸出。

現在讓我們在專案中使用可移植類庫的其他擴充套件方法。相同的可移植庫也將被您的 UWP 應用程式使用。

.NET Core - 向庫新增引用

在本章中，我們將討論如何向庫新增引用。向庫新增引用就像向其他專案（如控制檯專案和 UWP 專案）新增引用一樣。

您現在可以看到 PCL 專案預設情況下有一些引用。您還可以根據應用程式需要新增其他引用。

在 PCL 庫中，您還可以看到 project.json 檔案。

{ 
   "supports": {}, 
   "dependencies": { 
      "NETStandard.Library": "1.6.0", 
      "Microsoft.NETCore.Portable.Compatibility": "1.0.1" 
   }, 
   "frameworks": { 
      "netstandard1.3": {} 
   } 
}

向庫新增引用的一種方法是直接在 project.json 檔案中鍵入它。如您所見，我們在依賴項部分添加了一些引用，如下面的程式碼所示。

{ 
   "supports": {}, 
   "dependencies": { 
      "NETStandard.Library": "1.6.0", 
      "Microsoft.NETCore.Portable.Compatibility": "1.0.1", 
      "System.Runtime.Serialization.Json": "4.0.3", 
      "Microsoft.EntityFrameworkCore": "1.1.0" 
   }, 
   "frameworks": { 
      "netstandard1.3": {} 
   } 
}

現在讓我們儲存此檔案，您將看到引用已新增到您的庫中。

向庫新增引用的另一種方法是 NuGet 包管理器。現在讓我們右鍵單擊StringLibrary（可移植）專案，然後選擇管理 NuGet 包…

在“瀏覽”選項卡上，您可以搜尋任何 NuGet 包；假設我們想要新增“System.Runtime.Serialization.Primitives”包。

單擊安裝按鈕，將顯示以下螢幕。

現在，單擊確定按鈕。

最後，單擊我接受按鈕開始安裝此 NuGet 包。安裝完成後，您將看到“System.Runtime.Serialization.Primitives”NuGet 包已新增到您的庫中。

.NET Core - 共享庫

在本章中，我們將討論如何將庫作為NuGet 包共享，以便可以在另一個專案中使用它。建立包從您要打包並與他人共享的程式碼開始，可以透過公共 nuget.org 庫或組織內的私有庫共享。該包還可以包含其他檔案，例如在安裝包時顯示的自述檔案，並且可以包含對某些專案檔案的轉換。

現在讓我們考慮一個簡單的示例，我們將從庫中建立一個 NuGet 包。為此，請開啟命令提示符並轉到庫專案 project.json 檔案所在的資料夾。

現在讓我們執行以下命令。

dotnet help

最後，您可以看到不同的命令，如 new、restore 和 build 等。

最後一個命令是pack；這將建立一個 NuGet 包。現在讓我們執行以下命令。

dotnet pack

您現在可以看到 NuGet 包已生成在 bin 資料夾中；讓我們開啟 bin\Debug 資料夾。

現在問題是 NuGet 包中包含什麼內容，要檢視它，我們可以使用 NuGet 包資源管理器。現在讓我們開啟 NuGet 包資源管理器。

選擇第一個選項開啟本地包。

選擇StringLibrary.1.0.0.nupkg並單擊開啟。

您可以看到在“包內容”部分中，我們只有 StringLibrary.dll。在“包元資料”部分中，您將看到一些關於此庫的資訊，例如 Id、版本和所有依賴項。

現在讓我們開啟StringLibrary.1.0.0.symbols.nupkg。

在此 NuGet 包中，您將看到原始檔和*.pdb檔案。如果雙擊StringLib.cs檔案，您也可以看到原始碼。

這裡的問題是，如何配置元資料，例如版本、作者和描述等。

project.json 檔案用於 .NET Core 專案定義專案元資料、編譯資訊和依賴項。現在讓我們開啟 project.json 檔案並新增以下其他資訊。

{ 
   "authors": [ "Mark Junior" ], 
   "description": "String Library API", 
   "version" : "1.0.1-*", 
   "supports": {}, 
   
   "dependencies": { 
      "Microsoft.EntityFrameworkCore": "1.1.0", 
      "Microsoft.NETCore.Portable.Compatibility": "1.0.1", 
      "NETStandard.Library": "1.6.0", 
      "System.Runtime.Serialization.Json": "4.0.3", 
      "System.Runtime.Serialization.Primitives": "4.3.0" 
   }, 
   "frameworks": { 
      "netstandard1.3": {} 
   } 
}

您現在可以看到此處添加了其他資訊，例如作者姓名、描述和版本。讓我們儲存此檔案，構建庫專案，然後再次執行“dotnet pack”命令。

在 bin\Debug 資料夾中，您可以看到 StringLibrary NuGet 包已生成，版本為 1.0.1；讓我們在 NuGet 包資源管理器中開啟它。

您將看到更新的元資料。現在問題是，如何在另一個包中使用它。

我們需要先發布到 NuGet 提要中的某個位置，然後才能在另一個專案中使用它。

有兩種選項可以釋出更新的元資料 -

釋出到 nuget.org
將元資料推送到私有 NuGet 源

這裡我們將使用私有 NuGet 源，因為它比在 nuget.org 上設定帳戶容易得多。要了解如何將您的包釋出到 nuget.org，您可以按照此處指定的準則操作 https://docs.microsoft.com/en-us/nuget/create-packages/publish-a-package。

請按照以下步驟將更新的元資料推送到私有 NuGet 源。

步驟 1 − 首先，我們需要 nuget 命令列實用程式，並且需要安裝它。現在讓我們開啟 NuGet 包管理器並搜尋 nuget.commandline。

步驟 2 − 選擇 Nuget.Commandline 並點選安裝。

步驟 3 − 點選確定安裝 Nuget.Commandline。您也可以透過從以下網址手動下載它來安裝它 https://dist.nuget.org/index.html，然後設定環境變數。

步驟 4 − 安裝完成後，讓我們再次開啟命令提示符並轉到bin\Debug資料夾（NuGet 包所在的資料夾）並指定以下命令−

nuget add StringLibrary.1.0.1.nupkg -Source D:\PrivateNugetPackages

步驟 5 − 在上述命令中，我們將 StringLibrary.1.0.1.nupkg 包新增到我們的私有源中，位置為D:\PrivateNugetPackages，-Source 指定包源。

步驟 6 − 您會看到已安裝StringLibrary；StringLibrary 可以進一步新增到私有源中。

步驟 7 − 讓我們轉到該資料夾。

步驟 8 − 在stringlibrary資料夾內，您將看到另一個包含版本名稱的資料夾，此處為 1.0.1。

NuGet 包位於此處。

建立 Xamarin.Forms 專案

在本章中，我們將討論如何使用我們建立併發布到私有 NuGet 源的 NuGet 包。因此，首先我們將建立一個 Xamarin.Forms 專案。我們需要首先了解什麼是 Xamarin.Forms。

Xamarin.Forms 是一個允許開發人員快速建立跨平臺使用者介面的框架。
Xamarin.Forms 是一個跨平臺的本機支援的 UI 工具包抽象，它允許開發人員輕鬆建立可以在 Android、iOS、Windows 和 Windows Phone 上共享的使用者介面。
使用者介面使用目標平臺的本機控制元件呈現，允許 Xamarin.Forms 應用程式保留每個平臺的適當外觀和風格。

要啟動 Xamarin.Forms，我們需要 Visual Studio 2015 中的一些其他功能。讓我們修改您的 Visual Studio 2015 並確保選擇了以下跨平臺移動開發選項。

安裝完成後，讓我們透過選擇工具→選項…更新 Xamarin。

向下滾動並在左側窗格中展開 Xamarin，然後選擇其他。在對話方塊的右上角，點選立即檢查以檢視是否有可用的更新。

您可以看到有可用的更新，讓我們點選下載按鈕開始下載。下載完成後，您將收到安裝更新的通知。

現在讓我們再次開啟 Visual Studio 並選擇檔案→新建→專案…選單選項。

在左側窗格中，選擇Visual C#→跨平臺模板，在中間窗格中，選擇空白 Xaml 應用（Xamarin.Forms 行動式）。在名稱欄位中輸入名稱，然後點選確定。

選擇目標版本和最低版本，然後點選確定。

您將看到一系列專案；在頂部，我們有 PCL 庫，它將在所有平臺（如 Android、iOS、UWP、Windows 8.1 和 Windows Phone 8.1）之間共享。

在這裡，我們將重點關注 PCL 庫，並在此處新增一些程式碼。讓我們擴充套件程式碼。

在此 Xamarin.Forms 模板中，您可以看到通用的 App.xaml 和 MainPage.xaml，使用 Xamarin.Forms XAML 框架，該框架可在這些平臺上執行。

我們需要匯入我們的程式碼，也需要我們在上一章中設定的私有 NuGet 源。

現在讓我們開啟 NuGet 包管理器。點選包源下拉列表旁邊的輪子。

我們需要在這裡新增我們的私有源，讓我們點選加號 (+) 按鈕。

您將看到在可用包源部分中添加了另一個複選框，讓我們指定一個名稱和源路徑，然後點選確定。

現在讓我們轉到瀏覽選項卡，從包源下拉列表中選擇 PrivateSource，您將看到 StringLibrary NuGet 包。選擇 StringLibrary 並點選安裝。

點選確定，您將看到一個錯誤。

我們無法使用 .NETPortable 配置檔案版本 259 的庫，我們將在下一章中修復此錯誤。

.NET Core - PCL 故障排除

在本章中，我們將修復在 Xamarin.Forms 專案中從我們的私有源安裝 NuGet 包時遇到的錯誤。

我們將進一步簡要了解問題。首先，讓我們右鍵點選 PCL 庫並選擇屬性。

在此頁面上，您將看到整個目標框架系列。從錯誤中，您可以看到 .NETPortable 配置檔案 259 與我們的 StringLibrary 1.0.1 不相容。但是，它試圖從 .NET Standard 1.1 庫中獲取引用。

現在讓我們看看 .NET Standard 庫並確定哪個平臺與我們的庫不相容。

您可以看到 Windows Phone Silverlight 8 與 .NET Standard 1.0 相容。如果您開啟以下網頁，那麼您將看到 Profile259 只能支援 .NET Standard 1.0。

現在讓我們取消選中 Windows Phone Silverlight 8。

點選確定按鈕。

現在要解決此問題，請點選確定並取消更改目標對話方塊，然後開啟包管理器控制檯並執行以下命令。

PM > Uninstall-Package Xamarin.Forms

現在讓我們轉到 PCL 庫的屬性。點選更改按鈕。

取消選中 Windows Phone Silverlight 8 並點選確定。

您現在可以看到 Windows Phone Silverlight 8 不再出現在目標框架中。您還可以看到當前的目標配置檔案。要檢視此內容，讓我們解除安裝 PCL 庫並編輯 XamarinApp.csproj 檔案。

您現在可以看到 TargetFrameworkProfile 現在是 Profile111。

如果您開啟文件，那麼您將看到 Profile111 支援 .NET Standard 1.1。

現在讓我們重新載入 PCL，然後開啟 NuGet 包管理器並嘗試從私有源安裝 StringLibrary 包。

從依賴項行為下拉列表中，選擇忽略依賴項，然後點選安裝。

您可以看到 StringLibrary 包現在已從私有源安裝。如果您展開 PCL 的引用，那麼您將看到 StringLibrary 引用也已新增，如下所示。

我們已解除安裝了 Xamarin.Forms 以解決 Windows Phone Silverlight 8 問題。需要重新安裝 Xamarin.Forms。建議安裝相同版本。

安裝完成後，讓我們在您的應用程式中使用 StringLibrary 功能。

.NET Core - 建立測試專案

在本章中，我們將討論如何使用 .NET Core 建立測試專案。單元測試是軟體的開發過程，該過程具有應用程式中最小的可測試部分，稱為單元。它們被單獨且獨立地審查以確保正常執行。單元測試可以自動化，也可以手動執行。

現在讓我們開啟新建專案對話方塊並選擇Visual C#→.NET Core模板。

在此對話方塊中，您可以看到沒有單元測試的專案模板。要建立單元測試專案，我們應該使用命令列實用程式。讓我們轉到我們建立的解決方案資料夾；建立一個測試資料夾，並在測試資料夾內建立另一個資料夾並將其命名為StringLibraryTests。

現在讓我們使用 dotnet 命令列實用程式透過執行以下命令建立一個新的測試專案−

dotnet new -t xunittest

您現在可以看到已建立了一個新的 C# 專案；讓我們透過執行v命令檢視資料夾，您將看到project.json和Tests.cs檔案，如下所示。

以下是 project.json 檔案中的程式碼。

{ 
   "version": "1.0.0-*", 
   "buildOptions": { 
      "debugType": "portable" 
   }, 
   "dependencies": { 
      "System.Runtime.Serialization.Primitives": "4.1.1", 
      "xunit": "2.1.0", 
      "dotnet-test-xunit": "1.0.0-rc2-192208-24" 
   }, 
   "testRunner": "xunit", 
   "frameworks": { 
      "netcoreapp1.0": { 
         "dependencies": { 
            "Microsoft.NETCore.App": { 
               "type": "platform", 
               "version": "1.0.1" 
            } 
         }, 
         "imports": [ 
            "dotnet5.4", 
            "portable-net451+win8" 
         ] 
      } 
   } 
}

以下是 Test.cs 檔案中的程式碼。

using System; 
using Xunit; 
namespace Tests { 
   public class Tests { 
      [Fact] 
      public void Test1() { 
         Assert.True(true); 
      } 
   } 
}

要從 NuGet 獲取必要的依賴項，讓我們執行以下命令−

dotnet restore

恢復必要的依賴項後，我們可以執行測試。

您可以看到編譯成功；當您向下滾動時，您可以看到一些有關執行的測試的資訊。

目前我們執行了 1 個測試，0 個錯誤，0 個失敗，0 個跳過，並且執行過程花費的時間也作為資訊提及。

.NET Core - 在 Visual Studio 中執行測試

在本章中，我們將討論如何在 Visual Studio 中執行測試。.NET Core 在設計時就考慮了可測試性，因此為您的應用程式建立單元測試比以往任何時候都更容易。在本章中，我們將在 Visual Studio 中執行和執行我們的測試專案。

讓我們在 Visual Studio 中開啟 FirstApp 解決方案。

您可以看到它只有兩個專案，您將無法看到測試專案，因為我們尚未將該專案新增到我們的解決方案中。

讓我們首先新增一個資料夾並將其命名為test。

右鍵點選test資料夾。

選擇project.json檔案並點選開啟。

以下螢幕截圖顯示了Tests.cs檔案中的程式碼作為輸出。

這是預設實現，它只是測試 True 是否等於 true。它是 xUnit 測試框架，您將看到註釋並表示測試方法的 Fact 屬性。

using System; 
using Xunit; 
  
namespace Tests { 
   public class Tests { 
      [Fact] 
      public void Test1() { 
         Assert.True(true); 
      } 
   } 
}

以下是project.json檔案的實現。

{ 
   "version": "1.0.0-*", 
   "buildOptions": { 
      "debugType": "portable" 
   }, 
   "dependencies": { 
      "System.Runtime.Serialization.Primitives": "4.1.1", 
      "xunit": "2.1.0", 
      "dotnet-test-xunit": "1.0.0-rc2-192208-24" 
   }, 
   "testRunner": "xunit", 
   "frameworks": { 
      "netcoreapp1.0": { 
         "dependencies": { 
            "Microsoft.NETCore.App": { 
               "type": "platform", 
               "version": "1.0.1" 
            }
         }, 
         "imports": [ 
            "dotnet5.4", 
            "portable-net451+win8" 
         ] 
      } 
   } 
}

在project.json檔案中，對測試框架最重要的依賴項是 xunit，它引入了 Fact 屬性。它引入了測試框架和用於使用 xunit 進行測試的 API。

我們還有dotnet-test-xunit，這是一個介面卡，以便 xunit 可以與 .NET Core 一起使用，特別是與dotnet test命令列實用程式一起使用。然後您將看到testRunner，它將執行 xunit，您還可以看到netcoreapp1.0框架。

您將在下面看到 .NETCore.App 依賴項。

要在 Visual Studio 中執行測試，讓我們從測試→視窗→測試資源管理器選單選項中開啟測試資源管理器。

您可以看到 Visual Studio 自動檢測到測試。測試的名稱由名稱空間.類名.測試方法名組成。現在讓我們點選測試資源管理器中的執行全部按鈕。

它將首先構建程式碼並執行測試，您將看到測試花費的總時間。讓我們更改測試方法，以便我們可以在測試失敗時看到輸出。

using System; 
using Xunit; 
  
namespace Tests { 
   public class Tests { 
      [Fact] 
      public void Test1() { 
         Assert.True(false); 
      } 
   } 
}

讓我們透過點選執行全部按鈕連結再次執行測試。

您現在可以看到測試失敗。

.NET Core - 測試庫

在本章中，我們將測試我們的 StringLibrary，為此，我們需要重新排列我們的專案，以便我們可以遵循預設約定。

讓我們開啟global.json檔案。

{ 
   "projects": [ "src", "test" ], 
   "sdk": { 
      "version": "1.0.0-preview2-003131" 
   } 
}

在此檔案的頂部，您將看到專案設定，它預設設定了一些資料夾，例如src和test。

根據約定，我們必須在這些資料夾中擁有專案，這是新的約定，它將作為 .NET Core 的一部分使用。

在解決方案資源管理器中，您可以看到控制檯專案和庫專案都在src資料夾內，而測試專案在test資料夾內。

並且解決方案資源管理器中的專案結構並不代表專案在磁碟上的實際位置。現在讓我們開啟解決方案資料夾，您會看到StringLibrary專案不在src資料夾內。

您可以看到src和test資料夾都對映到global.json檔案中指定的約定。但是，我們有一個專案StringLibrary不符合約定。現在讓我們將StringLibrary專案新增到src資料夾內。

在src資料夾中，我們有兩個專案，我們需要修復問題，以便我們可以正確使用所有專案。讓我們回到Visual Studio，右鍵單擊StringLibrary專案，然後選擇“刪除”選項。它不會刪除它，而只會刪除專案。

現在右鍵單擊src資料夾，然後選擇新增→現有專案…

瀏覽到現在位於src資料夾內的StringLibrary專案，選擇StringLibrary.csproj檔案，然後單擊開啟。

現在我們必須從控制檯應用程式的project.json檔案中刪除StringLibrary的引用。

{ 
   "version": "1.0.0-*", 
   "buildOptions": { 
      "emitEntryPoint": true 
   }, 
   "dependencies": { 
      "Microsoft.NETCore.App": { 
         "type": "platform", 
         "version": "1.0.1" 
      }, 
      "NuGet.CommandLine": "3.5.0", 
      "System.Runtime.Serialization.Json": "4.0.3" 
   }, 
   "frameworks": { 
      "netcoreapp1.0": { 
         "dependencies": { }, 
         "imports": "dnxcore50" 
      } 
   } 
}

儲存更改，然後在控制檯專案中再次新增StringLibrary的引用。

{ 
   "version": "1.0.0-*", 
   "buildOptions": { 
      "emitEntryPoint": true 
   }, 
   "dependencies": { 
      "Microsoft.NETCore.App": { 
         "type": "platform", 
         "version": "1.0.1" 
      }, 
   "NuGet.CommandLine": "3.5.0", 
      "System.Runtime.Serialization.Json": "4.0.3" 
   }, 
   "frameworks": { 
      "netcoreapp1.0": { 
         "dependencies": { 
            "StringLibrary": { 
               "target": "project" 
            } 
         }, 
         "imports": "dnxcore50" 
      } 
   } 
}

現在一切應該都重新工作了，您可以構建StringLibrary，然後構建FirstApp（控制檯專案）而不會出現任何錯誤。現在讓我們使用xunit測試StringLibrary的功能。我們需要將StringLibrary的引用新增到我們的測試專案中。右鍵單擊StringLibraryTests專案的“引用”，然後選擇“新增引用…”。

單擊確定，這將向我們的測試專案新增StringLibrary的引用。現在讓我們替換Tests.cs檔案中的以下程式碼。

using System; 
using Xunit; 
using StringLibrary; 
  
namespace Tests { 
   public class Tests { 
      [Fact] 
      public void StartsWithUpperCaseTest() { 
         string input = "Mark"; 
         Assert.True(input.StartsWithUpper()); 
      } 
      [Fact] 
      public void StartsWithLowerCaseTest() { 
         string input = "mark"; 
         Assert.True(input.StartsWithLower()); 
      } 
      [Fact] 
      public void StartsWithNumberCaseTest() { 
         string input = "123"; 
         Assert.True(input.StartsWithNumber()); 
      } 
   } 
}

您可以看到我們有三個測試方法，它們將測試StringLibrary的功能。讓我們單擊執行全部連結，您將在測試資源管理器中看到以下輸出。

您也可以從命令列執行測試。讓我們開啟命令提示符並執行dotnet test命令。

託管可擴充套件性框架

在本章中，我們將討論託管可擴充套件性框架 (MEF)。MEF 可用於第三方外掛擴充套件，或者可以為常規應用程式帶來鬆散耦合外掛式架構的優勢。

MEF 是一個用於建立輕量級、可擴充套件應用程式的庫。
它允許應用程式開發人員發現和使用擴充套件，而無需任何配置。
MEF 是 .NET Framework 4 的組成部分，並且在使用 .NET Framework 的任何地方都可用，從而提高了大型應用程式的靈活性和可維護性以及可測試性。
您可以在客戶端應用程式中使用 MEF，無論它們使用 Windows 窗體、WPF 還是任何其他技術，或者在使用 ASP.NET 的伺服器應用程式中使用 MEF。
MEF 也已作為Microsoft.Composition移植到 .NET Core，但僅部分移植。
僅移植了System.Composition，而System.ComponentModel.Composition尚不可用。這意味著，我們沒有可以從目錄中的程式集中載入型別的目錄。

在本章中，我們只學習如何在 .NET Core 應用程式中使用 MEF。

讓我們瞭解一個簡單的示例，在該示例中，我們將在 .NET Core 控制檯應用程式中使用 MEF。現在讓我們建立一個新的 .NET Core 控制檯專案。

在左側窗格中，選擇模板→Visual C#→.NET Core，然後在中間窗格中，選擇控制檯應用程式 (.NET Core)。

在“名稱”欄位中輸入專案的名稱，然後單擊“確定”。

建立專案後，我們需要新增 Microsoft.Composition 的引用，以便我們可以使用 MEF。為此，讓我們右鍵單擊解決方案資源管理器中的專案，然後選擇管理 NuGet 包…

搜尋Microsoft.Composition，然後單擊安裝。

點選確定按鈕。

單擊我接受按鈕。

安裝完成後，您將在“引用”中發現錯誤。

讓我們開啟project.json檔案。

{ 
   "version": "1.0.0-*", 
   "buildOptions": { 
      "emitEntryPoint": true 
   }, 
  
   "dependencies": { 
      "Microsoft.Composition": "1.0.30", 
      "Microsoft.NETCore.App": { 
         "type": "platform", 
         "version": "1.0.1" 
      } 
   }, 
  
   "frameworks": { 
      "netcoreapp1.0": { 
         "imports": "dnxcore50" 
      } 
   } 
}

您可以看到已新增Microsoft.Composition依賴項，但問題是此包與dnxcore50不相容。因此，我們需要匯入portablenet45+win8+wp8+wpa81。現在讓我們用以下程式碼替換您的project.json檔案。

{ 
   "version": "1.0.0-*", 
   "buildOptions": { 
      "emitEntryPoint": true 
   }, 
   "dependencies": { 
      "Microsoft.Composition": "1.0.30", 
      "Microsoft.NETCore.App": { 
         "type": "platform", 
         "version": "1.0.1"
      } 
   }, 
   "frameworks": { 
      "netcoreapp1.0": { 
         "imports": "portable-net45+win8+wp8+wpa81" 
      } 
   } 
}

儲存此檔案，您將看到錯誤已更正。

如果展開“引用”，則會看到Microsoft.Composition的引用。

首先，我們需要建立一個要匯出的介面並實現該介面，並使用匯出屬性裝飾該類。現在讓我們新增一個新類。

在“名稱”欄位中輸入類的名稱，然後單擊新增。

讓我們在PrintData.cs檔案中新增以下程式碼。

using System; 
using System.Collections.Generic; 
using System.Composition; 
using System.Linq; 
using System.Threading.Tasks; 
  
namespace MEFDemo { 
   public interface IPrintData { 
      void Send(string message); 
   } 
   [Export(typeof(IPrintData))] 
   public class PrintData : IPrintData { 
      public void Send(string message) { 
         Console.WriteLine(message); 
      } 
   } 
}

如上所述，目錄在 Microsoft.Composition 名稱空間中不可用。因此，它將載入程式集中所有帶有匯出屬性的型別，並將其附加到 Program.cs 檔案中 Compose 方法中顯示的匯入屬性。

using System; 
using System.Collections.Generic; 
using System.Composition; 
using System.Composition.Hosting; 
using System.Linq; 
using System.Reflection; 
using System.Threading.Tasks; 
  
namespace MEFDemo { 
   public class Program { 
      public static void Main(string[] args) { 
         Program p = new Program(); 
         p.Run(); 
      } 
      public void Run() { 
         Compose(); 
         PrintData.Send("Hello,this is MEF demo"); 
      } 
      [Import] 
      public IPrintData PrintData { get; set; } 
      
      private void Compose() { 
         var assemblies = new[] { typeof(Program).GetTypeInfo().Assembly }; 
         var configuration = new ContainerConfiguration() 
            .WithAssembly(typeof(Program).GetTypeInfo().Assembly); 
         
         using (var container = configuration.CreateContainer()) { 
            PrintData = container.GetExport<IPrintData>(); 
         } 
      } 
   } 
}

現在讓我們執行您的應用程式，您將看到它透過例項化PrintData類來執行。

要了解有關 MEF 的更多資訊，請訪問以下網址https://msdn.microsoft.com/en-us/library/dd460648%28v=vs.110%29.aspx瞭解更多詳細資訊。

.NET Core - SDK

在本章中，我們將瞭解 .NET Core 中即將推出的功能。我們將從 .NET 命令列工具開始，方法是在瀏覽器中開啟以下網址https://github.com/dotnet/cli

要了解有關進度的更多資訊，您可以下載最新版本的 .NET Core SDK，向下滾動，您將看到“安裝程式和二進位制檔案”部分。

您可以看到不同作業系統的最新預覽版工具，讓我們根據您的作業系統選擇安裝程式。

我們正在使用 .NET Core 2.0 的預覽版 1。

現在讓我們透過開啟命令提示符並執行以下命令來檢視我們當前的工具。

dotnet --info

您將看到有關係統上當前安裝的 .NET 命令列工具版本的資訊，如下所示。

您可以看到我們目前有預覽版 2 工具。現在讓我們執行以下命令以檢視有關new命令的資訊。

dotnet help new

對於專案的新的命令語言，您可以選擇 C# 和 F# 以及專案型別等。

現在讓我們看看 .NET Core 最新版本中的更改。下載安裝程式後，雙擊它進行安裝。單擊“安裝”。

以下螢幕截圖顯示了安裝過程。

它將啟動安裝過程。安裝完成後，關閉此對話方塊。

開啟命令提示符並執行以下命令。

dotnet --info

您將看到有關係統上當前安裝的 .NET 命令列工具版本的資訊，如下所示。

您現在可以看到我們有 .NET Core 2 的預覽版 1 工具。現在讓我們在命令提示符中執行以下程式碼以檢視 .NET Core 2 預覽版 1 中的新命令。

dotnet help new

該命令還可以幫助您將軟體包下載到軟體包快取中。

該命令將開啟以下網頁，其中包含有關 .NET Core 2 預覽版 1 中的新命令的資訊。

讓我們向下滾動，您現在可以看到我們可以使用更多模板建立 .NET Core 應用程式。

我們現在還可以使用命令列建立mstest、web、mvc和webapi專案。

.NET Core - MSBuild 和 project.json

.NET Core 已決定放棄 project.json 並返回到 MSBuild 和 *.csproj。這在剛剛釋出的 .Net Core 2.0 預覽版 1 工具中已經發生了。這相當令人失望，因為 project.json 是一股清新的空氣。但是，這是可以理解的，並且也有許多優點。

現在讓我們討論此更改帶來的優勢：

這將使現有 Visual Studio 解決方案向 .NET Core 的過渡變得簡單。
這是一個巨大的變化，它還將能夠利用圍繞 MSBuild 的 CI/RM 中現有的投資。
在 MSBuild 中構建期間，我們可以考慮增量編譯、解決構建時依賴項、配置管理等。
需要大量工作才能按時交付 dotnet cli，因為它不再僅僅是關於 ASP.NET Core，還包括控制檯應用程式、UWP 應用程式等。

以下是 MSBuild 和 *.csproj 中的更改：

Project.json 檔案 (*.xproj) 將由 MSBuild (*.csproj) 替換。
Project.json 中的功能將開始合併回 *.csproj 中。
目前尚不清楚他們將如何處理程式包列表，但有人提到他們可能會將其保留為nuget.json下的 json 或將其合併到*.csproj中。
據推測，如果使用 Visual Studio，則此轉換應該很順利，並且可能自動進行。

MSBuild 的優勢

MSBuild 是開源的，可在 GitHub 上獲得，並且註定將成為完全跨平臺的。
MSBuild 將顯著簡化和修剪*.csproj的結構。
Microsoft 還引入了一個新的專案系統，它將能夠在無需 Visual Studio 的情況下實現許多方案，詳細資訊在以下網址提供https://github.com/dotnet/roslyn-project-system/。
目標是即使使用 MSBuild 設定，在 Visual Studio IDE 中和 IDE 外部使用構建和專案都將同樣無縫。

MSBuild 與 project.json

現在讓我們透過執行以下命令使用 .NET Core 預覽版 2 工具建立一個新的控制檯專案。

dotnet new -t console

要檢視在此專案中建立的所有檔案，請執行dir命令。

您可以看到建立了兩個檔案，Program.cs和project.json檔案。

現在讓我們透過執行以下命令使用 .NET Core 2 預覽版 1 工具建立一個控制檯應用程式。

dotnet new console

要檢視在此專案中建立的所有檔案，請執行dir命令。您可以看到建立了三個檔案，Program.cs、NuGet.config和MSBuild.csproj，而不是 project.json 檔案。

現在讓我們並排比較project.json和MSBuild.csproj檔案。

在左側，我們有 json 格式的檔案，而在右側，檔案為 XML 格式。您可以看到在 project.json 檔案中，在 dependencies 部分內，有netcoreapp1.0，而在 MSBuild.csproj 檔案中，您將看到netcoreapp2.0。

使用 MSBuild 還原和構建

在本節中，我們將討論如何使用命令列工具還原和構建您的 MSBuild (*.csproj) 檔案。要檢視 .NET Core 2.0 預覽版 1 中可用的命令，讓我們執行以下命令。

dotnet help

您將看到所有命令，例如 new、restore、build 等。

以下是 **Program.cs** 檔案中的預設實現。

using System;  
namespace MSBuild { 
   class Program { 
      static void Main(string[] args) { 
         Console.WriteLine("Hello World!"); 
      } 
   } 
}

現在讓我們執行以下命令以檢視進度。