.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!"); 
      } 
   } 
}

现在让我们执行以下命令以查看进度。