.NET Core - 快速指南

.NET Core - 概述

.NET Core 是 Microsoft 维护的最新通用开发平台。它可以跨不同平台工作，并经过重新设计，使 .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 和应用程序场景将随着时间的推移而增长，由 Microsoft、其他公司和个人提供。

灵活部署

  • .NET Core 应用程序可以有两种类型的部署 -

    • 依赖框架的部署

    • 独立部署

  • 通过依赖于框架的部署，您的应用程序依赖于安装了您的应用程序和第三方依赖项的系统范围版本的 .NET Core。

  • 通过独立部署，用于构建应用程序的 .NET Core 版本也会与您的应用程序和第三方依赖项一起部署，并且可以与其他版本并行运行。

命令行工具

  • 所有产品场景都可以在命令行上执行。

兼容的

  • .NET Core 通过 .NET 标准库与 .NET Framework、Xamarin 和 Mono 兼容

模块化的

  • .NET Core 通过 NuGet 以较小的程序包形式发布。

  • .NET Framework 是一个包含大部分核心功能的大型程序集。

  • .NET Core 作为较小的以功能为中心的包提供。

  • 这种模块化方法使开发人员能够通过在应用程序中仅包含他们需要的 NuGet 包来优化他们的应用程序。

  • 较小的应用程序表面积的好处包括更严格的安全性、减少的服务、提高的性能以及降低按使用量付费模式的成本。

.NET Core 平台

.NET Core 平台包含以下主要部分 -

  • .NET Runtime - 它提供类型系统、程序集加载、垃圾收集器、本机互操作和其他基本服务。

  • 基本库- 一组框架库，提供原始数据类型、应用程序组合类型和基本实用程序。

  • SDK 和编译器- 一组 SDK 工具和语言编译器，可在 .NET Core SDK 中提供基本的开发人员体验。

  • 'dotnet' 应用程序主机- 用于启动 .NET Core 应用程序。它选择运行时并托管运行时，提供程序集加载策略并启动应用程序。同一主机也用于以大致相同的方式启动 SDK 工具。

.NET Core - 先决条件

在本章中，我们将讨论您需要部署和运行的各种依赖项。其中包括使用 Visual Studio 开发的 Windows 计算机上的 .NET Core 应用程序。

支持的 Windows 版本

以下版本的 Windows 支持 .NET Core -

  • Windows 7 SP1
  • Windows8.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 C++ Redistributable for Visual Studio 2015。

  • 对于 Windows 7 和 Windows Server 2008 计算机，您需要确保您的 Windows 安装是最新的，并且还包括通过 Windows 更新安装的修补程序 KB2533623。

Visual Studio 的先决条件

  • 要使用 .NET Core SDK 开发 .NET Core 应用程序，您可以使用您选择的任何编辑器。

  • 但是，如果您想使用 Visual Studio 在 Windows 上开发 .NET Core 应用程序，您可以使用以下两个版本 -

    • 视觉工作室 2015

    • Visual Studio 2017 RC

  • 默认情况下，使用 Visual Studio 2015 创建的项目将基于 project.json，而使用 Visual Studio 2017 RC 创建的项目将始终基于 MSBuild。

.NET Core - 环境设置

在本章中，我们将讨论.NET Core的环境设置。这是对 .NET Framework 的重大重新设计。要在应用程序中使用 .NET Core，您可以使用两个版本 -

  • 视觉工作室 2015
  • Visual Studio 2017 RC

视觉工作室 2015

要使用 Visual Studio 2015，您必须安装以下软件 -

  • 微软 Visual Studio 2015 更新 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/下载

您还可以按照以下 URL 上的安装指南进行操作：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 Tooling Preview 2。

发射

步骤 8 - 选中复选框并单击安装。

复选框

步骤 9 - 安装完成后，您将看到以下对话框。

应用准备就绪

您现在已准备好使用 .NET Core 启动应用程序。

视觉工作室 2017

在本教程中，我们将使用 Visual Studio 2015，但如果您想使用 Visual Studio 2017，Visual Studio 2017 RC 中包含适用于 Visual Studio 的 .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 字节到 8 字节不同范围的有符号和无符号整数。所有整数都是值类型。

下表列出了整数类型及其大小；

类型 签名/未签名 大小（字节） 最小值 最大值
字节 未签名 1 0 255
整数16 签 2 −32,768 32,767
整数32 签 4 −2,147,483,648 2,147,483,647
整型64 签 8 −9,223,372,036,854,775,808 9,223,372,036,854,775,807
字节 签 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 包含三种原始浮点类型，如下表所示。

类型 大小（字节） 最小值 最大值
双倍的 8 −1.79769313486232e308 1.79769313486232e308
单身的 4 −3.402823e38 3.402823e38
十进制 16 −79,228,162,514,264,337,593,5 43,950,335 79,228,162,514,264,337,593,543,9 50,335

  • 每个浮点类型都支持一组标准算术、比较、相等、显式转换和隐式转换运算符。

  • 您还可以使用 BitConverter 类处理 Double 和 Single 值中的各个位。

  • Decimal 结构具有其自己的方法 Decimal.GetBits 和 Decimal.Decimal(Int32())，用于处理十进制值的各个位，以及它自己的一组用于执行一些附加数学运算的方法。

大整数

  • System.Numerics.BigInteger 是一种不可变类型，表示任意大的整数，其值理论上没有上限或下限。

  • BigInteger 类型的方法与其他整型类型的方法非常相似。

复杂的

  • System.Numerics.Complex 类型表示复数，即具有实数部分和虚数部分的数字

  • 它支持一组标准的算术、比较、相等、显式转换和隐式转换运算符，以及数学、代数和三角方法。

单指令多数据流

  • Numerics 命名空间包含一组支持 SIMD 的 .NET Core 向量类型。

  • SIMD 允许在硬件级别并行化某些操作，从而显着提高在向量上执行计算的数学、科学和图形应用程序的性能。

  • .NET Core 中支持 SIMD 的向量类型包括以下内容 -

    • System.Numerics.Vector2、System.Numerics.Vector3 和 System.Numerics.Vector4 类型，它们是 Single 类型的 2、3 和 4 维向量。

    • Vector <T> 结构允许您创建任何原始数字类型的向量。原始数值类型包括 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)

  • 在第一代中，对象有第二次机会空间。

  • 生命周期较短但在第 0 代收集中幸存下来的对象（通常基于巧合的时间）将进入第 1 代。

  • 第一代收集也很快，因为它的关联堆也很小。

  • 前两个堆仍然很小，因为对象要么被收集，要么被提升到下一代堆。

第三代 (2)

  • 在第 2 代中，所有长对象都已存活，并且其堆可能会变得非常大。

  • 这一代中的对象可以存活很长时间，并且没有下一代堆来进一步提升对象。

  • 垃圾收集器有一个用于存储大型对象的附加堆，称为大型对象堆 (LOH)。

  • 它是为 85,000 字节或更大的对象保留的。

  • 大对象不分配到分代堆，而是直接分配到 LOH

  • 对于运行很长时间或处理大量数据的程序来说，第二代和 LOH 收集可能会花费相当长的时间。

  • 众所周知，大型服务器程序的堆大小为数十 GB。

  • GC 采用多种技术来减少阻塞程序执行的时间。

  • 主要方法是在后台线程上以不干扰程序执行的方式尽可能多地进行垃圾收集工作。

  • GC 还向开发人员公开了一些影响其Behave的方法，这对于提高性能非常有用。

.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 代码执行

  • 在 .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 框架中已有的所有这些组件。

  • 所以答案和微软为什么要实现.NET Core是一样的。

.NET Core - 模块化

构建和实现模块化应用程序是.NET Core的另一个考虑因素。您的应用程序现在可以只安装所需的内容，而无需安装整个 .NET Framework。让我们去视觉工作室看看模块化。

这是解决方案资源管理器中的简单 .NET Core 应用程序。让我们展开引用，您将看到对 .NETCoreApp 的引用

.Net核心应用程序

在 .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 框架控制台应用程序，那么了解如何在 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文件夹 -

核心FX

您将看到与不同包相对应的文件夹的完整列表。现在让我们搜索 Json -

杰森

还有另一种方法可以找到你的包，如果你熟悉.NET Framework，你可能知道各种类型，但是.NET Core中包的组装完全不同，你不会知道包在哪里。

如果您知道类型，则可以使用https://packagesearch.azurewebsites.net/进行反向包搜索

反向套餐

您可以在此处输入您想要查找的任何类型的包裹。然后，该站点将扫描 NuGet 并为您找到相关的包。

现在让我们搜索DataContractJson。

数据契约Json

现在你会看到我们得到了相同的包；让我们点击包。

包裹

您现在将看到 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以及Tools的最新更新，点击Next。

专业2015

现在，单击“安装”按钮。

安装按钮

安装完成后，您将需要重新启动系统。

设置完成

现在让我们按照以下步骤实施 UWP。

  • 首先，启动 Visual Studio 2015。

  • 单击“文件”菜单，选择“新建”→“项目”；将显示一个新项目对话框。您可以在对话框的左侧窗格中看到不同类型的模板。

文件菜单

  • 在左侧窗格中，您可以看到树视图，现在从模板 → Visual C# → Windows 中选择通用模板。

  • 从中心窗格中，选择空白应用程序（通用 Windows）模板。

  • 通过在“名称”字段中键入UWPFirstApp为项目命名，然后单击“确定”。

UWP第一应用程序

  • 出现目标版本/最低版本对话框。默认设置适合本教程，因此选择“确定”来创建项目。

默认设置

  • 在这里，我们有一个可以针对所有 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"; 
      } 
   } 
}

现在让我们在本地计算机上运行上面的代码，您将看到以下窗口。现在，在文本框中输入任意名称，然后按“Click Me”按钮。

点我

.NET 核心 - MSBuild

在本章中，我们将讨论什么是 MSBuild 以及它如何与 .NET Core 一起工作。MSBuild 是 Microsoft 和 Visual Studio 的构建平台。在 UWP 应用程序中，如果打开项目文件夹，您将看到 project.json 和 *.csproj 文件。

项目.json

但是，如果您打开我们之前的 .NET Core Console 应用程序，那么您将看到 project.json 和 *.xproj 文件。

文件

  • .NET Core 构建系统或project.json 构建系统不足以满足 UWP 需求；这就是 UWP 仍然使用 *.csproj (MSBuild) 构建系统的原因。

  • 但就构建系统而言，project.json 将移出。

  • 现在，如果您想将一些现有文件添加到 UWP 应用程序（就像我们在控制台应用程序中添加的那样），那么您需要将这些文件添加到项目文件夹中。此外，您还需要将其包含在解决方案资源管理器中的项目中。

现在让我们考虑以下文件；将这些文件复制到您的项目文件夹中。

项目文件夹

项目

让我们返回 Visual Studio 并打开解决方案资源管理器。

解决方案浏览器

  • 您现在可以看到，对于 UWP 应用程序，仅复制文件是不够的，因为在解决方案资源管理器中，我们看不到这些文件。

  • 现在，我们还必须通过单击上面屏幕截图中突出显示的“显示所有文件”图标来包含这些文件，您现在将看到项目文件夹中的所有文件。

显示所有文件

这两个文件仍然没有包含在我们的项目中。要包含这些文件，请选择这些文件并右键单击任意文件，然后选择“包含在项目中”。

包含在项目中

现在这些文件也包含在内。可以预见的一件好事是在未来版本的 SKD 工具以及 Visual Studio 中使用 project.json 方法将 *.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 来查看这一点。现在让我们在浏览器中打开此网址 - https://npe.codeplex.com/downloads/get/clickOnce/NuGetPackageExplorer.application，您将看到一个小实用程序正在下载。

  • 下载完成后，双击该文件。

打开文件

  • 单击“安装”以在 NuGet Package Explorer 上开始安装。

NuGet 包资源管理器

  • 安装完成后，您将看到以下对话框。

完成的

  • 现在让我们单击“从在线源打开包”选项。

在线饲料

  • 默认情况下，它将搜索 nuget.org feed。现在让我们在搜索框中搜索 Microsoft.NETCore.UniversalWindowsPlatform，您将看到 1 个结果，如下所示。

Nuget 组织提要

  • 单击打开链接，它将打开此元包的顶级依赖项。

打开链接

  • 现在让我们并排打开 .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 SDK

通用 Windows 是对 Windows 运行时的引用，它已被纳入一系列 API 合约中。

设备系列中的 API 集被细分为称为 API 合约的细分部分。您可以在此处找到不同 API 合约的列表https://msdn.microsoft.com/en-us/library/windows/apps/dn706135.aspx

应用程序编程接口

Windows 运行时内的大多数 API 都被纳入单个合约中。现在让我们在 API 合约页面上搜索 Universal 关键字。

API 合约页面

您可以看到各种 API 的链接，还可以看到 Universal 系列非常庞大，有 12 页的文档。

您还可以在此页面搜索电话API合约。

电话API

现在让我们单击Windows.Phone.PhoneContract并向下滚动；您现在将看到手机或移动设备的电池信息。

电池信息

如果您想在已有信息的基础上添加此信息，那么您应该手动添加引用。现在让我们转到 Visual Studio 并右键单击“解决方案资源管理器”中的“引用”。

选择添加引用...

添加参考文献

您现在可以看到通用 Windows 的新参考类别；此类别下有 Core，指的是核心通用 Windows API 合约

API合约

  • 扩展允许我们扩展功能，您将看到不同的参考移动、桌面和其他扩展。

  • 有不同的 SKD 扩展，您可以在顶部添加以获得更多 API。

  • 您还可以看到不同的版本。因此，请确保您获取最新版本以获得更新的 API，然后单击“确定”。

更新的API

您现在可以看到UWP 的 Windows Mobile 扩展已添加为参考。

.NET Core - 创建 .NET 标准库

类库定义了可以从任何应用程序调用的类型和方法。

  • 使用 .NET Core 开发的类库支持 .NET 标准库，这允许任何支持该版本的 .NET 标准库的 .NET 平台调用您的库。

  • 完成类库后，您可以决定是否要将其作为第三方组件分发，或者是否要将其作为与一个或多个应用程序捆绑在一起的组件包含在内。

让我们首先在控制台应用程序中添加一个类库项目；右键单击“解决方案资源管理器”中的src文件夹，然后选择“添加”→“新建项目...”

新项目

在“添加新项目”对话框中，选择“.NET Core”节点，然后选择“类库 (.NET Core)”项目模板。

在“名称”文本框中输入“UtilityLibrary”作为项目的名称，如下图所示。

实用程序库

单击“确定”创建类库项目。创建项目后，让我们添加一个新类。右键单击“解决方案资源管理器”中的项目，然后选择“添加”→“类...”

班级

在中间窗格中选择类，并在名称和字段中输入 StringLib.cs，然后单击Add。添加类后，替换 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 等）的应用程序引用这些程序集。

现在让我们删除从解决方案资源管理器中创建的类库。同时，将其从Solution文件夹中删除，并进一步添加新的项目项。

消除

在左侧窗格中选择Visual C# → Windows模板，然后在中间窗格中选择类库（便携式）。

在名称字段中输入 StringLibrary，然后单击“确定”以创建此项目。

字符串库

现在我们需要选择要引用的目标框架。让我们暂时选择 Windows Universal 和 ASP.NET Core，然后我们将重新定位它。单击“确定”。

重新定位

可以看到它已经创建了一个PCF格式的新项目。现在，我们在解决方案资源管理器中右键单击 StringLibrary 项目，然后选择“属性”。

特性

单击“目标 .NET 平台标准”。

目标

单击是；现在它是同一个类库，只有一点点不同。不同之处在于它也可以被 UWP 使用，因为它包含 *.csproj 文件而不是 *.xproj。

类库

现在让我们添加一个新类；为此，您需要在解决方案资源管理器中右键单击项目并选择添加 → 类...

添加新班级

在中间窗格中选择类，并在名称字段中输入StringLib.cs ，然后单击Add。添加类后，替换 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 项目）的引用一样。

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 (Portable)项目并选择Mange NuGet Packages...

便携的

在“浏览”选项卡上，您可以搜索任何 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

执行

现在可以看到 bin 文件夹中生成了 NuGet 包；让我们打开 bin\Debug 文件夹。

调试文件夹

现在的问题是NuGet包里面有什么，我们可以使用NuGet Package Explorer来查看。现在让我们打开 NuGet 包资源管理器。

打开 NuGet

选择第一个选项“打开本地包”。

第一个选项

选择StringLibrary.1.0.0.nupkg并单击Open。

单击“确定”

您可以看到，在“包内容”部分中，我们只有 StringLibrary.dll。在“包元数据”部分中，您将看到有关该库的一些信息，例如 ID、版本和所有依赖项。

现在让我们打开StringLibrary.1.0.0.symbols.nupkg。

符号

在此 NuGet 包中，您还将看到源文件和*.pdb文件。如果双击StringLib.cs文件，您也会看到源代码。

字符串库.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”命令。

.Net包

在 bin\Debug 文件夹中，您可以看到 StringLibrary NuGet 包是使用版本 1.0.1 生成的；让我们在 NuGet Package Explorer 中打开它。

版本

您将看到更新的元数据。现在的问题是，我们如何在另一个包中使用它。

我们需要首先在 NuGet feed 中的某个位置发布，然后我们可以在另一个项目中使用它。

有两个选项可以发布更新的元数据 -

  • 将其发布到 nuget.org
  • 将元数据推送到私有 NuGet 源

在这里，我们将使用私有 NuGet feed，因为它比在 nuget.org 上设置帐户要容易得多。要了解如何将包发布到 nuget.org，您可以遵循此处指定的所有准则