-NET-标准-2-0-秘籍-全-

.NET 标准 2.0 秘籍（全）

原文：zh.annas-archive.org/md5/4c555c436a572194e4929e640c176f78

译者：飞龙

协议：CC BY-NC-SA 4.0

前言

本书是构建 .NET Standard 2.0 库及其在各个 .NET 平台上使用的逐步指南。此外，我们将演示如何使用 ASP.NET、ASP.NET Core、ASP.NET MVC、Xamarin iOS 和 Xamarin Android 使用库。最后，我们将指导你如何使用 NuGet 包管理器打包和发送你的库。

本书面向的对象

这本书是为需要接触新 .NET Standard 2.0 库的开发者而写的。如果你对 C# 有基本的了解，以及库能对你的代码做什么，那么这足以理解这本书。此外，如果你是一位编写第三方库的开发者，这将给你一个关于 .NET Standard 2.0 库是什么以及如何使用它来满足 Windows、Linux 和 macOS 上的各种 .NET 平台的公平概念。

本书涵盖的内容

第一章，回到基础，为试图构建第一个基于 .NET 的类库的新手概述了所有开始的地方。它讨论了这种方法的局限性。本章通过一个简单的项目开始，并使用控制台应用程序和经典基于 Windows 的应用程序来使用它，讨论了当前库方法的局限性。它向读者介绍了 .NET Standard 2.0 及其版本。涵盖了如何创建第一个 .NET Standard 2.0 库以及如何使用它与各种 .NET 版本，如 .NET Framework 和 .NET Core 应用程序。

第二章，原始类型、集合、LINQ 等，探讨了 .NET Standard 2.0 的核心。它讨论了原始类型、集合、反射和 LINQ。涵盖了迄今为止支持的区域。它利用了不同版本的 .NET Framework 之间的功能。

第三章，与文件一起工作，解释了在 .NET Standard 2.0 中 System.IO 和 System.Security 的用法，以及使用文件系统进行读写操作的使用方法。它还介绍了在 Ubuntu 和 macOS 上的 .NET Core 的跨平台版本中的使用。

第四章，函数式编程，介绍了 C# 中的函数式编程功能以及如何在 .NET Standard 2.0 库中使用它们。

第五章，XML 和数据，解释了在 .NET Standard 2.0 中使用 System.XML 和 System.Data 创建 XML 文档以及使用数据表的用法。

第六章，探索多线程，讨论了创建多线程 .NET Standard 2.0 库的线程支持。这还包括在库中使用 C# 的异步功能（Tasks）。

第七章，网络，专注于 .NET Standard 2.0 中 System.Net 的用法。它深入探讨了套接字、Http 和邮件以及如何在 .NET Standard Library 2.0 中使用它们。

第八章，使用 Xamarin 迈向 iOS，概述了使用 Visual Studio for Mac 移动 iOS 工具创建一个简单的基于移动的应用程序。本章指导您创建一个.NET Standard 2.0 库，并将其与构建的 iOS 应用程序一起使用。

第九章，使用 Xamarin 迈向 Android，将指导您使用 Visual Studio for Mac 和 Android 工具创建一个简单的基于移动的应用程序。它展示了如何创建一个.NET Standard 2.0 库，并将其与构建的 Android 应用程序一起使用。

第十章，让我们微调我们的库，展示了如何使用调试工具和诊断工具微调.NET Standard 2.0 库。它还帮助您捕获异常，并确保最终用户在使用我们的.NET Standard Library 2.0 时拥有良好的体验。

第十一章，打包和交付，讨论了如何将完成的.NET Standard 2.0 库交付给世界。涵盖了如何使用 NuGet 包管理器、创建包以及交付的内容。

第十二章，部署，介绍了如何创建.NET Standard Library 2.0，将其与 ASP.NET Core Web 应用程序一起使用，并将其部署到 Azure 云。

为了充分利用本书

本书假设读者具备 C#的基本知识。此外，它还假设读者具备使用 Visual Studio、使用 NuGet 安装包以及在项目中引用其他项目中的库的基本知识。

基本了解如何在 Ubuntu 上使用 bash 和 macOS 中的终端等命令行工具将是一个额外的优势，但不是必须的。

下载示例代码文件

您可以从www.packtpub.com的账户下载本书的示例代码文件。如果您在其他地方购买了这本书，您可以访问www.packtpub.com/support并注册，以便将文件直接通过电子邮件发送给您。

您可以通过以下步骤下载代码文件：

1. 在www.packtpub.com上登录或注册。

2. 选择“支持”选项卡。

3. 点击“代码下载与勘误”。

4. 在搜索框中输入书籍名称，并遵循屏幕上的说明。

文件下载完成后，请确保使用最新版本解压缩或提取文件夹：

• Windows 上的 WinRAR/7-Zip

• Mac 上的 Zipeg/iZip/UnRarX

• Linux 上的 7-Zip/PeaZip

本书代码包也托管在 GitHub 上，网址为github.com/PacktPublishing/DotNET-Standard-2-Cookbook。我们还有其他丰富的图书和视频的代码包可供选择，网址为github.com/PacktPublishing/。请查看它们！

代码实战

访问以下链接查看代码运行的视频：

goo.gl/GwN5Xq

使用的约定

在本书中，使用了多种文本约定。

CodeInText：表示文本中的代码词汇、数据库表名、文件夹名、文件名、文件扩展名、路径名、虚拟 URL、用户输入和 Twitter 昵称。以下是一个示例：“将下载的WebStorm-10*.dmg磁盘映像文件作为系统中的另一个磁盘挂载。”

代码块按照以下方式设置：

public void WriteLog(string message)
{
logFile.WriteLine($"{DateTime.Now} Log Message: {message} ");
}

当我们希望您注意代码块中的特定部分时，相关的行或项目将以粗体显示：

if (!File.Exists(logFileName))
{
  logFile = File.CreateText(logFileName);
}
else
{
  logFile = File.AppendText(logFileName);
}

任何命令行输入或输出都按照以下方式编写：

$ dotnet build

粗体: 表示新术语、重要词汇或屏幕上看到的词汇。例如，菜单或对话框中的文字会以这种方式显示。以下是一个示例：“从管理面板中选择系统信息。”

警告或重要提示看起来像这样。

小贴士和技巧看起来像这样。

部分

在本书中，您将找到一些频繁出现的标题（准备工作、如何操作...、工作原理...、还有更多... 和 参见）。

为了清楚地说明如何完成食谱，请按照以下方式使用这些部分：

准备工作

本节告诉您在食谱中可以期待什么，并描述如何设置任何软件或任何为食谱所需的初步设置。

如何操作…

本节包含遵循食谱所需的步骤。

工作原理…

本节通常包含对上一节发生事件的详细解释。

还有更多…

本节包含有关食谱的附加信息，以便您对食谱有更深入的了解。

参见

本节提供了对食谱其他有用信息的链接。

联系我们

我们始终欢迎读者的反馈。

一般反馈：请将电子邮件发送至feedback@packtpub.com，并在邮件主题中提及书名。如果您对本书的任何方面有疑问，请通过电子邮件与我们联系questions@packtpub.com。

勘误表：尽管我们已经尽最大努力确保内容的准确性，但错误仍然可能发生。如果您在本书中发现错误，我们将不胜感激，如果您能向我们报告，我们将不胜感激。请访问www.packtpub.com/submit-errata，选择您的书籍，点击勘误表提交表单链接，并输入详细信息。

盗版：如果您在互联网上遇到我们作品的任何形式的非法副本，我们将不胜感激，如果您能提供位置地址或网站名称，我们将不胜感激。请通过电子邮件与我们联系copyright@packtpub.com，并提供材料的链接。

如果您想成为一名作者：如果您在某个领域有专业知识，并且对撰写或为本书做出贡献感兴趣，请访问authors.packtpub.com。

评论

请留下您的评价。一旦您阅读并使用了这本书，为何不在购买它的网站上留下评价呢？潜在读者可以查看并使用您的客观意见来做出购买决定，我们 Packt 可以了解您对我们产品的看法，而我们的作者也可以看到他们对书籍的反馈。谢谢！

如需了解 Packt 的更多信息，请访问 packtpub.com.

第一章：回归基础

在本章中，我们将涵盖以下食谱：

• 创建基于 C# 的控制台应用程序

• 创建 C# 类库

• 创建一个使用库的经典 Windows 应用程序

• 创建一个基于 WPF 的应用程序以使用库

• Hello Universe – 我第一个 .NET Standard 类库

• 创建一个基于 Windows 控制台的程序以使用库

• 创建一个基于 ASP.NET Core 的 Web 应用程序以使用库

技术要求

读者应具备 C# 的基本知识。他们还应了解如何使用 Visual Studio，使用 NuGet 安装包，以及在其他项目中引用项目中的库。

本章的代码文件可以在 GitHub 上找到：

github.com/PacktPublishing/DotNET-Standard-2-Cookbook/tree/master/Chapter01

查看以下视频以查看代码的实际效果：

goo.gl/PoR4HM

简介

Microsoft .NET 是一个支持多种编程语言的多用途开发平台，这是一个关键特性。其他关键特性包括异步和并发编程模型以及原生互操作性。.NET Framework 支持多种编程语言，如 C#、VB.NET 和 F#，这些语言由 Microsoft 活跃开发和支持。在这本书中，我们将探讨 C#。

C# 是一种现代的、面向对象的、类型安全的编程语言，它帮助开发者使用 .NET Framework 构建健壮、安全的应用程序。C# 在 2002 年随着 .NET Framework 1.0 一起推出。从那时起，C# 不断发展成熟。在撰写本文时，C# 的当前版本是 7.0，.NET 有多种风味可供使用，包括以下内容：

• .NET Framework：与 Windows 一起分发的 .NET 完整风味。由开发者用于在 Windows 下构建 ASP.NET 4.5/4.6 或桌面 Windows 应用程序。

• .NET Core：另一种在 Windows、Mac 和 Linux 下运行的 .NET 风味。由开发者用于构建跨平台的 .NET 基础应用程序，包括跨平台的 Web 应用程序，使用 ASP.NET Core。

• Xamarin：一个基于 mono 的框架，用于 iOS、Android 和 Windows Phone 设备的移动应用程序。此风味支持 macOS 桌面应用程序。

• .NET Standard：用于开发者之间在所有平台上共享代码的 Portable Class Libraries（PCL）的替代品，但在最新版本 2.0 中支持 API。此外，请注意，.NET Standard 2.0 在 .NET Core 2.0、.NET Framework 4.6.1 及更高版本以及 Visual Studio 2017（版本 15.3）中得到支持。

创建一个基于 C# 的控制台应用程序

让我们从简单的基于 C#的控制台应用程序开始。这个控制台应用程序将介绍一些基本的 C#代码，并为我们在下一道菜谱中要构建的库做好准备。我们的主要重点是进入 C#编码，并为我们将要经历的兴奋做好准备。

准备工作

要逐步执行此菜谱，您需要一个运行中的 Visual Studio 2017 副本以及.NET Framework 的最新版本。如果您没有 Visual Studio 2017 的副本，您可以从中下载www.visualstudio.com/。

这将带您到微软的 Visual Studio 网站。按照网站上的说明获取 Visual Studio 的副本并开始操作。

如何操作...

1. 打开 Visual Studio 2017。

2. 点击文件 | 新建 | 项目，然后在新建项目模板对话框中，在左侧面板中选择 Visual C#，在右侧面板中选择控制台应用程序 (.NET Framework)：

1. 在名称：文本框中，为您的应用程序输入一个名称。在本例中，输入HelloCSharp。在位置：下拉列表中选择一个首选位置或点击浏览...按钮选择一个位置。保留默认设置：

1. 现在点击确定。

2. 你将看到一个默认的 C#控制台应用程序代码模板。让我们按F5来测试运行。如果一切正常，一个控制台窗口将弹出并关闭。

3. 在Main方法的末尾，输入以下代码片段：

      private static string SayHello(string yourName)
      {
          return $"Hello, {yourName}";
      }

1. 现在，在您的Main方法中，输入调用我们刚刚创建的先前方法的代码：

      var message = SayHello("Fiqri Ismail");
      Console.WriteLine(message);
      Console.ReadLine();

1. 现在我们已经编写了我们的第一个 C#代码。完成编码后，控制台应用程序的代码应该看起来像以下这样：

      static void Main(string[] args)
      {
        var message = SayHello("Fiqri Ismail");
 Console.WriteLine(message);
 Console.ReadLine();
      }

      private static string SayHello(string yourName)
      {
        return $"Hello, {yourName}";
      }

1. 让我们按F5测试应用程序。如果一切正常，你应该会看到以下屏幕。按Enter键退出：

工作原理...

让我们快速回顾一下上一道菜谱中我们做了什么。在第 1 步到第 4 步中，我们创建了一个基于 C#的控制台应用程序。控制台应用程序的骨架已经作为模板包含在 Visual Studio 中。为您的项目命名并指定位置是一个好习惯。这些事情将帮助您轻松追踪项目以便将来使用。在第 5 步中，我们只是确保默认的控制台应用程序模板运行正常，并且在实际编码之前没有出现任何意外。

在第 6 步中，我们创建了一个接受string参数并返回带有该参数的消息的静态方法；这被称为字符串插值。这是 C# 6.0 中引入的新功能，可以用作传统string.format()方法的替代。第 7 步在主方法中使用该方法。在正常的控制台应用程序中，Console.ReadLine()将等待按下任何键后才退出。最后，在第 9 步中，我们调试代码以检查一切是否按预期正常工作。

相关内容

• C#基础知识  (第二章，原始类型、集合、LINQ 等)

• 使用 C#创建基于 Windows 的应用程序（创建一个经典基于 Windows 的应用程序以使用库——第一章，回到基础)

创建一个 C#类库

在这个菜谱中，我们将构建一个简单的 C#类库。这个库将有一个简单的公共方法，该方法接受一个参数并返回一个字符串。我们还将创建一个空白的 Visual Studio 解决方案并添加库项目。这个解决方案将在后面的菜谱中使用。

准备工作

确保你已经安装了 Visual Studio 2017 及其最新更新。在撰写本文时，最新的 Visual Studio 2017 版本是 15.3.5。

如何做...

1. 打开 Visual Studio 2017。

2. 点击“文件”|“新建”|“项目”，在“新建项目”模板对话框中，在左侧面板的“其他项目类型”节点下选择 Visual Studio 解决方案，在右侧面板中选择空白解决方案：

1. 在“名称：”文本框中，为你的应用程序输入一个名称。在这个例子中，输入Chapter1.Library。在“位置：”下拉列表中选择一个首选位置，或者点击“浏览...”按钮并选择一个位置。保留默认设置：

1. 现在你有一个空白解决方案。让我们向解决方案中添加一个 C#类库项目。点击“项目”|“添加新项...”，或者你可以在解决方案资源管理器中右键单击Chapter1.Library解决方案标签，然后选择“添加”|“新项目....”

2. 在“添加新项目”模板对话框中，在左侧面板中选择 Visual C#，在右侧面板中选择类库(.NET Framework)：

1. 在“名称：”文本框中，为你的类库输入一个名称。在这个例子中，将项目名称输入为Chapter1.Library.HelloLib。在“位置：”下拉列表中保留当前位置，然后点击“确定”以创建项目：

1. 现在我们有一个全新的基于.NET Framework 的类库。在解决方案资源管理器中（如果你看不到解决方案资源管理器，请按Ctrl + Alt + L），默认结构应该如下所示：

1. 现在我们有一个类库项目的默认模板。让我们将Class1.cs重命名为更有意义的东西。将其重命名为HelloWorld.cs。你可以在解决方案资源管理器中简单地点击文件的标签并输入新名称（或单击文件名标签并按F2）。在确认框中点击“是”以确认重命名。

2. 在HelloWorld类体中输入以下代码片段：

      public string SayHello(string name) 
      { 
          return $"Hello {name}, congratulations !!!, 
          this message is from the class library you created."; 
      }

1. 让我们构建我们的代码以检查一切是否正常。点击“生成”|“生成解决方案”，或者按Ctrl + Shift + B，解决方案应该成功构建。让我们在下一个菜谱中测试我们的类库。

2. 点击 文件 | 保存所有，或者按 Ctrl + Shift + S，以保存解决方案和类库项目。

它是如何工作的...

让我们看看在这个菜谱中我们已经做了什么以及它是如何工作的。在步骤 1 到 3 中，你创建了一个空白解决方案。空白解决方案是任何大小项目的非常好的起点。它为你提供了一个全新的解决方案来开始。稍后，你可以向解决方案中添加更多内容。尽管这是一个关于类库的简单介绍，但坚持使用正确的命名约定是一个好习惯。这不是必须的，但这是一个好习惯。正如你所看到的，我们给了一个名字 Chapter1.Library，所以这个名字是有意义的，它说明了我们的解决方案是关于什么的。

在接下来的步骤 4 到 8 中，我们向空白解决方案中添加了一个类库项目。现在你有一个关于解决方案如何随着时间的推移从开始到结束逐渐成长的概念。我们选择的模板是一个完整的 .NET Framework 类库。我们将 Visual Studio 提供的默认 Class1.cs 模板重命名了。给类和文件起一个有意义的名字是一个好习惯。

在步骤 9 和 10 中，我们向我们的类中添加了代码，并通过构建解决方案来检查所有语法是否正确。偶尔检查语法中的错别字和其他错误也是一个好习惯。

创建一个基于 Windows 的经典应用程序以使用库

到目前为止，从上一个菜谱中，我们已经创建了一个空白解决方案和一个使用完整 .NET Framework 的类库。在这个菜谱中，让我们创建一个经典的 Windows Forms 应用程序，它使用上一个菜谱中创建的类库。我们将构建一个 Windows 表单，它使用文本框和按钮获取一个名称，并触发我们在类库中创建的公共方法。

准备工作

对于这个菜谱，你需要前一个菜谱中构建的解决方案和类。打开 Visual Studio 2017 并为项目做准备。 点击 构建 | 构建解决方案，或者按 Ctrl + Shift + B，解决方案应该成功构建。一切准备就绪，可以测试我们的类库。

如何操作...

1. 打开 Visual Studio 2017。

2. 现在，打开上一个菜谱中的解决方案。点击 文件 | 打开 | 项目/解决方案，或者按 Ctrl + Shift + O，并选择 Chapter1.Library 解决方案。

3. 现在点击 Chapter1.Library 解决方案标签。点击 文件 | 添加 | 新项目...

4. 在 添加新项目模板对话框中，展开左侧窗格中的 Visual C# 节点。

5. 选择 Windows 经典桌面，并在右侧模板窗格中选择 Windows Forms App (.NET Framework)：

1. 现在，在 名称：文本框中，为新的项目输入一个名称。让我们输入 Chapter1.Library.HelloWindowsForms 并保持 位置：文本框不变以及默认设置。点击 确定 创建新项目。

1. 新项目将被添加到解决方案资源管理器中，它应该看起来像这样：

1. 现在让我们对名称进行一些清理。将Form1.cs更改为MainForm.cs。记住，给你的文件起一个有意义的名称非常重要，并且是一种非常好的实践。

2. 在“MainForm [设计]”选项卡中选择表单，并转到属性窗口（或按F4）。现在将文本属性更改为Hello World。

3. 让我们在窗体中添加一些 UI 组件。转到工具箱窗口（或按Ctrl + Alt + X），并将一个标签、一个文本框和一个按钮拖放到窗体上。按照以下截图进行排列：

1. 让我们更改刚刚添加到窗体上的组件的一些属性。转到属性窗口，并将默认值更改为以下内容：

组件	属性	值
标签	名称	NameLabel
标签	文本	输入您的姓名
文本框	名称	NameTextBox
按钮	名称	HelloButton
按钮	文本	问候

变更之后，Windows 窗体设计器应该看起来像这样：

1. 让我们将我们的库添加到 Windows 窗体项目中。为此，展开Chaper1.Library.HelloWindowsForms项目下的“引用”。右键单击“引用”标签，然后选择“添加引用……”。

2. 在“引用管理器”对话框中，点击左侧窗格中的“项目”标签。在中间窗格中，选中Chapter1.Library.HelloLib项目：

1. 点击“确定”。

2. 现在双击“问候”按钮以打开代码窗口。

3. 在代码窗口中，滚动到顶部并在using指令的最后一行之后输入以下代码：

      using Chapter1.Library.HelloLib;

1. 现在滚动到HelloButton_Click方法。在大括号之间，输入以下代码：

      var helloMessage = new HelloWorld();
      var yourName = NameTextBox.Text;
      MessageBox.Show(helloMessage.SayHello(yourName));

1. 现在是时候测试我们用之前菜谱中创建的类库构建的经典 Windows 应用程序了。按F5调试代码。现在你应该能看到创建的 Windows 窗体。

2. 在文本框中输入您的姓名，然后点击“问候”按钮。将出现一个消息框，显示来自类库的消息：

1. 恭喜！！！您刚刚使用了一个来自经典 Windows 应用程序的类库。

它是如何工作的...

如果你仔细看看我们刚刚完成的菜谱，我们使用了一个从之前的菜谱创建的解决方案。在实际应用中，这是一个日常过程。从步骤 1 到 7，我们打开了一个包含之前菜谱中类库的现有解决方案，并将经典 Windows 窗体应用程序添加到该解决方案中。

在步骤 8 到 11 中，我们准备了 Windows 表单项目。为组件和文件命名得当是良好的实践。即使这是一个小型应用程序，良好的命名也是一项良好的纪律。步骤 12 到 14 是本食谱中最重要的步骤。在这些步骤中，我们将我们的类库添加到 Windows 项目中作为引用。现在你可以从你的 Windows 应用程序中访问类库提供的所有公共方法。

在步骤 15 到 17 中，我们向 HelloButton 的按钮点击事件中添加了代码。双击组件将带你到 Windows 表单的 C# 代码。Visual Studio 将为你生成代码。在这种情况下，是按钮点击事件。组件的默认事件将根据你选择的组件而变化。在步骤 17 中，我们创建了一个变量来保存类库中 HelloWorld 类的实例。然后，我们创建另一个变量来保存文本框的用户输入。代码的最后一行将使用上一行代码中创建的变量提供的字符串参数调用 HelloWorld.SayHello(string name) 方法。最后，一个默认的消息框将显示 HelloWorld 类的 SayHello(string name) 方法返回的 string。

步骤 19 将执行默认项目，在本例中，我们的基于 Windows 的应用程序。有时，如果类库项目被选为默认项目，Visual Studio 将会抱怨你无法执行此类项目。所以请确保你已经选择了 Windows 项目作为默认启动项目。

创建一个基于 WPF 的应用程序以使用库

现在，在这个食谱中，让我们向解决方案添加一个基于 Windows Presentation Foundation (WPF) 的应用程序，并使用之前食谱中创建的类库。WPF 是 Windows Presentation Foundation 的缩写。本食谱的目的是演示如何在不同的 .NET 基于的应用程序之间共享库。

准备工作

对于这个食谱，你需要使用之前食谱中构建的解决方案和类库。打开 Visual Studio 2017 并准备项目。点击 Build | Build Solution，或者按 Ctrl + Shift + B，解决方案应该能够成功构建。一切准备就绪，可以测试我们的类库。

如何做这件事...

1. 打开 Visual Studio 2017。

2. 现在打开之前食谱中的解决方案。点击 File | Open | Open Project/Solution，或者按 Ctrl + Shift + O，并选择 Chapter1.Library 解决方案。

3. 现在点击 Chapter1.Library 解决方案标签。点击 File | Add | New Project。

4. 在“添加新项目”模板对话框中，展开左侧窗格中的 Visual C# 节点。

5. 选择 Windows Classic Desktop，并在右侧模板窗格中选择 WPF App (.NET Framework)。

1. 现在，在 名称：文本框中，为新项目输入一个名称。让我们输入 Chapter1.Library.HelloWPF 并保持 位置：不变以及默认设置。点击 确定 以创建新项目。

1. 现在，解决方案资源管理器（如果不可见，请按 Ctrl + Alt + L）应该看起来像这样：

1. 现在，点击 MainWindow.xaml 选项卡并确保您处于设计模式。

2. 现在，从工具箱（要查看工具箱，请按 Ctrl + Alt + X）拖放一个按钮和一个文本块。您可以在 公共 WPF 控件 下找到这些组件。

3. 主窗口应该看起来像这样：

1. 让我们命名我们的控件并更改一些属性如下：

   控件	属性	值
   文本块	名称	消息标签
   文本块	布局 | 宽度	498
   文本块	布局 | 高度	93
   文本块	文本 | 字体	粗体
   文本块	文本 | 字体	大小 14
   文本块	公共 | 文本	按按钮查看消息
   按钮	名称	HelloButton
   按钮	布局 | 宽度	276
   按钮	布局 | 高度	60
   按钮	公共 | 内容	说你好

2. 让我们将我们的类库作为引用添加到我们刚刚创建的 WPF 项目中。展开 Chapter1.Library.HelloWPF 项目节点，并在解决方案资源管理器中展开 引用 节点（如果您看不到解决方案资源管理器，请按 Ctrl + Alt + L）。

3. 右键单击 引用 标签并选择添加引用....。

4. 在 引用管理器 对话框中，在左侧窗格中单击 项目 标签。在中窗格中，选中 Chapter1.Library.HelloLib 项目：

1. 点击确定。

2. 在 MainWindow.xaml 选项卡中，双击 SayHello 按钮。

3. 在 MainWindow.xamal.cs 选项卡中，向上滚动直到看到 using 代码块。将此代码作为 using 代码块的最后一行添加：

      using Chapter1.Library.HelloLib;

1. 现在，向下滚动直到到达 HelloButton_Click 方法。在 HelloButton_Click 方法的括号中输入以下代码块：

      var yourName = "Fiqri Ismail";
      var helloMessage = new HelloWorld();

      MessageLabel.Text = helloMessage.SayHello(yourName);

1. 现在，我们准备测试。按 F5 调试我们的代码：

1. 点击 说你好 按钮以查看来自类库的消息：

1. 恭喜！！！您刚刚使用了一个用 WPF 应用程序创建的库。

它是如何工作的...

让我们看看这些片段以及它们是如何结合在一起的。从步骤 1 到 7，我们打开了一个现有解决方案并添加了一个 WPF 项目到该解决方案中。在步骤 8 到 10 中，我们从工具箱中添加了一个控件到 WPF 主窗体。由于这是一个 WPF 应用程序，我们通过一个额外的元素；设置 UI。在步骤 11 中，我们使用属性窗口设置了 UI 元素。

在步骤 12 到 15 中，我们添加了对 WPF 项目的引用。引用我们创建的库是最重要的部分。没有引用，WPF 项目对库一无所知。仅引用库后，它将可供 WPF 项目使用。步骤 17 告诉编译器使用库的命名空间。现在我们不需要在库内部调用类的完整命名空间。在步骤 18 中，我们创建了一个简单的变量并存储了一个名称。下一行在库内部创建了一个HelloWorld类的实例。最后，我们使用 WPF TextBlock 控制的 Text 属性来存储从SayHello(string name)方法中获取的值。

在最后几步 – 19 到 20 中，我们执行了代码并进行了测试。

Hello Universe – 我的第一个.NET Standard 类库

现在是时候继续前进，看看 Microsoft .NET Standard 了。在这个菜谱中，我们将查看.NET Standard 库的 2.0 版本。一开始，我们将构建一个小型的.NET Standard 类库，并使用它与不同的.NET 应用程序。

准备工作

让我们确保我们已经下载并安装了 Visual Studio 2017 的一个版本。如果您在 Windows 上运行，您可以选择 Visual Studio 2017 社区版、专业版或企业版。如果您在 mac 上运行，您可以选择 Visual Studio 2017 for macOS。此外，Visual Studio Code 适用于所有 Windows、Mac 和 Linux 平台。访问www.visualstudio.com并按照说明下载您选择的 Visual Studio。

在下一步中，我们将需要下载并安装.NET Core 2.0。再次提醒，只需访问www.dot.net/core并下载最新版本，在这种情况下，是.NET Core 的 2.0 版本。该网站提供了一套非常简单且信息丰富的说明，指导如何在您的系统上安装.NET Core 2.0。

如何操作...

1. 打开 Visual Studio 2017。

2. 点击文件 | 新建 | 项目。

3. 现在，在新项目对话框中，展开左侧窗格中的 Visual C#节点，并选择.NET Standard 类库，在右侧窗格中，选择.NET Standard 类库：

1. 在名称：文本框中，为您的类库输入一个名称。让我们输入Chapter1.StandardLib.HelloUniverse，并在位置：下拉列表中选择一个首选位置，或者点击浏览...按钮并选择一个位置。保留默认设置。最后，在解决方案名称：文本框中，输入Chapter1.StandardLib。

1. 点击确定。

2. 在解决方案资源管理器（按Ctrl + Alt + L），点击 Class1.cs，按F2，将其重命名为HelloUniverse.cs。通过在确认框中选择是来确认重命名。

3. 将命名空间从Chapter1.StandardLib.HelloUniverse更改为Chapter1.StandardLib。

4. 现在，在HelloUniverse类的花括号内，输入以下代码：

      public string SayHello(string name)
      {
          return $"Hello {name}, 
          welcome to a whole new Universe of .NET Standard 2.0";
      }

1. 按Ctrl + S保存更改，然后按Ctrl + Shift + B构建代码。如果构建没有错误完成，我们就可以进行下一个菜谱，了解如何使用这个类库。

它是如何工作的...

.NET Standard 2.0 是其最新版本。.NET Standard 完全是关于代码共享的。与.NET Framework 类库不同，.NET Standard 类库代码几乎可以在.NET 生态系统的所有部分共享。.NET Standard 的最新版本是 2.0。在撰写本文时，它可以与.NET Framework 4.6.1、.NET Core 2.0、Mono 5.4、Xamarin.iOS 10.14、Xamarin.Mac 3.8、Xamarin.Android 7.5 以及即将推出的通用 Windows 平台（UWP）版本共享。它还取代了可移植类库（PCLs），作为构建在所有地方都能工作的.NET 库的工具。

在步骤 1 到 5 中，我们创建了一个基于.NET Standard 2.0 的新类库项目。在步骤 4 中，我们为类库以及解决方案给出了合适的名称。给项目和解决方案起一个有意义的名称是良好的实践。在步骤 6 中，我们将默认类的名称更改为HelloUniverse.cs，这要归功于 Visual Studio 中的重构功能。如果你查看.NET Standard 2.0 库模板的布局，你会看到一个依赖项节点。在一个正常的.NET Framework 类库中，我们有引用。依赖项节点将列出该类库的所有依赖组件。

在步骤 8 中，我们添加了一个简单的公共方法，该方法接受一个字符串参数，并返回一个包含发送到方法中的参数的消息。最后，我们通过构建解决方案来检查语法错误和拼写错误。

创建一个基于 Windows 控制台的应用程序以使用库

在上一个菜谱中，我们创建了一个基于.NET Standard 2.0 的类库。在这个菜谱中，我们将创建一个基于 Windows 控制台的应用程序来使用这个库。基于控制台的应用程序将在 Windows 下使用完整的.NET Framework，当前.NET Framework 的版本是 4.6.1。

准备工作

让我们准备好创建一个 Windows 控制台应用程序，以使用我们在上一个菜谱中构建的.NET Standard 库。如果你没有遵循上一个菜谱，请确保你已经完成了它。我们将使用那个解决方案并向其中添加 Windows 控制台应用程序。打开 Visual Studio 2017，打开上一个菜谱中保存的解决方案。点击“构建”|“构建解决方案”，或者按Ctrl + Shift + B，解决方案应该能够成功构建。一切准备就绪，可以测试我们的类库。

如何操作...

1. 打开 Visual Studio 2017。

2. 现在，打开上一个菜谱中的解决方案。点击“文件”|“打开”|“打开项目/解决方案”，或者按Ctrl + Shift + O，然后选择Chapter1.StandardLib解决方案。

3. 现在，点击Chapter1.Library解决方案标签。点击“文件”|“添加”|“新建项目”。

4. 在“添加新项目”模板对话框中，展开左侧窗格中的 Visual C#节点。从右侧窗格中选择 Windows 经典桌面，并选择控制台应用程序(.NET Framework)。

1. 现在，在“名称：”文本框中，输入Chapter1.Standard.HelloConsole，并将“位置：”文本框保持原样。

1. 点击确定。

2. 现在，解决方案资源管理器（如果未显示，请按Ctrl + Alt + L）应该看起来像这样：

1. 在Chapter1.StandardLib.HelloConsole项目树中，右键单击“引用”标签并选择添加引用...

2. 在“引用管理器”对话框中，点击左侧窗格中的“项目”标签。在中间窗格中，选中Chapter1.StandardLib.HelloUniverse项目。

1. 点击确定。

2. 在解决方案资源管理器中，双击Chapter1.StandardLib.HelloConsole项目下的Program.cs文件名。

3. 滚动至代码中的using指令部分，并将以下代码作为该部分的最后一行添加：

      using Chapter1.StandardLib;

1. 现在，在Main()方法的括号内，输入以下代码：

      var myName = "Fiqri Ismail";
      var helloMessage = new HelloUniverse();
      Console.WriteLine(helloMessage.SayHello(myName));
      Console.ReadLine();

1. 按F5并查看代码运行：

1. 按Enter退出命令提示符。

它是如何工作的...

好的，让我们深入了解我们刚刚完成的工作。从步骤 1 到 7，我们打开了一个现有项目并添加了一个新的 Windows 控制台应用程序。该项目是一个完整的.NET Framework 项目，其版本为.NET Framework 版本 4.6.1。在步骤 9 和 10 中，我们从 Windows 控制台应用程序添加了对.NET Standard 类库项目的引用。这是测试类库所必需的。然后，我们可以从应用程序中引用并使用它，就像我们在步骤 12 中所做的那样。

在步骤 13 中，我们创建了一个变量来存储名称（请注意，硬编码不是一种好习惯）。然后，我们创建了.NET Standard 2.0 类库中创建的HelloUniverse类的实例。为了将SayHello()方法的输出显示到控制台窗口，我们直接使用了Console.WriteLine()方法。最后，我们使用Console.ReadLine()方法等待用户按下键退出控制台，否则最终用户将无法在控制台看到任何输出。

创建一个基于 ASP.NET Core 的 Web 应用程序以使用库

到目前为止，我们已经使用运行在完整.NET Framework 版本 4.6.1 下的 Windows 控制台应用程序测试了.NET Standard 2.0 类库。在这个菜谱中，我们将创建一个 ASP.NET Core 2.0 应用程序。ASP.NET Core 使用.NET Core，这是一个开源的、跨平台支持的.NET 版本。

准备工作

让我们准备创建 ASP.NET Core 应用程序，以便在我们创建.NET Standard 库时使用前一个菜谱中构建的.NET Standard 库。如果您没有遵循那个菜谱，请确保您已经完成了它。我们将使用那个解决方案，并将 ASP.NET Core 应用程序添加到其中。同时，请确保您已下载并安装了最新版本的.NET Core 框架，该框架可在www.dot.net/core找到。

打开 Visual Studio 2017，并打开前一个菜谱中保存的解决方案。点击“生成”|“生成解决方案”，或者按Ctrl + Shift + B，解决方案应该会成功构建。一切准备就绪，可以测试我们的类库。

如何操作...

1. 打开 Visual Studio 2017。

2. 现在，打开前一个菜谱中的解决方案。点击“文件”|“打开”|“打开项目/解决方案”，或者按Ctrl + Shift + O，然后选择Chapter1.StandardLib解决方案。

3. 现在，点击Chapter1.Library解决方案标签。点击“文件”|“添加”|“新项目”。

4. 在“添加新项目”模板对话框中，展开左侧窗格中的 Visual C#节点。从右侧窗格中选择 Web，然后选择 ASP.NET Core Web 应用程序：

1. 在“名称”文本框中，将项目名称输入为Chapter1.StandardLib.AspNetCore，并保持“位置”不变：

1. 点击确定。

2. 现在，在“新建 ASP.NET Core Web 应用程序”对话框中，从第一个下拉列表中选择.NET Core，从第二个下拉列表中选择 ASP.NET Core 2.0。最后，从模板列表中选择 Web 应用程序（模型-视图-控制器）：

1. 保持默认设置并点击确定。

2. 现在，解决方案资源管理器应该看起来像这样：

1. 选择Chapter1.StandardLib.AspNetCore项目，右键单击，并选择设置为启动项目。

2. 现在，按F5进行测试运行。如果一切运行顺利，你应该会在默认浏览器中看到这个默认的 ASP.NET Core 模板正在运行：

默认 ASP.NET Core 模板在您的默认浏览器上运行

1. 让我们关闭浏览器，并将我们的.NET Standard 类库作为引用添加。为此，展开Chapter1.StandardLib.AspNetCore项目树并选择依赖项。

2. 右键单击依赖项标签，并选择添加引用。

3. 在“参考管理器”对话框中，点击左侧窗格中的“项目”标签。在中间窗格中，选中Chapter1.StandardLib.HelloUniverse项目，然后点击确定。

1. 让我们展开“控制器”文件夹，并双击HomeController.cs。

2. 在HomeController.cs中，在using指令块的最后一行旁边添加以下代码：

      using Chapter1.StandardLib;

1. 现在，在 About() 动作中，在 ViewData["Message"] 行之后（默认情况下，这是默认模板的第 21 行）添加以下代码块：

      var myName = "Fiqri Ismail"; 
      var helloMessage = new HelloUniverse();
      ViewData["HelloMessage"] = helloMessage.SayHello(myName);

1. 现在展开 Views 文件夹。同样，也展开 Home 文件夹。

2. 双击 About.cshtml。

3. 在 About.cshtml 文件的末尾，添加以下代码：

      <p>@ViewData["HelloMessage"]</p>

1. 现在按 F5 键来查看其效果。

2. 你将在浏览器中看到默认的 ASP.NET Core 模板。现在点击 About 来查看 About.cshtml 页面：

About.cshtml 页面

1. 太棒了，现在你已经使用了一个 .NET Standard 2.0 库和一个 ASP.NET Core 2.0 网络应用程序。

它是如何工作的...

让我们看看我们刚才做了什么。从第 1 步到第 9 步，我们打开并构建了一个包含 .NET Standard 2.0 库代码的现有解决方案。然后，我们将一个 ASP.NET Core 项目添加到该解决方案中。在第 10 步中，我们告诉 Visual Studio 在我们按 F5 或开始调试时执行 ASP.NET Core 项目。在第 11 步中，我们在默认浏览器中测试了 ASP.NET Core 的默认模板。

在第 12 步到第 14 步中，我们将我们的 ASP.NET Core 应用程序的引用添加到了 .NET Standard 2.0 类库中。这允许您从 ASP.NET Core 2.0 网络应用程序中访问库。在第 16 步中，我们使用 using 指令引用了类库。在第 17 步中，我们创建了一个变量来保存名称并创建了 HelloUniverse 类的一个实例。

最后，我们已经将 SayHello() 方法中的消息存储在 ViewData 集合中。ViewData 集合允许您将数据从控制器传输到视图。在第 19 步和第 20 步中，我们打开了 About() 动作的相关视图，即 About.cshtml。最后，在第 20 步中，我们在 HomeController 类中添加了简单的 HTML 代码来显示存储在 ViewData 中的值。作为最后一步，我们执行了网络应用程序并进行了测试。

第二章：原始数据类型、集合、LINQ 以及更多

在本章中，我们将介绍以下内容：

• 构建一个使用原始数据类型的.NET Standard 2.0 库

• 构建一个用于使用库的.NET 控制台应用程序

• 创建集合

• 构建一个用于使用库的 WPF 应用程序

• 使用反射描述我们的库

• 构建一个用于使用库的.NET Core 控制台应用程序

• 构建一个使用 LINQ 的.NET Standard 2.0 库

• 构建一个用于使用库的 ASP.NET MVC 应用程序

技术要求

读者应该具备基本的 C#知识。他们还应该了解如何使用 Visual Studio，使用 NuGet 安装包，以及在其他项目中引用项目中的库。

本章的代码文件可以在 GitHub 上找到：

github.com/PacktPublishing/DotNET-Standard-2-Cookbook/tree/master/Chapter02

查看以下视频以查看代码的实际操作：

goo.gl/BiXiAM

简介

当您将 C#视为一种语言时，有一些事情我们需要首先考虑：C#能做什么，它如何支持我们的日常编程需求，以及它如何帮助我们解决问题。在本章中，我们将主要探讨 C#支持的原始数据类型、集合和 LINQ 功能。在完整的.NET Framework 中，使用这些功能没有问题，但当涉及到跨平台和.NET Framework 不同版本之间的代码共享时，它确实成为一个问题。

每个菜谱都将通过构建.NET Standard 2.0 库以及如何使用它来介绍如何与使用.NET Framework 版本的程序一起使用。

构建一个使用原始数据类型的.NET Standard 2.0 库

在这个菜谱中，我们将探讨 C#原始数据类型及其在.NET Standard 2.0 库中的使用。原始数据类型是框架的核心部分之一。这些类型是在.NET Framework 本身中定义的，而不是在 C#语言规范中定义的。

我们将构建一个使用.NET Framework 中的原始数据类型的.NET Standard 2.0 库，并在下一个菜谱中使用它。

准备工作

如前所述，原始数据类型是在.NET Framework 本身中定义的，并且不是特定于语言的。这意味着您可以在.NET Framework 支持的所有语言中使用这些数据类型。这并不意味着您可以在不同版本的.NET Framework 中使用这些原始数据类型。例如，如果一个数据类型是在.NET Framework 版本 4.6.1 中定义的，而在.NET Core 2.0 中没有定义，那么您的代码将在.NET Core 2.0 中失败。

此外，请确保您拥有最新的 Visual Studio 版本，即写作时的 2017 版本。

如何操作...

1. 打开 Visual Studio 2017。

2. 点击“文件”|“新建”|“项目”，然后在“新建项目模板”对话框中，在左侧窗格的“其他项目类型”节点下选择“Visual Studio 解决方案”，然后在右侧窗格中选择“空白解决方案”。

3. 在“名称”文本框中，输入Chapter2.Primitives作为解决方案的名称。在“位置”下拉列表中选择一个首选位置，或点击“浏览...”按钮选择一个位置。保留默认设置。

1. 点击“确定”。

2. 现在，在解决方案资源管理器中（或按Ctrl + Alt + L），选择 Chapter2.Primitives。右键单击，选择“添加”|“新建项目”。

3. 在“添加新项目”对话框中，展开“Visual C#”节点，在左侧窗格中选择.NET Standard。

4. 在右侧窗格中，选择类库(.NET Standard)：

1. 现在，在“名称”文本框中，输入Chapter2.Primitives.PrimitiveLib，并将“位置”文本框保留为默认设置：

1. 点击“确定”。

2. 现在，解决方案资源管理器应该看起来像这样：

1. 点击Class1.cs并按F2重命名它。输入Helpers.cs作为新名称。

2. 在重命名确认对话框中，选择“是”。

3. 现在，双击Helpers.cs以打开其代码窗口。

4. 在Helpers类的花括号之间输入以下代码：

      public char WhatIsMyGrade(int yourMarks)
      {
          var grade = 'F';
          if (yourMarks >= 85)
              grade = 'A';
          else if (yourMarks >= 65)
               grade = 'B';
          else if (yourMarks >= 55)
               grade = 'C';
          else if (yourMarks >= 35)
               grade = 'S';

          return grade;
      }

1. 按Ctrl + Shift + B构建您的代码。

2. 再次，在步骤 14 的结束花括号旁边输入以下代码：

      public double CmToInches(double cm)
      {
          var oneCmToInches = 0.393700787;

          return oneCmToInches * cm; 
      }

1. 让我们构建代码以检查一切是否正常。点击“生成”|“生成解决方案”或按Ctrl + Shift + B，解决方案应该能够成功构建。让我们在下一个菜谱中测试我们的类库。

2. 点击“文件”|“全部保存”，或者按Ctrl + Shift + S，以保存解决方案和类库项目。

它是如何工作的...

让我们看看到目前为止我们取得了什么成果。从步骤 1 到 4，我们打开了 Visual Studio 2017 并创建了一个空白解决方案。空白解决方案是具有多个项目的项目的良好基础。在步骤 5 到 10 中，我们在空白解决方案中添加了一个新项目。在第 7 步中，我们使用了一个现有的基础.NET Standard 2.0 项目模板，并在第 8 步中给它起了适当的名字。

在第 11 步和第 12 步中，我们将默认的Class1.cs更改为有意义的名称。这些名称非常重要，它有助于开发者理解文件内部的代码用途。在这种情况下，我们选择了Chapter2.Primitives.PrimitiveLib作为项目名称。前两部分提供了解决方案名称，最后是实际的项目名称。

在第 14 步中，我们创建了包含公共方法的代码。该方法接受一个int类型的变量作为参数。int是框架本身支持的原始数据类型，因此我们在.NET Standard 库中使用它。这意味着代码可以在.NET Framework、.NET Core 和 Mono 运行的应用程序之间共享。

数据类型int是System.Int32的别名，这些是在.NET 下支持的原始类型，可以在.NET Standard 2.0 库中使用和共享：

• Boolean

• Byte

• SByte

• Int16

• UInt16

• Int32

• UInt32

• Int64

• UInt64

• IntPtr

• UIntPtr

• Char

• Double

• Single

代码接受一个 char 变量，每个 if 语句验证通过方法中的 yourMarks 参数发送的分数。最后，方法返回一个 char 值作为成绩，然后我们确认所有语法都是正确的，并在步骤 15 中成功构建。在步骤 16 中，我们创建了另一个方法，将厘米转换为英寸。输入参数是另一个原始类型 double，它也是 System.Double 的别名。这是因为 C# 将所有原始类型表示为对象。在代码内部，一个变量已经将厘米转换为英寸，并存储为 oneCmToInches。在最后一行，我们返回英寸作为 double，这是从方法参数中给出的厘米转换而来的。

在步骤 17 中，我们进行了另一个构建以检查所有代码的语法，并最终保存了所有内容。

一个用于使用库的 .NET 控制台应用程序

在本菜谱中，我们将做两件事。首先，我们将打开 Visual Studio 并对之前构建的 .NET Standard 2.0 库的解决方案进行快速构建。最后，我们将添加一个 .NET 控制台应用程序来使用这个库。这个控制台应用程序将在 Windows 下使用 .NET Framework 4.6.1 作为基础框架。

准备工作

确保你已经完成了上一个菜谱中构建的 .NET Standard 2.0 库。我们将在本菜谱中使用它。打开 Visual Studio 2017 并准备项目。点击 构建 | 构建解决方案，或者按 Ctrl + Shift + B，解决方案应该能够成功构建。一切准备就绪，可以测试我们的类库。

如何操作...

1. 打开 Visual Studio 2017。

2. 现在打开上一个菜谱中的解决方案。点击 文件 | 打开 | 打开项目/解决方案，或者按 Ctrl + Shift + O，然后选择 Chapter2.Primitives 解决方案。

3. 现在，点击 Chapter2.Library 解决方案标签。点击 文件 | 添加 | 新建项目。

4. 在 添加新项目 模板对话框中，展开左侧面板中的 Visual C# 节点。

5. 在右侧面板中选择 Windows Classic Desktop，然后选择 控制台应用程序 (.NET Framework)：

1. 现在，在名称：文本框中，键入 Chapter2.Primitives.PrimitivesConsole，并保持位置：文本框不变。

1. 点击确定。

2. 添加新项目后，解决方案资源管理器 (Ctrl + Alt + L) 应该看起来像这样：

1. 在 Chapter2.Primitives.PrimitivesConsole 项目节点中点击引用标签。右键单击并选择添加 | 添加引用。

2. 在参考管理器中，在左侧面板中选择项目，然后在右侧面板中检查 Chapter2.Primitives.PrimitiveLib：

1. 点击确定以将引用添加到所选项目。

2. 现在，在新增的控制台应用程序项目中，双击 Program.cs 打开代码窗口。

3. 向上滚动并添加以下 using 指令：

      using Chapter2.Primitives.PrimitiveLib;

1. 现在，向下滚动，在 Main() 方法的花括号之间，输入以下代码：

      var myHelper = new Helpers();
      var myGrade = myHelper.WhatIsMyGrade(65);
      Console.WriteLine($"You are current grade is {myGrade}");

      Console.ReadLine();

1. 现在，按 F5 键进行代码调试。

2. 你应该看到如下输出：

1. 现在，按任意键退出控制台，点击在 Console.ReadLine() 行之前，按 Enter 键添加一些新的代码。

2. 让我们现在输入以下代码：

      var cm = 15;
      var inches = myHelper.CmToInches(cm);
      Console.WriteLine($"{cm} centimeters in inches are {inches}");

1. 按 F5 键查看输出，你应该会看到以下内容：

1. 现在我们已经成功测试了库，更改一些值并查看它是如何工作的。

它是如何工作的...

在第 1 步到第 7 步中，我们打开了一个现有的 Visual Studio 解决方案，并向其中添加了一个新项目。新添加的项目是基于 .NET 的控制台应用程序。在第 9 步到第 11 步中，我们添加了对 .NET Standard 2.0 库项目的引用。这是一个重要的步骤。为了使用库中的功能，你必须将项目作为引用添加。

在第 13 步，我们添加了代码来使用库的第一个方法。代码的第一行将定义一个变量来持有 Helpers() 类的实例。var 关键字帮助你创建一个局部变量，而不需要给出显式的类型。它只是告诉编译器从初始化语句右侧的表达式中获取变量的类型。例如，请看以下内容：

var myInteger = 10;

这与以下内容相同：

int myInteger = 10; 

代码的第二行保存了 WhatIsMyGrade() 方法的返回值。下一行将输出显示到控制台窗口。最后一行将告诉控制台等待按键。在第 14 步和第 15 步中，我们看到了我们编写的代码的输出。

在第 17 步，我们正在测试我们创建的 .NET Standard 2.0 库中 Helpers() 类内的第二个方法。在第一行，我们创建了一个变量来存储需要转换的默认值。在第二行，它将转换后的输出存储在一个变量中。同样，我们使用了 var 关键字来存储变量，这将自动存储从方法返回的类型值，在本例中是 System.Double 类型。第三行将在控制台窗口中显示输出。在第 18 步和第 19 步中，我们执行了控制台应用程序。

创建集合

在 .NET Framework 中支持三种类型的集合。在这个菜谱中，我们将专注于在 .NET Standard 2.0 库中使用这些集合。一般来说，集合用于管理相关对象的组。创建对象的数组是分组相关对象的一种方式。但我们的重点是使用这些集合，这是分组相关对象的第二种方法。

准备工作

这是我们在 .NET Framework 中拥有的三种类型的集合：

• System.Collections.Generic 类

• System.Collections.Concurrent 类

• System.Collections 类

让我们来看看这些以及它们在 .NET Standard 2.0 库中的使用。

如何操作...

1. 打开 Visual Studio 2017。

2. 点击 文件 | 新建 | 项目，然后在新建项目模板对话框中，在左侧窗格的 其他项目类型 节点下选择 Visual Studio 解决方案，然后在右侧窗格中选择 空白解决方案。

3. 在 名称：文本框中，输入 Chapter2.Collections 作为解决方案的名称。在 位置：下拉列表中选择一个首选位置或点击 浏览... 按钮选择一个位置。保留默认设置不变：

1. 点击确定。

2. 现在，在解决方案资源管理器（或按 Ctrl + Alt + L），选择 Chapter2.Collections。右键单击并选择 添加 | 新建项目。

3. 在添加新项目对话框中，展开 Visual C# 节点并在左侧窗格中选择 .NET Standard。

4. 在右侧窗格中选择 类库 (.NET Standard)：

1. 现在，在 名称：文本框中输入 Chapter2.Collections.CollectionsLib 并保留 位置：文本框不变：

1. 点击确定。

2. 现在，解决方案资源管理器应该看起来像这样：

1. 点击 Class1.cs 并按 F2 重命名它。输入新名称为 LittleShop.cs。

2. 在确认对话框中选择是进行重命名。

3. 现在双击 LittleShop.cs 以打开其代码窗口。

4. 在代码窗口顶部，将光标（或点击鼠标）移动到 using 指令的最后一行并添加以下 using 指令：

      using System.Collections.Generic;

1. 在 LittleShop 类的花括号之间输入以下代码：

      public List<string> GetFruitsList()
      {
          var fruitsList = new List<string>();

          fruitsList.Add("Apples");
          fruitsList.Add("Grapes");
          fruitsList.Add("Mangoes");
          fruitsList.Add("Oranges");
          fruitsList.Add("Pineapples");

          return fruitsList;
       }

1. 按下 Ctrl + Shift + B 进行快速构建并检查任何语法错误。

2. 现在在代码窗口顶部的 using 指令末尾输入以下代码：

      using System.Collections;

1. 在 GetFruitsList() 方法的末尾添加以下代码：

      public ArrayList GetShopItems()
      {
          var shopItems = new ArrayList();
          shopItems.Add("Fruits");
          shopItems.Add("Vegetables");
          shopItems.Add("Chocolates");

          return shopItems;
       }

1. 快速按一下 Ctrl + B 进行调试并检查语法错误。

2. 现在我们已经准备好测试库了。

工作原理...

让我们看看幕后发生了什么。从步骤 1 到 4，我们创建了项目的基。这个基将帮助您创建 .NET Standard 2.0 库以及将使用该库的项目。空白解决方案始终是任何类型项目的良好起点。在步骤 5 到 10 中，我们将 .NET Standard 2.0 库项目添加到空白解决方案，并给它一个有意义的名称。在步骤 11 到 13 中，我们将默认类模板名称更改为有意义的名称。

在第 14 步中，我们创建了对 System.Collections.Generics 命名空间的引用。这将使您能够访问此命名空间下所有可用的集合。在第 15 步中，我们使用了一个名为 List<T> 的泛型集合对象。在接下来的几行中，我们将一些字符串对象添加到创建的变量中。最后，我们返回了列表集合，它与 GetFruitsList() 方法的返回类型相同。然后，在第 16 步中，我们进行了快速构建，这将帮助我们检查代码的语法。进行快速构建以检查语法是一个好的做法。

再次，在第 17 步中，我们向 System.Collections 命名空间添加了另一个引用。然后，在第 18 步中，我们添加了一个返回 ArrayList() 的 public 方法，它包含在 System.Collections 命名空间中。在 GetShopItems() 方法的第一行中，我们创建了一个 ArrayList() 对象的实例，在接下来的几行中，我们使用其 Add() 方法向 ArrayList() 添加了一个字符串对象。最后，在最后一行，我们返回存储在变量中的数组列表。然后，在第 19 步中，我们进行了快速构建，这将帮助我们检查代码的语法。进行快速构建以检查语法是一个好的做法。

最后一种类型是 System.Collections.Concurrent 命名空间。此命名空间包含线程安全的集合。这意味着多个线程可以安全地向这些集合添加或从这些集合中删除项目。

一个用于使用库的 WPF 应用程序

在本菜谱中，我们将创建一个用于使用我们在上一个菜谱中创建的 .NET Standard 2.0 库的 Windows Presentation Foundation 应用程序。我们将从之前创建的解决方案继续构建应用程序。Windows Presentation Foundation 是一个在 .NET Framework 下工作并在 Windows OS 中运行的 UI 框架。

准备工作

打开 Visual Studio 2017 并为项目做准备。确保你已经完成了在预览构建中构建 .NET Standard 2.0 库。如果该项目尚未打开，请打开它，然后点击 构建 | 构建解决方案，或按 Ctrl + Shift + B，解决方案应该能够成功构建。一切准备就绪，可以测试我们的类库。

如何操作...

1. 打开 Visual Studio 2017。

2. 现在打开之前菜谱中创建的解决方案。点击 文件 | 打开 | 打开项目/解决方案，或按 Ctrl + Shift + O，并选择 Chapter2.Collections 解决方案。

3. 现在，点击 Chapter2.Collections 解决方案标签。点击 文件 | 添加 | 新建项目。

4. 在 添加新项目 模板对话框中，展开左侧窗格中的 Visual C# 节点。

5. 在右侧窗格中选择 Windows Classic Desktop 然后选择 WPF App (.NET Framework)：

1. 在“名称：”文本框中，输入Chapter2.Collections.WPFLittleShop作为项目的名称，并保持“位置：”文本框不变：

1. 点击确定。

2. 现在，解决方案资源管理器（按 Ctrl + Alt + L 打开）应该看起来像这样：

1. 现在，双击MainWindow.xaml以打开设计视图。

2. 通过按Ctrl + Alt + X打开工具箱，并将两个按钮和两个列表框拖放到主窗口中。

3. 将它们放置如下：

1. 现在，打开属性窗口，或按F4，并更改以下属性：

   控制器	属性	值
   按钮（从左数第一个）	名称	FruitsButton
   按钮（从左数第一个）	内容	Get Fruits
   按钮（从左数第二个）	名称	ItemsButton
   按钮（从左数第二个）	内容	Get Items
   列表框（从左数第一个）	名称	FruitsList
   列表框（从左数第二个）	名称	ItemsList

2. 应用了之前的属性后，MainWindow应该看起来像这样：

1. 现在，在解决方案资源管理器中（或按Ctrl + Alt + L），展开Chapter2.Collections.WPFLittleShop项目树。

2. 右键单击“引用”标签并选择“添加引用”。

3. 在引用管理器对话框中，展开左侧窗格中的“项目”节点。

4. 点击“解决方案”。

5. 现在，在右侧窗格中检查Chapter2.Collections.CollectionsLib：

1. 点击“确定”。

2. 双击“获取水果”按钮。

3. 你将看到FruitsButton_Click()方法。

4. 向上滚动代码窗口，并在所有using指令的末尾添加以下using指令：

      using Chapter2.Collections.CollectionsLib;

1. 再次向下滚动，并在FruitsButton_Click()方法中编写以下代码：

      var littleShop = new LittleShop();
      var fruits = littleShop.GetFruitsList();

      foreach (var fruit in fruits)
      {
          FruitsList.Items.Add(fruit);
      }

      FruitsList.Items.Add("--------");
      FruitsList.Items.Add($"Item Count: {fruits.Count}");
      FruitsList.Items.Add($"Capacity: {fruits.Capacity}");

1. 通过点击其标签或直接在解决方案资源管理器中双击MainWindow.xaml标签来切换回MainWindow.xaml的设计视图。

2. 选择“获取项目”按钮并双击它。

3. 现在，在ItemsButton_Click()事件方法中输入以下代码：

      var littleShop = new LittleShop();
      var items = littleShop.GetShopItems();

      for (int i=0; i<items.Count; i++)
      {
          ItemsList.Items.Add(items[i]);
      }

      ItemsList.Items.Add("--------");
      ItemsList.Items.Add($"Item Count: {items.Count}");
      ItemsList.Items.Add($"Capacity: {items.Capacity}");

1. 让我们按F5来调试代码。

2. 点击“获取水果”和“获取项目”按钮。

3. 你应该看到如下输出：

它是如何工作的...

现在，我们有一个使用.NET Standard 2.0 库作为其源的工作 WPF 应用程序。让我们看看我们遵循的步骤。在步骤 1 到 7 中，我们打开了之前构建的.NET Standard 2.0 库项目和解题方案。之后，我们将一个 Windows Presentation Foundation 项目添加到解决方案中。正如你所知，WPF 是一个在.NET Framework 之上运行的 UI 框架。

从步骤 9 到 13，我们只是创建了应用程序的用户界面。然后在步骤 12 中，我们更改了我们添加的控件的一些默认属性。赋予有意义的名称是一个非常好的做法，因为它有助于你构建可读的代码。在步骤 20 中，我们只是双击了一个控件，在这个例子中是按钮，以打开代码窗口。默认情况下，Visual Studio 为我们选择了一个事件。主要选择一个常用事件，在这个例子中是按钮的点击事件。

在步骤 22 中，我们将.NET Standard 2.0 库引用到代码中。这将允许你在 WPF 应用程序中访问其可用方法。在步骤 23 中，我们有按钮点击事件的实际运行代码。在第一行，我们创建了一个LittleShop()实例并将其存储在一个变量中。然后我们使用GetFruitsList()方法获取水果列表并将其存储在一个变量中。然后我们遍历fruits变量中所有可用的项目。

foreach (var fruit in fruits)
{
    FruitsList.Items.Add(fruit);
}

在之前为fruits变量编写的代码中，有一个List集合。foreach循环将遍历存储在fruits变量中的List集合内的每个项目。在循环内部，一个FruitsList列表框控件将添加存储在fruit变量中的fruits集合中的每个项目。

FruitsList.Items.Add("--------");
FruitsList.Items.Add($"Item Count: {fruits.Count}");
FruitsList.Items.Add($"Capacity: {fruits.Capacity}");

在我们将每个项目添加到列表框（FruitsList）之后，我们添加了一个显示List集合中项目数量的字符串。我们使用了List集合中的Count属性来获取该信息。在代码的最后一行，我们选择了List集合的Capacity属性。容量属性获取或设置内部数据结构可以不进行大小调整而容纳的总元素数。

在步骤 26 中，我们创建了一个LittleShop()类的实例，并使用GetShopItems()方法获取作为ArrayList()返回的项目。然后我们使用for循环获取第二个列表框中的项目。其余部分与我们对List集合所做的一样。

使用反射描述我们的库

在这个菜谱中，我们将构建一个具有两个公共方法的类对象。在使用控制台应用程序之后，我们将使用反射来描述这个类对象。反射赋予你读取其自身元数据以及在运行时查找程序集、类型和模块信息的能力。

准备工作

确保已安装 Visual Studio 2017 及其所有更新。我们将从一个空白解决方案开始。空白解决方案是任何规模项目的非常好的起点。让我们构建我们的.NET Standard 2.0 库。

如何操作...

1. 打开 Visual Studio 2017。

2. 点击“文件”|“新建”|“项目”，然后在“新建项目模板”对话框中，在左侧窗格的“其他项目类型”节点下选择“Visual Studio 解决方案”，然后在右侧窗格中选择“空白解决方案”。

3. 在“名称：”文本框中，将Chapter2.Reflections作为解决方案的名称输入。在“位置：”下拉列表中选择一个首选位置或点击“浏览...”按钮选择一个位置。保留默认设置：

1. 点击“确定”。

2. 现在，在解决方案资源管理器（或按Ctrl + Alt + L），选择 Chapter2.Reflections。右键单击并选择“添加”|“新项目”。

3. 在“添加新项目”对话框中，展开“Visual C#”节点，并在左侧窗格中选择“.NET Standard”。

4. 在右侧窗格中，选择“类库 (.NET Standard)”：

1. 现在，在 名称： 文本框中，键入 Chapter2.Reflections.CalculatorLib 并保持 位置： 文本框不变：

1. 点击确定。

2. 现在，解决方案资源管理器（按 Ctrl + Alt + L 打开）应该看起来像这样：

1. 在项目树中选择 Class1.cs 并按 F2。

2. 将 Class1.cs 重命名为 Calculator.cs，同时确保你也将类名本身进行了相同的更改：

      using System;

      namespace Chapter2.Reflections.CalculatorLib
      {
          public class Calculator
          {
          }
      }

1. 现在，解决方案资源管理器应该看起来像这样：

1. 在代码窗口中，在 Calculator 类的大括号之间，编写以下代码：

      public int Add(int number1, int number2)
      {
          return number1 + number2; 
      }

      public int Subtract(int number1, int number2)
      {
          return number1 - number2;
      }

1. 通过按 Ctrl + Shift + B 进行快速构建。

工作原理...

从步骤 1 到 4，我们创建了一个空白解决方案。然后，从步骤 5 到 9，我们在空白解决方案中添加了一个 .NET Standard 2.0 库。在步骤 12 中，我们将模板中提供的现有 Class1.cs 重命名为更有意义的东西。我们还重命名了类名以匹配文件名。这是一个好习惯，也是 Visual Studio 在创建全新的类时的默认行为。我们将名称更改为 Calculator.cs 并将类名更改为 Calculator。

在步骤 14 中，我们向 Calculator 类添加了两个简单的方法。第一个方法用于将给定的整数相加，第二个方法用于从一个整数中减去另一个整数。最后，我们快速构建以检查语法错误。

一个用于使用库的 .NET Core 控制台应用程序

让我们看看在这个配方中使用反射。在上一个配方中，我们构建了一个小的 .NET Standard 2.0 库。现在我们将创建一个基于 .NET Core 的控制台应用程序并使用反射来描述我们的库。我们将使用 System.Reflection 命名空间及其几个类

准备工作

确保你已经完成了上一个配方，如果没有，请完成它并返回这个配方。打开 Visual Studio 2017 并定位并打开之前构建的 .NET Standard 库。

如何操作...

1. 打开 Visual Studio 2017。

2. 现在打开上一个配方中的解决方案。单击 文件 | 打开 | 打开项目/解决方案，或按 Ctrl + Shift + O，并选择 Chapter2.Reflections 解决方案。

3. 按 Ctrl + Shift + B 进行快速构建以检查一切是否正常。

4. 现在，单击 Chapter2.Reflections 解决方案标签。单击 文件 | 添加 | 新项目。

5. 在 添加新项目 模板对话框中，展开左侧窗格中的 Visual C# 节点。

6. 在右侧窗格中选择 .NET Core，然后选择 控制台应用程序 (.NET Core)：

1. 现在，在 名称： 文本框中，键入 Chapter2.Reflections.ReflectCore 作为项目的名称。其余字段应保持默认设置：

1. 点击确定。

2. 现在，解决方案资源管理器（按 Ctrl + Alt + L）应该看起来像这样：

1. 右键单击Chapter2.Reflections.CalculatorLib中的“依赖项”标签。

2. 选择“添加引用”。

3. 在参考管理器中，点击右侧窗格中的“项目”标签。

4. 在左侧窗格中检查Chapter2.Reflections.CalculatorLib项目。

5. 点击“确定”。

6. 现在，双击Program.cs以打开代码窗口。

7. 在代码窗口中，滚动到屏幕顶部。

8. 在using指令的最后一行旁边，添加以下using指令：

      using System.Reflection;
      using Chapter2.Reflections.CalculatorLib;

1. 再次，向下滚动直到到达Main()方法，并在Main()方法的括号之间写入以下代码：

      MemberInfo info = typeof(Calculator);
      Console.WriteLine($"Assembly Name: {info.Name}");
      Console.WriteLine($"Module Name: {info.Module.Name}");
      Console.WriteLine();

      var calculator = new Calculator();
      var typeObject = calculator.GetType();
      var methods = typeObject.GetRuntimeMethods();

      foreach (var method in methods)
      {
          Console.WriteLine($"Method name : {method.Name}, 
          ---> Return type : {method.ReturnType}");
      }

      Console.ReadLine();

1. 让我们按F5并查看输出：

1. 按任意键退出。

它是如何工作的...

让我们看看步骤并尝试理解。在步骤 1 到 3 中，我们打开了一个包含.NET Standard 2.0 库的现有解决方案。我们快速构建以检查所有语法是否正确，并且项目没有问题地编译。在步骤 4 到 8 中，我们将一个基于.NET Core 的控制台应用程序添加到项目中，并给它一个合适的名称。

在步骤 10 到 14 中，我们从.NET Core 控制台应用程序中添加了对.NET Standard 2.0 库项目的引用。在步骤 17 中，我们将两个命名空间添加到了Program.cs代码中。一个是用于访问反射类，这些类包含在System.Reflection命名空间中。另一个是.NET Standard 2.0 库本身。

在步骤 18 中，我们在Program.cs的Main()方法中添加了代码：

MemberInfo info = typeof(Calculator);
Console.WriteLine($"Assembly Name: {info.Name}");
Console.WriteLine($"Module Name: {info.Module.Name}");
Console.WriteLine();

在第一行代码中，我们将一个名为info的变量存储了一个Calculator类类型，该变量是System.Reflections.MemberInfo()类型。在第二行代码中，我们使用Name属性访问了程序集类的名称，而再次使用Module.Name属性访问了模块名称。Member Info()类允许您获取成员的属性信息，并提供对成员元数据的访问：

var calculator = new Calculator();
var typeObject = calculator.GetType();
var methods = typeObject.GetRuntimeMethods();

foreach (var method in methods)
{
    Console.WriteLine($"Method name : {method.Name}, 
    ---> Return type : {method.ReturnType}");
}

Console.ReadLine();

在前面的几行代码中，我们在.NET Standard 2.0 库内部创建了一个Calculator()类的实例。在第二行中，我们存储了类的类型。在第三行中，我们有一个名为methods的变量，用于存储该类内部所有可用的运行时方法。由于GetRuntimeMethods()是一个集合，我们可以轻松地使用foreach语句遍历集合。最后，在foreach()语句内部，我们输出了Calculator()类内部每个方法的名称和返回类型。

最后，我们等待用户按任意键退出控制台应用程序。

在步骤19中，在输出中，您可能会注意到除了我们创建的两个公共方法之外，还有更多方法。这些方法来自基Object类本身。

构建.NET Standard 2.0 库，使用 LINQ

在这个示例中，我们将在我们的.NET Standard 2.0 库中使用 LINQ。LINQ 代表.NET 语言集成查询。LINQ 定义了一组通用标准查询操作符：列表、选择、排序和投影操作符，这些操作符可以在任何.NET 编程语言中使用。标准查询操作符允许查询应用于任何基于IEnumerable<T>的信息源。

我们将构建一个利用 LINQ 的.NET Standard 2.0 库，并在下一个示例中使用这个库。

准备工作

让我们通过打开 Visual Studio 2017 并创建一个基于.NET Standard 2.0 库的项目来做好准备。我们可以从一个空白解决方案开始，稍后添加库项目。

如何操作...

1. 打开 Visual Studio 2017。

2. 点击“文件”|“新建”|“项目”，然后在左侧窗格的“其他项目类型”节点下选择“Visual Studio 解决方案”，然后在右侧窗格中选择“空白解决方案”。

3. 在“名称”文本框中，输入Chapter2.Linq作为解决方案的名称。在“位置”下拉列表中选择一个首选位置，或点击“浏览...”按钮选择一个位置。保留默认设置：

1. 点击“确定”。

2. 现在，在解决方案资源管理器（或按Ctrl + Alt + L），选择 Chapter2.Linq。右键单击并选择“添加”|“新建项目”。

3. 在“添加新项目”对话框中，展开“Visual C#”节点，并在左侧窗格中选择.NET Standard。

4. 在右侧窗格中，选择“类库 (.NET Standard)”。

1. 现在，在“名称”文本框中，输入Chapter2.Linq.QueriesLib，并保留“位置”文本框不变：

1. 点击“确定”。

2. 现在，解决方案资源管理器（按Ctrl + Alt + L打开）应该看起来像这样：

1. 在项目树中选择 Class1.cs 并按F2。

2. 将Class1.cs重命名为TelephoneBook.cs，同时确保你也将类名本身进行了相同的更改。

3. 在确认对话框中点击“是”以确认重命名。

4. 现在，解决方案资源管理器应该看起来像这样：

1. 双击 TelephoneBook.cs 文件以打开代码窗口。

2. 现在，将代码窗口滚动到顶部，并在using指令的最后一行旁边添加以下代码：

      using System.Collections.Generic;
      using System.Linq;

1. 再次，滚动到TelephoneBook类的开括号处，并添加以下代码：

      private List<string> _contactList;

1. 现在，在下一行，将以下代码作为constructor方法添加：

      public TelephoneBook()
      {

          _contactList = new List<string>();

          _contactList.Add("Lenna Paprocki");
          _contactList.Add("Donette Foller");
          _contactList.Add("Simona Morasca");
          _contactList.Add("Mitsue Tollner");
          _contactList.Add("Leota Dilliard");
          _contactList.Add("Sage Wieser");
          _contactList.Add("Kris Marrier");
          _contactList.Add("Minna Amigon");
          _contactList.Add("Abel Maclead");
          _contactList.Add("Kiley Caldarera");
          _contactList.Add("Graciela Ruta");
}

1. 在构造函数旁边添加以下代码：

      public List<string> GetContacts() 
      {
          return _contactList;
      }

1. 再次，在GetContacts()方法的末尾添加此代码块：

      public List<string> GetContactsByLastName(string lastName)
      {
          var contacts = _contactList.Where(
          c => c.Contains(lastName)).ToList();
          return contacts;
      }

1. 最后，在GetContactsByLastName()方法的末尾添加以下代码块：

      public List<string> GetSortedContacts(bool ascending = true)
      {
          var sorted = _contactList.OrderBy(c => c).ToList();

          if (!ascending)
          {
              sorted = _contactList.OrderByDescending(c => c).ToList();
          }

          return sorted;
      }

1. 现在我们已经将代码添加到.NET Standard 2.0 库中，让我们按Ctrl + Shift + B进行快速构建并检查语法错误。

它是如何工作的...

从步骤 1 到 4，我们使用 Visual Studio 2017 创建了一个空白解决方案，并给它指定了一个位置和有意义的名称。然后，从步骤 5 到 9，我们在空白解决方案中添加了一个新的.NET Standard 2.0 库。像往常一样，我们给它起了一个恰当且有意义的名字。

在步骤 12 和 13 中，我们将默认的 Class1.cs 模板重命名为 TelephoneBook.cs。保持类和文件名相同是一个好习惯。当你回到代码时，这会使代码更易读、更易理解。在步骤 16 中，我们向代码中添加了两个命名空间。System.Collections.Generic 将为你提供代码中使用的 List<T> 类，而 System.Linq 通过允许使用 LINQ 功能，为你提供了对那些泛型集合的更多控制。

在步骤 17 中，我们引入了一个类型为 List<string> 的私有变量。在步骤 18 中，我们初始化了这个变量并向列表中添加了一些数据。  所有这些都是在 TelephoneBook() 类的构造函数中完成的。在步骤 19 中，我们创建了一个返回联系人列表的方法。它只有一行代码，返回了填充后的列表。

再次，在步骤 20 中，我们创建了一个接受字符串作为参数的方法。该参数是姓氏，我们在这行代码中使用了 LINQ 查询：

var contacts = _contactList.Where(c => c.Contains(lastName)).ToList();

我们使用了一个 Where 子句来过滤列表，并使用内联函数将 lastName 参数传递给操作。最后，我们将结果作为列表输出，并在方法末尾返回结果。

在步骤 21 中，我们创建了一个使用 LINQ 对列表进行排序的方法。GetSortedContacts() 方法接受一个布尔参数，它是可选的。C#自 C# 4.0 以来就支持可选参数。

var sorted = _contactList.OrderBy(c => c).ToList();

上一行代码使用了列表中的 OrderBy() 方法来按升序排序列表，并将其作为列表传递。如果我们需要降序排序，只需将方法参数传递为 false。

使用库的 ASP.NET MVC 应用程序

在这个菜谱中，我们将创建一个 ASP.NET MVC 应用程序来使用.NET Standard 2.0 库。这个库是在上一个菜谱中创建的。ASP.NET MVC 应用程序在基于 Windows 的系统下运行于 IIS，并使用完整的.NET Framework。我们将从一个空的 ASP.NET MVC 项目开始，然后转向其组件和库的使用。

准备工作

定位之前构建的.NET Standard 2.0 库，并确保它构建时没有错误。还假设你具备基于 MVC 的 ASP.NET 应用程序的基本知识，并且熟悉术语模型（Models）、视图（Views）和控制器（Controllers）。

如何操作...

1. 打开 Visual Studio 2017。

2. 现在，打开上一个菜谱中的解决方案。点击 文件 | 打开 | 打开项目/解决方案，或者按 Ctrl + Shift + O，然后选择 Chapter2.Linq 解决方案。

3. 按 Ctrl + Shift + B 进行快速构建以检查一切是否正常。

4. 现在，点击 Chapter2.Linq 解决方案标签。点击 文件 | 添加 | 新项目。

5. 在 添加新项目 模板对话框中，展开左侧窗格中的 Visual C#节点。

6. 在右侧窗格中选择 Web，然后选择 ASP.NET Web 应用程序 (.NET Framework)：

1. 现在，在“名称：”文本框中，键入Chapter2.Linq.QueriesMVC作为名称，并将“位置：”文本框保留在默认值：

1. 在新 ASP.NET Web 应用程序对话框中，从模板列表中选择空：

2. 选择 MVC 作为“为以下添加文件夹和核心引用”的选项：

1. 保持其余部分不变，并点击确定以创建默认的 ASP.NET MVC Web 应用程序模板。

2. 现在，解决方案资源管理器应该看起来像这样：

1. 现在，在Chapter2.Linq.QueriesMVC项目中的“控制器”文件夹内右键单击。

2. 选择添加 | 控制器。

3. 在添加脚手架对话框中，选择 MVC 5 控制器 - 空的：

1. 点击添加。

2. 在添加控制器对话框中，将控制器名称键入为HomeController：

1. 点击添加。

2. 现在，解决方案资源管理器（按 Ctrl + Alt + L）应该看起来像这样：

1. 现在，右键单击“引用”标签并选择添加引用。

2. 在参考管理器中，选择项目并从列表中检查 Chapter2.Linq.QueriesLib：

1. 点击确定。

2. 现在，在“控制器”文件夹中双击HomeController.cs。

3. 在HomeController.cs代码窗口中，向上滚动并在using指令的最后一行添加以下代码：

      using Chapter2.Linq.QueriesLib;

1. 在Index()动作中，在return关键字之前添加以下代码：

      var telephoneBook = new TelephoneBook();

      ViewBag.Contacts = telephoneBook.GetContacts();

1. 右键单击Index()方法的名称并选择添加视图：

1. 在添加视图对话框中，保留默认设置并点击添加：

1. 你将看到一个带有默认模板的Index.cshtml代码窗口。

2. 将代码<h2>Index</h2>更改为以下内容：

      <h2>Contacts</h2>

1. 现在，将光标移至代码窗口的底部并添加此代码：

      <ul>
          @foreach(var contact in ViewBag.Contacts as List<string>)
          {
              <li>@contact</li>
          }
      </ul>

1. 让我们按 F5 测试代码。

2. 默认情况下，浏览器将加载http://localhost:portnumber/Home/，这里是输出：

1. 现在让我们关闭浏览器并切换回HomeController.cs代码窗口。

2. 在Index()动作方法的结束花括号之后，添加以下代码：

      public ActionResult Search(string ln)
      {

          var telephoneBook = new TelephoneBook();

          if (string.IsNullOrEmpty(ln))
          {
              ViewBag.Contacts = telephoneBook.GetContacts();
          }
          else
          {
              ViewBag.Contacts =
              telephoneBook.GetContactsByLastName(ln);
          }

          return View();
      }

1. 右键单击Search()动作的方法名称并选择添加视图。

2. 按步骤 26 和 27 添加Search.chtml视图。

3. 在Search.chtml代码窗口中，将代码<h2>Search</h2>更改为以下内容：

      <h2>Search Results - Contacts</h2>

1. 在<h2>标签之后将以下代码添加到Search.chtml中：

      <ul>
          @foreach (var contact in ViewBag.Contacts as List<string>)
          {
              <li>@contact</li>
          }
      </ul>

1. 让我们按 F5 调试当前代码。

2. 在浏览器地址栏中输入http://localhost:portnumber/Home/Search并按 Enter：

1. 现在再次，在地址栏中输入http://localhost:portnumber/Home/Search?ln=Marrier并按Enter键：

1. 关闭浏览器并切换回HomeController.cs代码窗口。

2. 在Search()动作方法之后添加以下代码：

      public ActionResult SortedContacts(bool asc = true)
      {
          var telephoneBook = new TelephoneBook();

          ViewBag.Contacts = telephoneBook.GetSortedContacts(asc);

          return View();
      }

1. 右键单击SortedContacts()动作的方法名称，然后选择添加视图。

2. 按照步骤26和27添加SortedContacts.chtml视图。

3. 现在，在SortedContacts.chtml中，将<h2>SortedContacts</h2>更改为<h2>Sorted Contacts</h2>。

4. 在<h2>标签的末尾添加以下代码。

      <ul>
          @foreach (var contact in ViewBag.Contacts as List<string>)
          {
              <li>@contact</li>
          }
      </ul>

1. 按F5键以调试当前代码。

2. 在浏览器地址栏中输入http://localhost:portnumber/Home/SortedContacts并按Enter键：

1. 再次，在地址栏中输入http://localhost:51084/Home/SortedContacts?asc=false并按Enter键：

1. 关闭浏览器。

它是如何工作的...

让我们看看完成后的步骤。从步骤 1 到 3，我们打开了一个现有的解决方案，这是在之前的菜谱中完成的。然后我们快速构建以进行语法检查。从步骤 4 到 6，我们在现有解决方案中添加了一个 ASP.NET Web 应用程序项目。在第 7 步，我们给它起了个合适的名字。

之后，在步骤 8 和 9 中，我们决定它应该是什么样的 ASP.NET Web 应用程序。在这种情况下，我们选择了 MVC 空模板。在步骤 13 到 15 中，我们向 MVC 应用程序添加了一个控制器。我们选择了一个空的 MVC 5 控制器。

在步骤 19 到 21 中，我们从.NET Standard 2.0 库中添加了引用。在第 23 步，我们在代码级别引用了它。在第 24 步，代码的第一行中，我们创建了一个TelephoneBook()类的实例。在第二行中，我们调用了GetContacts()方法并将其存储在ViewBag.Contacts中。ViewBag用于从控制器向视图发送数据。

从步骤 25 到 27，我们向控制器动作方法中添加了一个视图。在第 28 步，我们更改了 Visual Studio 为我们创建的View模板中的现有代码。然后，我们使用 Razor 语法遍历联系人。在步骤 30 和 31 中，我们在浏览器中测试了代码。

从步骤 31 到 50，我们创建了视图并测试了TelephoneBook()类中找到的其他方法。

第三章：文件操作

在本章中，我们将探讨以下食谱：

• 在 Ubuntu 中设置.NET Core

• 创建一个文本日志

• 在 Ubuntu 中创建一个 ASP.NET Core 应用程序以使用库

• 在 macOS 中设置.NET Core

• 从逗号分隔（CSV）文本文件中读取

• 在 macOS 中创建一个.NET Core 控制台应用程序以使用库

• 压缩？为什么不呢？

• 创建一个经典 Windows 应用程序以使用库

• 在文本文件中加密和解密内容

• 创建一个经典 Windows 应用程序以使用库

技术要求

读者应具备 C#的基本知识。他们还应具备使用 Visual Studio、使用 NuGet 安装包以及在其他项目中引用库的基本知识。

本章的代码文件可以在 GitHub 上找到：

github.com/PacktPublishing/DotNET-Standard-2-Cookbook/tree/master/Chapter03

观看以下视频以查看代码的实际操作：

goo.gl/82FCEP

简介

作为一名开发者，在某个时候，我们不得不将一些数据写入磁盘或从磁盘读取数据。这可能是一个简单的文本文件，或者可能是一个您所编写的系统中的日志文件。.NET Framework 为与文件操作提供了强大的支持。主要，我们将关注System.IO命名空间及其使用。

在本章中，我们还将探讨一些跨平台应用程序。每个食谱将介绍如何设置新的环境，例如 Ubuntu 和 macOS，以及构建.NET Standard 2.0 库及其配套的应用程序。

在 Ubuntu 中设置.NET Core

在本食谱中，我们将介绍如何在 Ubuntu 系统中设置.NET Core 2.x。Ubuntu 是一个广泛使用的基于 Debian 的 Linux 环境。通过访问www.ubuntu.com/desktop，您可以轻松地下载并在您的系统上安装 Ubuntu。您可能需要使用虚拟 PC 来完成此操作。有两个出色的免费工具您可以使用：

1. VMWare Workstation Player for Windows: www.vmware.com/products/workstation-player.html

2. Oracle Virtual Box for Windows, Linux, and macOS: www.virtualbox.org/wiki/Downloads

本章假设您已经设置并安装了所需的操作系统。

准备工作

您将需要下载一个虚拟 PC 并安装最新版本的 Ubuntu。如果您还没有运行 Ubuntu 的虚拟 PC，在继续此食谱之前请确保已经完成。我在这里使用的是 Ubuntu 版本 16.04。要找出您拥有哪个版本，只需在终端中输入以下命令：

$ lsb_release -a

您应该得到以下输出：

如何操作...

1. 打开您喜欢的浏览器，输入以下 URL，然后按Enter键：

   https://www.microsoft.com/net/download/linux

1. 选择“安装 .NET Core SDK 2.x 包”按钮。

2. 从 Linux 发行版下拉列表中选择 Ubuntu 16.04。

1. 按照页面上的说明安装当前 SDK 或执行以下步骤进行安装。

2. 现在打开终端，输入以下命令并按 Enter 键：

 $ curl https://packages.microsoft.com/keys/microsoft.asc | 
      gpg --dearmor > microsoft.gpg

1. 如果您有一个全新的 Ubuntu 安装，您可能没有安装 curl。如果没有，请使用以下命令安装 curl：

 $ sudo apt-get install curl 

1. 现在，再次在终端中输入以下命令并按 Enter 键以获取文件列表：

 $ sudo mv microsoft.gpg /etc/apt/trusted.gpg.d/microsoft.gpg

1. 在终端中输入以下命令并按 Enter 键：

 $ sudo sh -c 'echo "deb [arch=amd64] 
      https://packages.microsoft.com/repos/
      microsoft-ubuntu-xenial-prod xenial main" > 
      /etc/apt/sources.list.d/dotnetdev.list'

1. 让我们使用以下命令更新软件包列表：

 $ sudo apt-get update

1. 最后，让我们使用以下命令安装 SDK：

 $ sudo apt-get install dotnet-sdk-2.0.2

1. 现在我们已经完成了 SDK 的安装，让我们使用以下命令来测试它：

 $ dotnet --version 

1. 如果一切正常，您应该会看到以下输出：

它是如何工作的...

在第 1 到 3 步中，我们导航以找到适合我们 Ubuntu 安装的所需 SDK 版本。这些命令很简单。我使用 Ubuntu 16.04 作为我的操作系统。在第 4 和 5 步中，我们使用 curl 将安全密钥下载到系统中，并告诉 Ubuntu 我们将从受信任的源下载 SDK。在一个全新的 Ubuntu 安装中，我们可能没有 curl 命令。所以，如果您遇到了“找不到命令”的问题，您可以直接按照第 4 步安装 curl。

在第 6 步中，我们使用 Ubuntu 命令更新了其软件包列表以包含 Microsoft 仓库。然后，在第 7 步中，我们使用 apt-get 命令更新了源列表。最后，在第 8 步中，我们实际安装了 .NET Core 2.0 SDK。

在第 9 和 10 步中，我们检查了安装是否一切正常，以便继续。

创建文本日志

在这个菜谱中，我们将创建一个 .NET Standard 2.0 库，该库将作为日志文件写入文本文件。这个日志文件将包含我们在应用程序中执行的操作的简单文本条目。它还将演示如何使用 .NET Core SDK 中的命令行工具来创建解决方案并添加项目，随着我们的进行。

准备工作

确保您已安装 Ubuntu 16.04 和 .NET Core 2.0 SDK。如果没有，请按照前面的菜谱进行操作。假设一切已安装且 .NET Core 2.0 正在运行，让我们开始创建一个将日志作为文本写入的库。

确保您已从 code.visualstudio.com 下载并安装了 Visual Studio Code。这是一个从网站下载 .deb 文件的简单安装。

如何操作...

1. 打开终端。

2. 现在在您的家目录或任何其他目录中输入以下命令并按 Enter 键：

      $ dotnet new sln -o Chapter3 -n Chapter3.LogFile

1. 现在，使用以下命令切换到新创建的目录：

 $ cd Chapter3

1. 现在您已经处于解决方案的根目录。让我们使用以下命令创建.NET Standard 库项目：

 $ dotnet new classlib -o Chapter3.LogFile.LogLib

1. 现在我们已经创建了我们的Class Library Project，让我们使用 Visual Studio Code 打开整个解决方案。

2. 在终端中输入以下命令并按Enter键：

 $ code .

1. 之前的命令将在当前目录中打开 Visual Studio Code，IDE 应该看起来像这样：

1. 现在，在代码树中，选择Class1.cs，按F2键，将名称更改为TextLog.cs并按Enter键。

2. 同样在代码窗口中，将类名从Class1更改为TextLog。

3. 现在您的代码应该看起来像这样：

      using System;

      namespace Chapter3.LogFile.LogLib
      {
          public class TextLog
          {
          }
      }

1. 让我们将我们的新项目添加到解决方案中。确保您位于项目目录的根目录。输入ls命令，输出应该像这样：

1. 在终端中输入以下命令并按Enter键：

 $ dotnet sln Chapter3.LogFile.sln  
      add Chapter3.LogFile.LogLib/Chapter3.LogFile.LogLib.csproj

1. 现在，在解决方案的根目录中，输入以下命令来构建解决方案及其关联的项目：

      $ dotnet build 

1. 输出窗口应该看起来像这样：

1. 让我们在库中添加一些代码。在using指令的顶部添加以下代码：

      using System.IO;

1. 在类的顶部，紧邻开括号，添加以下代码：

      private string logFileName = "server_log.txt";
      private StreamWriter logFile;

1. 让我们添加一个构造函数。在我们创建的变量旁边添加以下代码：

      public TextLog()
      {
          if (!File.Exists(logFileName))
          {
              logFile = File.CreateText(logFileName);
          }
          else
          {
              logFile = File.AppendText(logFileName);
          } 
      }

1. 在构造函数代码旁边，添加写入日志文件的函数：

      public void WriteLog(string message)
      {
          logFile.WriteLine($"{DateTime.Now} Log Message: {message} ");
      }

1. 让我们在代码中添加最后一个方法：

      public void CloseLog()
      {
          logFile.Close();
      }

1. 现在我们已经将所有代码添加到库中，让我们回到终端窗口并使用以下命令进行构建：

 $ dontnet build

它是如何工作的...

在第一步中，我们在 Ubuntu 系统中打开了终端窗口。这个终端类似于您在 Windows 操作系统中使用的命令窗口。终端可以帮助您执行由.NET Core 2.0 支持的 shell 命令。在第2步中，我们创建了一个空白解决方案。dotnet new命令创建了一个包含目录的新解决方案文件。在第3步中，我们将目录更改为解决方案文件的根目录。从这一点开始，我们将向解决方案中添加项目。

在第 4 步中，我们使用了相同的dotnet new命令来创建类库。默认情况下，这个类库将使用.NET Standard 2.0 库，因此我们不需要告诉命令行工具创建.NET Standard 2.0 库。我们可以通过在 Visual Studio Code 中展开Chapter3.LogFile.LogLib节点，然后点击Chapter3.LogFile.LogLib.csproj标签来确认这一点。在 Visual Studio Code 的右侧窗格中，您将能够看到以下 XML 代码：

<Project Sdk="Microsoft.NET.Sdk">
    <PropertyGroup>
        <TargetFramework>netstandard2.0</TargetFramework>
    </PropertyGroup>
</Project>

在此代码中，<TargetFramwork> 标记表示它是 netstandard2.0，并且已经确认，我们手头有一个 .NET Standard 2.0 库。在第 6 步到第 10 步中，我们使用 Visual Studio Code 打开当前目录并对现有类进行了修改。在第 11 步中，我们确保我们处于解决方案的根目录。在第 12 步中，我们使用命令行工具将类库项目添加到解决方案中。你可以在终端中执行以下命令来列出解决方案中的所有项目：

$ dotnet sln list 

命令将列出当前解决方案文件中所有可用的项目。在第 13 步中，我们执行了一个 build 命令以确保一切完好且运行正常。在第 15 步中，我们添加了用于处理输入和输出的命名空间。System.IO 命名空间包含其内部的所有文件处理类。

在第 16 步中，我们创建了两个 private 变量来存储文件名和 StreamWriter 类，该类可以帮助你将文本写入文件。在第 17 步中，我们创建了一个构造函数方法，用于检查文件是否存在。如果文件不存在，它将创建一个新的文本文件；如果已经存在文件，我们将打开文件以追加文本。当你处理这类任务时，这是一个非常好的实践。

在第 18 步中，我们创建了一个方法，该方法接受一个 string 参数作为消息并将其写入文件。在第 19 步中，我们创建了一个方法来关闭打开的文件。最后，在第 20 步中，我们使用 build 命令验证了语法正确且构建无误。

在 Ubuntu 中创建 ASP.NET Core 应用程序以使用库

我们将创建一个 ASP.NET Core 应用程序来使用本配方中的库。ASP.NET Core 将使用 MVC 设计模式，并在 Linux、macOS 以及当然，在 Windows 上工作。我们将使用 Ubuntu 作为操作系统来构建这个小应用程序，以展示 .NET Core 的跨平台能力。

准备工作

确保你已经完成了之前的配方，包括设置环境和构建用于创建日志文件的 .NET Standard 2.0 库。本配方假设你具备 MVC 架构的基本知识。简单来说，MVC 是一种软件架构模式，它将数据模型、控制代码和用户界面分开。让我们看看如何构建这个应用程序并使用我们的库。

如何做...

1. 打开终端并导航到之前配方中构建的应用程序的根目录。

2. 目录结构应该看起来像这样：

1. 现在在终端中输入以下命令并按 Enter 键以创建新的 ASP.NET Core MVC 应用程序：

      $ dotnet new mvc -o Chapter3.LogFile.LogAppMvc

1. 让我们将这个新项目添加到解决方案中：

     $ dotnet sln add 
 Chapter3.LogFile.LogAppMvc/Chapter3.LogFile.LogAppMvc.csproj

1. 现在让我们执行构建以检查一切是否正常工作：

      $ dotnet build

1. 现在，导航到我们刚刚创建的应用程序：

      $ cd Chapter3.LogFile.LogAppMvc/

1. 使用以下命令执行应用程序：

 $ dotnet run

1. 如果一切正常，打开您的浏览器，在地址栏中输入 http://localhost:5000 并按 Enter。浏览器输出应该如下所示：

1. 让我们关闭浏览器，并在终端窗口中按 Ctrl + C 来停止网络服务器。

2. 我们需要添加之前构建的 .NET Standard 2.0 库的引用。现在让我们使用终端中的此命令来添加它：

 $ dotnet add reference 
      ../Chapter3.LogFile.LogLib/Chapter3.LogFile.LogLib.csproj 

1. 让我们通过输入以下命令回到根文件夹：

      $ cd ..

1. 现在，在解决方案目录的根目录中，输入以下命令以使用当前目录打开 Visual Studio Code：

      $ code . 

1. 在 Visual Studio Code 中，展开 Chapter3 标签，然后展开 Chapter3.LogFile.LogAppMvc。

2. 再次，展开 Controllers 文件夹，并点击 HomeController.cs:

1. 在 HomeController.cs 中，将以下 using 指令添加到 using 指令块的最后一行：

      using Chapter3.LogFile.LogLib;

1. 现在，在 HomeController 类的 Index 方法的起始大括号旁边，添加以下代码：

      TextLog logFile = new TextLog();
      logFile.WriteLog("You are in the Index action.");
      logFile.CloseLog();

1. 让我们在 About 方法内部也添加更多的代码：

      TextLog logFile = new TextLog();
      logFile.WriteLog("You are in the About action.");
      logFile.CloseLog();

1. 同样对 Contact 方法也进行相同的操作：

      TextLog logFile = new TextLog();
      logFile.WriteLog("You are in the Contact action.");
      logFile.CloseLog();

1. 现在，我们已经完成了代码的添加，让我们导航到 Chapter3.LogFile.LogAppMvc：

 $ cd Chapter3.LogFile.LogAppMvc/

1. 让我们运行应用程序：

      $ dotnet run

1. 打开您喜欢的浏览器，在地址栏中输入 localhost:5000，然后按 Enter。点击导航链接 Home、About 和 Contact 几次。

2. 关闭浏览器。

3. 现在，转到 Visual Studio Code，展开 Chapter3 标签，然后展开 Chapter3.LogFile.LogAppMvc。 您应该在根目录中看到一个名为 server_log.txt 的文件：

1. 现在，点击 server_log.txt 文件名以查看输出：

它是如何工作的...

在步骤 1 和 2 中，我们打开了终端并确保我们处于正确的目录，即解决方案的根目录。然后，在步骤 3 中，我们创建了 ASP.NET Core 2.0 MVC 应用程序。在步骤 4 中，我们将该项目添加到解决方案中。完成此步骤后，解决方案中就有两个项目了，您可以通过在解决方案目录的根目录中输入以下命令来查看解决方案中的所有项目：

dotnet sln list 

在步骤 5、6 和 7 中，我们从根目录构建项目以检查一切是否正常。然后，我们导航到新创建的项目文件夹并执行项目以测试是否一切正常。在步骤 8 中，我们打开默认浏览器并给出测试 ASP.NET Core 2.0 应用程序的 URL。如您所见，URL 看起来像 http://localhost:5000。默认情况下，网络服务器（即 Kestrel）运行在端口 5000。

Kestrel 是一个跨平台的 ASP.NET Core 网络服务器，它使用名为 libuv 的跨平台异步 I/O 库构建。

因此，我们没有做任何更改，保留了默认设置。在步骤 11 中，我们导航回根解决方案目录，然后在步骤 12 中，我们使用该目录打开 Visual Studio Code。

在步骤 14 中，我们导航到 HomeController.cs，在步骤 15 中，我们添加了第一个 using 语句以访问允许您使用文件操作的类。在步骤 16 中，我们创建了 TextLog 类并在 WriteLog() 方法中使用它。最后，我们使用 CloseLog() 方法关闭了打开的文件。我们在步骤 17 和 18 中做了同样的事情。在步骤 19 和 20 中，我们导航到 ASP.NET Core 2.0 应用程序目录并执行了应用程序。

在步骤 21 和 22 中，我们打开了浏览器并使用该应用程序将一些文本写入磁盘。然后我们关闭了浏览器。最后，在步骤 23 和 24 中，当我们使用应用程序时，我们见证了写入磁盘的文件。

在 macOS 中设置 .NET Core

在本教程中，我们将探讨如何在 macOS 上设置以运行 .NET Core 2.0 应用程序。在撰写本文时，macOS 版本是 macOS High Sierra 10.13.2。我们需要一台 MacBook 或 iMac 这样的设备来运行 macOS，否则您可以跳过本教程。

准备工作

确保您的设备上已安装并运行 macOS。打开您喜欢的浏览器。我还假设您在 Mac 设备上下载和安装应用程序有经验。

如何操作...

1. 打开您喜欢的浏览器，导航到 www.microsoft.com/net/download/macos。

2. 点击 Download .NET Core 2.1.x SDK（在撰写本文时，版本是 2.1.105）按钮。

1. 现在，在下载对话框中，选择“保存”。

2. 现在双击下载位置（通常在 Downloads 文件夹中）的文件，并按照说明进行安装。

3. 安装完成后，您应该可以开始了。让我们打开一个终端并测试安装。（应用程序 | 实用工具 | 终端）。

4. 现在，在终端中，输入以下命令：

      $ dotnet --version

1. 如果一切正常，您应该会看到如下输出：

1. 让我们在 code.visualstudio.com/ 下载 Visual Studio Code for Mac。

2. 在对话框中，选择“保存文件”以下载。

3. 下载文件后，找到它并双击以解压。然后将文件拖放到 Applications 文件夹中，您就可以使用 Visual Studio Code 了。

它是如何工作的...

在这些步骤中，我们已经下载并安装了 .NET Core 2.0 和 Visual Studio Code。每一步都很直观。在打开 Visual Studio Code 后，您可能需要安装一些扩展，如 C#，以便使事情变得更容易。

从逗号分隔（CSV）文本文件中读取

在本教程中，我们将使用 macOS 下的 .NET Core 2.0。我假设您熟悉使用终端并在其中输入一些命令。我们将查看 .NET Core 2.0 提供的命令行工具，以创建我们的 .NET Standard 2.0 库，该库可以读取逗号分隔值（CSV）文件并返回其数据。

准备工作

如果您还没有完成之前的菜谱，请确保您已经完成了。这将帮助您下载.NET Core 2.0 和 Visual Studio Code 作为 IDE。让我们启动终端并开始吧。

如何做到这一点...

1. 打开终端窗口（应用程序 | 实用工具 | 终端）。

2. 现在，在您的home目录中，输入以下命令（您可能需要为项目创建一个单独的目录并执行以下命令）：

      $ dotnet new sln -o Chapter3.CsvFile

1. 现在，输入以下命令以导航到新创建的解决方案：

      $ cd Chapter3.CsvFile

1. 再次输入此命令以创建.NET Standard 2.0 库项目：

      $ dotnet new classlib -o Chapter3.CsvFile.CsvReader

1. 现在，让我们通过输入此命令将此项目添加到我们的解决方案中：

      $ dotnet sln add 
      Chapter3.CsvFile.CsvReader/Chapter3.CsvFile.CsvReader.csproj

1. 让我们打开 Visual Studio Code 并打开当前解决方案目录（文件 | 打开）。（Visual Studio Code 通常会在应用程序目录下列出它）。

2. Visual Studio Code 应该看起来像这样：

Visual Studio Code

1. 现在，选择文件树中的Class1.cs标签。

2. 按下Enter键，将Class1.cs重命名为CsvFileLib.cs，然后再次按下Enter。

3. 现在，在代码编辑器中，将Class1类名更改为与文件名CsvFileLib匹配。

4. 让我们点击 CsvFileLib.cs 选项卡并添加一些代码。在代码窗口的最后一行using指令旁边添加using指令：

      using System.IO;
      using System.Collections.Generics;

1. 在CsvFileLib的开放花括号上方，在类中添加以下代码：

      private string _fileName; 

1. 现在，在上一行旁边，添加以下类的构造函数代码：

      public CsvFileLib(string csvFile)
      {
          _fileName = csvFile;
      }

1. 最后，让我们添加一个方法来读取 CSV 文件中的所有行：

      public List<string> ReadCsvFile()
      {
          var fileContents = new List<string>();

          using (var csvFile = File.OpenRead(_fileName))
          {
              var fileStream = new StreamReader(csvFile);

              while(!fileStream.EndOfStream)
              {
                  fileContents.Add(fileStream.ReadLine());
              }
              fileStream.Close();
          }

          return fileContents;
      }

1. 现在，在终端中输入以下命令来构建解决方案（确保您位于解决方案目录的根目录）：

      $ dotnet build

1. 这将构建并检查代码中的任何语法错误。

它是如何工作的...

在步骤 1 到 5 中，我们使用了.NET Core 命令行工具来创建解决方案和项目，然后将项目添加到解决方案中。在步骤 6 和 7 中，我们打开了 macOS 上的 Visual Studio Code 并打开了刚刚创建的目录。macOS 上的 Visual Studio Code 允许您在 macOS 上使用基于.NET 的应用程序。此外，通过安装扩展，它还允许您使用其他流行的技术。

在步骤 9 和 10 中，我们将模板生成的默认Class1.cs重命名，并将文件和类重命名为有意义的名称。在步骤 11 中，我们添加了必要的命名空间来处理文件和集合。在步骤 12 中，我们创建了一个私有变量来保存文件名。在步骤 13 中，我们创建了一个构造函数，它接受一个包含路径的文件名作为string参数，然后填充了我们在步骤 12 中创建的变量。

在第 14 步中，我们创建了一个方法，该方法读取整个文件并将文本的每一行存储到一个列表集合中。这个集合将其项目存储为string，在ReadCsvFile()方法的第 1 行，我们创建了一个局部变量来保存 CSV 文本文件的句柄。代码的下一部分打开给定的文本文件，在下一行将所有内容存储在一个变量中作为一个流。第 3 行循环到文件末尾，并将每一行存储在之前的列表中。最后，它关闭流并从ReadCsvFile()方法返回内容列表：

      using (var csvFile = File.OpenRead(_fileName))
      {
          var fileStream = new StreamReader(csvFile);

          while(!fileStream.EndOfStream)
          {
              fileContents.Add(fileStream.ReadLine());
          }

          fileStream.Close();
      }

在 macOS 上创建一个.NET Core 控制台应用程序以使用库

在这个菜谱中，我们将创建一个.NET Core 控制台应用程序来使用之前会话中构建的库。.NET Core 是一个跨平台的.NET 版本，可以在 Windows、Linux 和 macOS 上运行。这个菜谱专注于在 macOS 下运行的.NET Core。

准备工作

让我们打开终端并确保我们位于之前菜谱中构建的解决方案的根目录。执行以下快速构建命令以检查一切是否正常工作：

$ dotnet build

如何操作...

1. 打开终端（应用程序 | 工具 | 终端）。

2. 导航到之前菜谱中构建的解决方案的根目录，并输入以下命令：

      $ dotnet new console -o Chapter3.CsvFile.ConsoleApp

1. 再次，输入此命令以查看目录内容：

      $ ls

1. 您的终端应该看起来像这样：

1. 执行以下命令将此项目添加到解决方案并测试构建：

      $ dotnet sln add 
 Chapter3.CsvFile.Console/Chapter3.CsvFile.ConsoleApp.csproj 

 $ dotnet build

1. 让我们打开 Visual Studio Code 并打开（文件 | 打开）完整的解决方案。

2. 您的 Visual Studio Code 应该看起来像这样：

1. 现在展开Chapter3.CsvFile.Console节点并选择Chapter3.CsvFile.Console标签。

2. 在选项卡上点击新建文件图标。

1. 输入movies.txt作为名称并按Enter键。

2. 现在选择movies.txt文件并添加以下内容：

   1,X-Men: Apocalypse,2016

   2,The Secret Life of Pets,2016

   3,Suicide Squad,2016

   4,Independence Day: Resurgence,2016

   5,Star Trek 3,2016

   6,Batman v Superman: Dawn of Justice,2016

   7,The Jungle Book,2016

   8,Hail, Caesar!,2016

   9,Zoolander 2,2016

   10,How to Be Single,2016

3. 您的文本文件应该看起来像这样：

1. 让我们打开终端（应用程序 | 工具 | 终端）并导航到新创建的控制台项目。

2. 输入以下命令并按Enter键将我们的库添加到控制台应用程序作为引用：

      $ dotnet add reference 
 ../Chapter3.CsvFile.CsvReader/Chapter3.CsvFile.CsvReader.csproj

1. 让我们回到 Visual Studio Code，选择Program.cs，并在using指令的最后一行之后添加此using指令：

      using Chapter3.CsvFile.CsvReader;

1. 现在删除Main()方法中任何现有的代码，并在大括号之间添加此代码：

      var moviesFile = new CsvFileLib("movies.txt");
      var moviesList = moviesFile.ReadCsvFile();

      foreach (var movie in moviesList)
      {
          var row = movie.Split(',');
          Console.WriteLine($"ID: {row[0]} Title : 
              {row[1]} Year : {row[2]}");
      }

1. 保存当前更改并回到终端，输入以下命令并按Enter键：

      $ dotnet build 

1. 再次，输入以下代码并按Enter键：

      $ dotnet run 

1. 你应该在终端窗口中看到以下输出：

它是如何工作的...

在第 1 至 4 步中，我们导航到之前构建的 .NET Standard 2.0 库。使用 macOS 终端，我们到达该解决方案的根目录。此外，我们还创建了一个新的 .NET Standard 2.0 库。当你创建 .NET Core 2.0 的库项目时，默认情况下它会选择 .NET Standard 2.0 作为模板。所以我们不用担心告诉命令行工具创建 .NET Standard 2.0 库。

在第 5 步中，我们将新创建的项目添加到我们的解决方案中，并执行构建以检查一切是否正常。在第 6 至 9 步中，我们使用 Visual Studio Code 打开当前目录，然后在第 9 至 12 步中，我们创建了用于测试目的的逗号分隔值样本文本文件。在第 14 步中，我们将库添加到我们的控制台应用程序中作为引用。

在第 15 步中，我们在using语句中添加了库项目的引用，然后在第 16 步中创建了一个CsvFileLib类的实例，并将ReadCsvFile()方法的输出存储在一个变量中。最后，我们遍历了由ReadCsvFile()方法返回的列表，并在控制台窗口中打印了输出。

压缩？为什么不呢？

在本食谱中，我们将探讨在 .NET Framework 上支持的文件压缩功能以及如何在 .NET Standard 2.0 库中使用它们。System.IO.Compression 命名空间内支持文件压缩类。此命名空间内的类用于压缩文件以及解压缩文件。它们还用于读取压缩文件内的内容。让我们看看并创建一个可以压缩和解压缩文件的 .NET Standard 2.0 库。

准备工作

确保你的 Visual Studio 2017 是最新版本并正在运行。如前所述，我们将使用System.IO.Compression中的类。主要我们将关注ZipFile类。让我们开始构建我们的库，它可以压缩和解压缩文件。

如何做...

1. 打开 Visual Studio 2017。

2. 点击“文件”|“新建”|“项目”来创建一个项目。

3. 在“新建项目”对话框中，展开左侧窗格中的“其他项目类型”节点，并选择“Visual Studio 解决方案”。在右侧窗格中，选择“空白解决方案。”

4. 在“名称：”文本框中，键入Chapter3.Compress，并在“位置：”文本框中，从下拉框中选择路径或点击“浏览...”按钮来定位路径。

1. 点击“确定”。

2. 现在，你的“解决方案资源管理器”(Ctrl + Alt + L)应该看起来像这样：

1. 现在，在“解决方案资源管理器”中右键单击Chapter3.Compress标签，并选择“添加”|“新建项目”。

2. 在“新建项目”对话框中，展开“Visual C#”节点。

3. 在左侧窗格中选择.NET Standard，在右侧窗格中选择类库 (.NET Standard)。

1. 现在，在名称：文本框中，输入 Chapter3.Compress.CompressLib，保留其他默认设置，然后点击确定。

1. 现在，解决方案资源管理器 (Ctrl + Alt + L) 应该看起来像这样：

1. 现在，在解决方案资源管理器中选择 Class1.cs 并按 F2 键重命名文件为 Zipper.cs。

2. 在确认对话框中回答是，以将类名也重命名。

3. 现在，在 Zipper.cs 代码窗口中（在解决方案资源管理器中双击 Zipper.cs 标签以打开），在 using 指令的最后一行旁边输入以下代码：

      using System.Collections.Generic;
      using System.IO.Compression;

1. 在类代码顶部创建一个 private 类变量（紧挨着类的开始花括号）：

      private string _sourcePath;

1. 让我们通过添加以下代码向我们的类添加一个构造函数：

      public Zipper(string sourcePath)
      {
          _sourcePath = sourcePath;
      }

1. 现在，在构造函数代码旁边添加此方法：

      public void CompressFile(string zipPath)
      {
          ZipFile.CreateFromDirectory(zipPath, _sourcePath);
      }

1. 最后，添加以下代码以列出压缩内容：

      public List<string> ListArchive(string zipFile)
      {
          var fileList = new List<string>()

          using (ZipArchive archive = ZipFile.OpenRead(zipFile)
          {
              foreach(var entry in archive.Entries)
              {
                  fileList.Add(entry.Name);
              }
          }

          return fileList;
      }

1. 通过按 Ctrl + Shift + B 执行快速构建，以检查语法错误。

它是如何工作的...

在步骤 1 到 5 中，我们使用 Visual Studio 2017 创建了一个空白解决方案，并给它一个合适、有意义的名称。在步骤 7 到 10 中，我们将一个 .NET Standard 2.0 类库添加到项目中。我们在步骤 12 中模板生成的默认 Class1.cs 进行了重命名。在步骤 14 中，我们向代码中添加了两个命名空间。System.IO.Compression 命名空间包含所有必要的类，用于压缩和解压缩。在步骤 15 中，我们添加了一个私有变量，用于存储压缩路径。在这种情况下，它是一个文件夹。

步骤 16 介绍了具有源路径参数的构造函数以进行压缩。在步骤 17 中，我们创建了一个使用 ZipFile 类及其方法压缩指定源文件夹的方法。然后，最终，我们创建了一个列出压缩存档名称的方法。它接受一个参数作为压缩 zip 文件路径：

var fileList = new List<string>()

    using (ZipArchive archive = ZipFile.OpenRead(zipFile)
    {
        foreach(var entry in archive.Entries)
        {
            fileList.Add(entry.Name);
        }
    }

    return fileList;

第一行创建了一个空的列表，将 strings 作为项目填充。然后我们创建了一个 ZipArchive 实例。我们使用了 using 关键字来包围那个语句。这是一种安全的编程方法，用于此类项目。using 关键字是使用实现 IDisposable 接口的对象的一种非常方便的方法。

IDisposable 接口提供了一个释放非托管资源的机制。

最后，我们使用 foreach 遍历了所有条目，然后返回了填充后的列表。

创建一个经典 Windows 应用程序以使用库

在这个菜谱中，我们将查看一个经典的 Windows 应用程序，该程序使用我们在上一个菜谱中构建的库来压缩指定的文件夹。确保你已经完成了创建 .NET Standard 2.0 库的上一个菜谱。

准备工作

让我们打开我们构建的库的先前解决方案。确保你执行快速构建 (Ctrl + Shift + B) 以检查任何语法错误。

如何操作...

1. 打开 Visual Studio 2017。

2. 现在，打开从先前菜谱构建的解决方案。

3. 解决方案资源管理器应该看起来像这样：

1. 现在，让我们选择解决方案名称并右键点击。

2. 从菜单中选择添加 | 新项目。

3. 在“新建项目”对话框中，展开 Visual C# 节点，并在左侧窗格中选择 Windows Classic Desktop。

4. 在右侧窗格中，选择 Windows Forms App (.NET Framework)：

1. 现在，在“名称：”文本框中输入 Chapter3.Compress.ZipperWinApp，保留“位置：”文本框的当前设置，然后点击确定。

1. 现在，解决方案资源管理器应该看起来像这样：

1. 让我们通过选择它并按 F2 将 Form1.cs 重命名为 MainForm.cs。

2. 在确认框中点击是以确认更改主类名。

3. 现在，从设计器窗口中选择 Windows 窗体。

4. 将 TextBox、Button 和 ListBox 拖放到窗体中。

5. 同时将一个 FolderDialogBox 控件拖放到 Windows 窗体中。

6. 根据此表更改先前控件的属性：

   控件	属性	值
   文本框	名称	FolderTextBox
   按钮	名称	BrowseButton
   按钮	文本	Browse...
   列表框	名称	FileListBox
   窗体	文本	Zipper WinApp
   文件夹对话框框	名称	ZipFolder

7. 现在，你的设计区域应该看起来像这样：

1. 现在，在解决方案资源管理器中选择 Chapter3.Compress.ZipperWinApp 标签并展开它。

2. 右键点击“引用”标签并选择添加引用。

3. 在引用管理器对话框中点击“项目”节点。

4. 在右侧窗格的项目列表中，勾选 Chapter3.Compress.CompressLib 前面的复选框。

1. 点击确定。

2. 现在双击“浏览...”按钮以打开代码窗口。

3. 在代码窗口中向上滚动并添加以下 using 指令到所有 using 指令的最后一行，即在顶部：

      using Chapter3.Compress.CompressLib;

1. 现在向下滚动，直到到达“浏览...”按钮的按钮点击事件，并在大括号之间添加以下代码：

      if (ZipFolder.ShowDialog() == DialogResult.OK)
      {
          FolderTextBox.Text = ZipFolder.SelectedPath;

          string zipFileName = 
              @"C:\Projects\Chapter3\TestFolder\result.zip";

          var zipFile = new Zipper(zipFileName);
          zipFile.CompressFile(FolderTextBox.Text);

          MessageBox.Show("You folder has been zipped.", 
              "Information", MessageBoxButtons.OK, 
              MessageBoxIcon.Information);

          var fileList = zipFile.ListArchive(zipFileName);

          FileListBox.Items.AddRange(fileList.ToArray());
      }

1. 让我们按 F5 并测试我们的代码。你的输出应该看起来像这样：

1. 让我们点击“浏览...”按钮并导航到一个文件夹：

1. 点击确定。现在，文件夹将被压缩，输出文件将是 result.zip。

1. 点击确定。

2. 现在，你将看到压缩 ZIP 文件中的文件列表：

1. 让我们使用 Windows 资源管理器浏览到选定的文件夹并查看（您可以从应用程序中的文本框中复制并粘贴路径）：

1. 双击文件，你会看到 ZIP 文件的内容与我们在第 29 步中看到的列表相匹配：

1. 现在关闭应用程序。

作用原理...

在步骤 1 到 9 中，我们打开了之前菜谱中构建的带有.NET Standard 2.0 类库的现有解决方案。然后我们向该解决方案添加了一个新的经典 Windows 应用程序项目，并给它一个合适的名称以匹配解决方案。在步骤 10 和 11 中，我们将 Visual Studio 生成的默认 Windows 窗体重命名。在步骤 12 到 16 中，我们添加了必要的控件来构建我们应用程序的用户界面。

在步骤 18 到 21 中，我们将.NET Standard 2.0 库的引用添加到我们的经典 Windows 应用程序中。这是一个强制性的步骤，否则你将无法访问库及其功能。在步骤 23 中，我们添加了一个 using 语句，这将告诉 Windows 应用程序我们已经引用了库，并允许我们访问其可访问的方法。

在步骤 24 中，我们向浏览...按钮的点击事件中添加了代码。在该代码的第一行中，我们使用了一个if语句来打开文件夹对话框，并检查对话框中是否按下了 OK 按钮。然后，接下来的两行代码将选定的路径存储在我们的 Windows 应用程序的文本框中：

FolderTextBox.Text = ZipFolder.SelectedPath;

string zipFileName = @"C:\Projects\Chapter3\TestFolder\result.zip";

然后，我们有一个string变量，用于存储目标 ZIP 文件名：

var zipFile = new Zipper(zipFileName);
zipFile.CompressFile(FolderTextBox.Text);

MessageBox.Show("You folder has been zipped.", 
    "Information", MessageBoxButtons.OK, MessageBoxIcon.Information);

在第一行，我们创建了一个Zipper类的实例，在第二行，我们使用了它的CompressFile()方法。最后，我们通过使用MessageBox.Show()方法向最终用户显示了一个通知。最后，在接下来的两行代码中，我们使用了ListArchive()方法来提取 ZIP 文件的内容，并将其添加到列表框控件中：

var fileList = zipFile.ListArchive(zipFileName);
FileListBox.Items.AddRange(fileList.ToArray());

在文本文件中加密和解密内容

在这个菜谱中，我们将查看System.IO命名空间的其他功能。我们将创建一个.NET Standard 2.0 库，该库可以加密现有的文本文件，也可以解密它。

准备工作

加密是保护文件的一种很好的方式。System.IO命名空间为你提供了加密和解密内容的功能。让我们看看如何在.NET Standard 2.0 库中实现它。

如何操作...

1. 打开 Visual Studio 2017。

2. 点击文件 | 新建 | 项目来创建一个项目。

3. 在“新建项目”对话框中，展开左侧窗格中的“其他项目类型”节点，并选择 Visual Studio 解决方案。在右侧窗格中，选择空白解决方案。

4. 在“名称：”文本框中，键入Chapter3.SecureFile，在“位置：”文本框中，从下拉框中选择路径或点击浏览...按钮来定位路径。

1. 点击确定。

2. 现在，你的解决方案资源管理器（Ctrl + Alt + L）应该看起来像这样：

1. 现在，在解决方案资源管理器中右键单击Chapter3.SecureFile标签，并选择添加 | 新项目****。

2. 在“新建项目”对话框中，展开“Visual C#”节点。

3. 在左侧窗格中选择 .NET Standard，在右侧窗格中选择类库 (.NET Standard)。

1. 现在，在“名称”文本框中，输入Chapter3.SecureFile.CryptLib，保留其他默认设置，然后点击确定。

1. 现在，解决方案资源管理器 (Ctrl + Alt + L) 应该看起来像这样：

1. 现在，在解决方案资源管理器中选择 Class1.cs 并按 F2 将文件重命名为 CryptFile.cs。

2. 在询问是否重命名类名的确认对话框中，回答是。

3. 现在，双击 CryptFile.cs 以打开代码窗口。

4. 在代码窗口中，向上滚动到顶部，并在 using 指令的最后一行添加以下 using 指令：

      using System.IO;

1. 现在，在 CryptFile 类的开始花括号旁边添加以下代码：

      private string _fileName;

1. 添加以下默认构造函数方法：

      public CryptFile(string fileName)
      {
          _fileName = fileName;
      }

1. 现在，让我们添加一个加密文件的方法：

      public void EncryptFile()
      {
          File.Encrypt(_fileName);
      }

1. 还要添加以下解密文件的方法：

      public void DecryptFile()
      {
          File.Decrypt(_fileName);
      }

1. 按 Ctrl + Shift + B 进行快速构建以检查语法是否正确。

它是如何工作的...

在步骤 1 到 5 中，我们打开了 Visual Studio 2017，创建了一个空解决方案，并给它起了适当的名字。在步骤 7 到 11 中，我们将 .NET Standard 2.0 库添加到解决方案中。在步骤 12 和 13 中，我们更改了由模板生成的类的默认名称。在步骤 15 中，我们添加了包含文件加密和解密功能的 System.IO 命名空间。

在步骤 16 中，我们添加了一个类级别的私有 string 变量来保存要加密和解密的文件名。在步骤 17 中，我们添加了默认构造函数，用于填充私有变量以保存文件名。在步骤 18 中，我们添加了一个加密文件的方法。我们使用了 System.IO 命名空间中找到的文件类的 Encrypt() 方法。在步骤 19 中，我们以相同的方式解密文件。

最后，我们进行了快速构建以检查所有语法是否完整。

创建一个经典 Windows 应用程序以使用库

这个配方将专注于构建一个经典 Windows 应用程序来使用我们在上一个配方中创建的 .NET Standard 2.0 库。

准备工作

确保你已经完成了之前的配方，其中我们构建了一个 .NET Standard 2.0 库。它使用了 System.IO 命名空间来加密和解密文件。打开该解决方案，并快速按 Ctrl + Shift + B 检查一切是否正常。

如何做...

1. 打开 Visual Studio 2017。

2. 现在，打开之前配方中构建的解决方案。

3. 解决方案资源管理器应该看起来像这样：

1. 现在，让我们选择解决方案名称并右键单击。

2. 从菜单中选择添加 | 新项目。

3. 在新项目对话框中，展开 Visual C# 节点，并在左侧窗格中选择 Windows Classic Desktop。

4. 在右侧窗格中，选择 Windows Forms App (.NET Framework)：

1. 现在，在名称：文本框中，键入 Chapter3.SecureFile.SecureWinApp，保留位置：文本框的当前内容，并点击确定。

1. 现在，解决方案资源管理器应该看起来像这样：

1. 让我们将 Form1.cs 重命名为 MainForm.cs，通过选中它并按 F2 键。

2. 在确认框中回答是，以确认更改主类名。

3. 现在从设计窗口中选择 Windows 窗体。

4. 在窗体中拖放两个按钮。

5. 同时将一个 OpenFileDialogBox 控件拖放到 Windows 窗体中。

6. 根据以下表格更改先前控件属性：

   控件	属性	值
   按钮	名称	EncryptButton
   按钮	文本	加密
   按钮	名称	DecryptButton
   按钮	文本	解密
   打开文件对话框框	名称	OpenDialog
   打开文件对话框框	过滤器	文本文件|*.txt

7. 现在，您的设计区域应该看起来像这样：

1. 现在从解决方案资源管理器中选择 Chapter3.SecureFile.SecureWinApp 标签，并展开它。

2. 右键单击引用标签，并选择添加引用。

3. 在引用管理器对话框中点击项目节点。

4. 从右侧窗格的项目列表中，勾选 Chapter3.SecureFile.CryptLib 标签前面的复选框。

1. 点击确定。

2. 现在切换回设计窗口，双击加密按钮以打开代码窗口。

3. 在代码窗口中，向上滚动到顶部，并将以下 using 指令作为 using 块的最后一行添加：

      using Chapter3.SecureFile.CryptLib;

1. 现在向下滚动到加密按钮，点击，并在大括号之间添加以下代码：

      if (OpenDialog.ShowDialog() == DialogResult.OK)
      {
          var textFileName = OpenDialog.FileName;
          var secureFile = new CryptFile(textFileName);

          secureFile.EncryptFile();

          MessageBox.Show("File encrypted", "Information", 
              MessageBoxButtons.OK,     
              MessageBoxIcon.Information);
      }

1. 现在通过点击 MainForm.cs [设计器] 选项卡，切换回设计窗口。

2. 双击解密按钮，进入该按钮点击事件的代码。

3. 在按钮点击代码的大括号之间添加以下代码：

      if (OpenDialog.ShowDialog() == DialogResult.OK)
      {

          var textFileName = OpenDialog.FileName;
          var secureFile = new CryptFile(textFileName);

          secureFile.DecryptFile();

          MessageBox.Show("File decrypted", "Information", 
              MessageBoxButtons.OK,
              MessageBoxIcon.Information);
      }

1. 现在按 F5 执行代码（确保经典 Windows 应用程序项目是默认项目）

2. 点击加密按钮并选择一个文件：

1. 点击打开，并在信息框中点击确定。

2. 现在打开 Windows 资源管理器，导航到您刚刚加密的文件位置。

3. 您会注意到文件上有一个锁。

1. 现在切换回您的应用程序，点击解密按钮，并按照之前的步骤进行。

2. 现在文件上的锁已被移除。

它是如何工作的...

在步骤 1 到 4 中，我们打开了包含我们在上一个菜谱中构建的库的现有解决方案。在步骤 5 到 9 中，我们将一个经典的 Windows 项目添加到解决方案中。我们为项目分配了适当的名称以保持一致性和可读性。在步骤 10 到 15 中，我们更改了 Windows 窗体的名称，并向窗体添加了必要的控件。最后，我们更改了这些控件的属性。

在步骤 18 到 21 中，我们添加了对包含库的项目引用。这是一个强制性的步骤，否则我们无法从我们的 Windows 应用程序中访问库功能。现在，在步骤 23 中，我们从代码级别添加了对库项目的引用。这一步骤将允许您从代码级别访问所有可用的方法。在步骤 24 中，我们使用了一个if语句来打开文件打开对话框，并检查是否点击了打开按钮。在接下来的代码行中，我们创建了一个CryptFile类的实例，并使用带有路径的文件名作为其参数。最后，我们使用EncryptFile()方法开始加密，并使用MessageBox.Show()向用户显示信息。同样，在步骤 25 中，我们使用了应用程序的解密按钮来使用CryptFile类的另一个DecryptFile()方法。

最后，在步骤 28 到 31 中，我们执行了我们的应用程序并对其进行了测试。在步骤 32 和 34 中，我们确认了加密和解密功能正常工作。

第四章：函数式编程

在本章中，我们将探讨以下菜谱：

• 创建 .NET Standard 2.0 库

• 创建一个用于库的 .NET Core console 应用程序

• 创建一个使用元组的 .NET Standard 2.0 库

• 创建一个用于库的 Razor Pages 网络应用程序

• 创建一个使用代理和 lambda 表达式的 .NET Standard 2.0 库

• 创建一个用于库的 .NET console 应用程序

技术要求

读者应具备 C# 的基本知识。他们还应具备使用 Visual Studio、使用 NuGet 安装包以及在其他项目中引用库的基本知识。

本章的代码文件可以在 GitHub 上找到：

github.com/PacktPublishing/DotNET-Standard-2-Cookbook/tree/master/Chapter04

查看以下视频，以查看代码的实际运行情况：

goo.gl/yeUdkd

简介

本章讨论了 C# 的函数式编程功能以及如何为 .NET Standard 2.0 库使用它们。让我们看看函数式编程的定义：

"函数式编程是一种将计算视为数学函数的评估，并避免改变状态和可变数据的风格。"

简而言之，这意味着你将能够将函数用作其他函数的输入和输出。你还可以将它们分配给变量并将它们存储在集合中。看看以下代码，它解释了我们刚才讨论的内容：

Func<int, int> addNumbers = n => n + 1;
var answer = addNumbers(1);

answer // 2

var range = Enumerable.Range(1, 5);
var answers = range.Select(addNumbers);
answers // 2, 3, 4, 5, 6

再次，当我们遵循函数范式时，我们必须避免状态突变。这意味着当一个对象被创建时，它永远不会改变；变量不应被重新分配。函数式编程已经存在了一段时间，C# 对其支持得很好。尽管如此，如果你正在考虑函数式编程，F# 也是一个不错的选择。

创建 .NET Standard 2.0 库

在这个菜谱中，我们将探讨在 .NET Standard 2.0 库中使用 C# 进行函数式编程的基础。

准备工作

让我们做好准备并打开 Visual Studio 2017。你还应该检查它是否已更新到最新版本。

如何做这件事...

1. 打开 Visual Studio 2017。

2. 点击“文件”|“新建”|“项目”来创建一个项目。

3. 在“新建项目”对话框中，在左侧窗格中展开“其他项目类型”节点并选择“Visual Studio 解决方案”。在右侧窗格中，选择“空白解决方案”。

4. 在“名称：”文本框中，键入 Chapter4.Functions，并在“位置：”文本框中，从下拉框中选择一个路径或点击“浏览...”按钮来定位路径：

1. 点击“确定”。

2. 现在，你的解决方案资源管理器 (Ctrl + Alt + L) 应该看起来像这样：

1. 现在，在解决方案资源管理器中的 Chapter4.Functions 标签上右键单击，然后选择“添加”|“新建项目”。

2. 在“新建项目”对话框中，展开“Visual C#”节点。

3. 在左侧窗格中选择.NET Standard，在右侧窗格中选择类库 (.NET Standard)：

1. 现在，在名称：文本框中，输入Chapter4.Functions.FuncLib。保留其他默认设置，然后点击确定：

1. 现在，解决方案资源管理器（Ctrl + Alt + L）应该看起来像这样：

1. 现在，在解决方案资源管理器中选择Class1.cs，然后按F2重命名文件为Helper.cs。

2. 在询问是否重命名类名的确认对话框中回答“是”。

3. 现在，在解决方案资源管理器中双击Helper.cs标签。

4. 在Helper.cs的代码窗口中，在类的花括号内输入以下代码：

      public Func<int, int> AddOne = n => n + 1;

      public Func<int, bool> IsZero = n => n == 0;

1. 让我们按Ctrl + Shift + B进行快速构建，以检查语法是否正确。

它是如何工作的...

在步骤 1 到 5 中，我们添加了一个空白解决方案。这是我们在本菜谱和下一个菜谱中添加编码的基础。之后，我们在步骤 7 到 11 中添加了一个.NET Standard 2.0 库。在步骤 12 和 13 中，我们将模板生成的默认类重命名了。你总是可以删除这个默认类模板，并使用新名称向项目中添加一个新类。

在第 15 步中，我们向Helper类中添加了代码。在第一行，我们创建了一个函数，该函数接受一个整数作为输入并返回一个整数作为输出。在输出之前，我们给输入加上了 1。使用Func<>来创建函数。第一个int被视为输入，最后一个被视为输出。你可以添加很多参数，但最后一个总是被视为输出类型。例如：

Func<string, string, int>

前面的函数接受两个string输入并返回一个int作为输出。在第 15 步中，代码的第二行检查输入数字是否为零，并返回一个布尔值作为输出。如果数字为零，它总是返回true，否则返回false。

创建一个.NET Core 控制台应用程序以使用库

在这个菜谱中，我们将创建一个.NET Core 2.0 控制台应用程序来使用我们在上一个菜谱中构建的库。

准备工作

确保你已经完成了上一个菜谱中构建的.NET Standard 2.0 库。如果你已经完成了，找到它，并使用 Visual Studio 2017 打开它。使用Ctrl + Shift + B进行快速构建以检查语法。

如何操作...

1. 打开 Visual Studio 2017。

2. 现在，打开我们之前构建的解决方案。

3. 解决方案资源管理器应该看起来像这样：

1. 按Ctrl + Shift + B进行快速构建以检查语法。

2. 现在，让我们选择解决方案名称并右键单击。

3. 从菜单中选择添加 | 新项目。

4. 在新建项目对话框中，展开 Visual C#节点，并在左侧窗格中选择.NET Core。

5. 在右侧窗格中，选择控制台应用程序 (.NET Core):

1. 在名称：文本框中，键入Chapter4.Functions.CoreConsoleApp并保留默认值：

1. 现在，解决方案资源管理器应该看起来像这样：

1. 现在，在解决方案资源管理器中，选择Chapter4.Functions.CoreConsoleApp标签。

2. 右键单击依赖项标签并选择添加引用。

3. 在参考管理器对话框中，在左侧窗格中，选择项目。

4. 在右侧窗格中，检查列表中的Chapter4.Functions.Funclib：

1. 点击确定。

2. 现在，双击Program.cs标签以打开代码窗口。

3. 在代码窗口中，向上滚动直到看到using指令。

4. 在所有using指令的末尾添加以下using指令：

      using System.Linq;
      using Chapter4.Functions.FuncLib;

1. 现在，向下滚动到主方法，将模板生成的默认代码替换为以下内容：

      var helper = new Helper();

      Console.WriteLine(helper.AddOne(5));

      int[] numbers = new int[] { 1, 0, 10, 0, 5, 0 };
      Console.WriteLine($"We have found {numbers.Count(helper.IsZero)} 
          zeros.");

      Console.ReadLine();

1. 现在，确保Chapter4.Functions.CoreConsoleApp项目设置为启动项目，然后按F5执行。

2. 你应该看到如下输出：

它是如何工作的...

在步骤 1 到 5 中，我们打开了之前构建.NET Standard 2.0 库的食谱中的解决方案。然后，我们进行了快速构建以检查语法错误。这是一个非常好的实践；在我们进一步之前，检查之前构建的代码的语法。然后，在步骤 6 到 10 中，我们将.NET Core 2.0 控制台应用程序添加到项目中。在步骤 12 到 14 中，我们将构建的库作为依赖项添加到.NET Core 2.0 控制台应用程序中。

你必须添加此引用才能在控制台应用程序中使用库的功能。然后，我们在第 18 步中添加了两个using语句。第一个将允许你在代码中使用 LINQ 功能，第二个将允许你使用库中可用的方法。

然后，在第 19 步中，我们添加了使用库中方法的代码。在第一行，我们创建了一个Helper类的实例并将其存储在一个变量中。然后，我们使用了AddOne函数并将输出写入控制台。在第三行，我们创建了一个整数数组并存储了一些数字。最后，我们使用了 LINQ 中可用的 count 函数来使用我们创建的函数。count 函数将遍历数组中的每个数字，将其传递给我们的IsZero函数，并返回输出。

最后，在第 21 步中，我们执行了应用程序以查看输出。

创建一个使用元组的.NET Standard 2.0 库

在这个食谱中，我们将使用 C#元组与我们的库。元组允许你在单个语句中将多个不同类型的变量赋值组合在一起。例如，你可以在一行代码中这样做：

(string firstName, string lastName, int yearsOfExperience) = ("Fiqri", "Ismail", 15);

让我们看看如何在.NET Standard 2.0 库中使用元组。

准备工作

让我们启动 Visual Studio 2017 并确保它已更新到最新版本。我们完成此食谱需要 C# 7.0。

如何操作...

1. 打开 Visual Studio 2017。

2. 点击文件 | 新 | 项目以创建一个项目。

3. 在新项目对话框中，展开左侧窗格中的其他项目类型节点，并选择 Visual Studio 解决方案。在右侧窗格中，选择空白解决方案****。

4. 在名称：文本框中，键入 Chapter4.Tuples，并在位置：文本框中，从下拉框中选择路径或点击浏览...按钮定位路径：

1. 点击确定。

2. 现在，您的解决方案资源管理器 (Ctrl + Alt + L) 应该看起来像这样：

1. 现在，在解决方案资源管理器中右键单击 Chapter4.Tuples 标签，并选择添加 | 新项目****。

2. 在新项目对话框中，展开左侧窗格中的 Visual C# 节点。

3. 在左侧窗格中选择 .NET Standard，在右侧窗格中选择类库 (.NET Standard)：

1. 现在，在名称：文本框中，键入 Chapter4.Tuples.TupleLib，保留其他默认设置，然后点击确定：

1. 现在，解决方案资源管理器 (Ctrl + Alt + L) 应该看起来像这样：

1. 现在，在解决方案资源管理器中选择 Class1.cs 并按 F2 重命名文件为 Employee.cs。

2. 在询问是否重命名类名的确认对话框中回答是。

3. 现在，在解决方案资源管理器中双击 Employee.cs 标签。

4. 在代码窗口中，在 Employee 类的大括号内添加以下代码：

      public (string, string, int) GetBasicDetails()
      {

          string firstName = "Fiqri";
          string lastName = "Ismail";
          int experience = 15;

          return (firstName, lastName, experience);
      }

1. 按 Ctrl + Shift + B 进行快速构建以检查语法。

工作原理...

我们在步骤 1 到 5 中创建了一个空白解决方案，并为其指定了合适的名称。在步骤 6 到 10 中，我们将一个新项目添加到解决方案中。我们选择 .NET Standard 2.0 库模板作为项目的起点，并给它指定了合适的名称。在步骤 11 和 12 中，我们将默认的 Class1.cs 重命名为更有意义的东西。这个类是由模板本身生成的。您可以重命名它，或者您可以删除该文件并添加一个新的文件。

在步骤 15 中，我们创建了一个返回两种字符串类型和一个整型类型的方法。这是由于元组的存在才成为可能。在那个方法中，我们分配了变量，并按顺序返回它们以匹配方法的返回类型。最后，我们进行了快速构建以确认语法正确。

创建一个用于使用库的 Razor Pages 网络应用程序

在本食谱中，我们将构建一个 Razor Pages 网络应用程序来使用上一食谱中创建的 .NET Standard 2.0 库。Razor Pages 网络应用程序是 MVC 框架的一个更精简版本。您可以知道它是老式 .aspx 网络表单页面的继任者。这是在 .NET Core 2.0 之后的一个补充。

准备工作

确保您已安装最新版本的 Visual Studio 2017 和.NET Core 2.0，并且您有权访问我们之前菜谱中构建的解决方案。进行快速Ctrl + Shift + B以检查一切是否完好无损且正常工作。

如何操作...

1. 打开 Visual Studio 2017。

2. 现在，打开我们之前菜谱中构建的解决方案。

3. 解决方案资源管理器应如下所示：

1. 按Ctrl + Shift + B进行快速构建以检查语法。

2. 现在，让我们选择解决方案名称并右键单击。

3. 从菜单中选择“添加 | 新建项目”。

4. 在“新建项目”对话框中，展开 Visual C#节点，并在左侧窗格中选择.NET Core。

5. 在右侧窗格中，选择 ASP.NET Core Web 应用程序：

1. 在“名称：”文本框中键入Chapter4.Tuples.CoreRazorWebApp并保持默认设置：

1. 点击“确定”。

2. 现在，在“新建 ASP.NET Core Web 应用程序”对话框中，从模板列表中选择 Web 应用程序（确保您已从下拉列表中选择.NET Core 和 ASP.NET Core 2.0）：

1. 保持默认设置并点击“确定”。

2. 现在，解决方案资源管理器应如下所示：

1. 现在，在解决方案资源管理器中选择Chapter4.Tuples.CoreRazorWebApp标签。

2. 右键单击“依赖项”标签并选择“添加引用”。

3. 在“引用管理器”对话框的左侧窗格中，选择“项目”。

4. 在右侧窗格中，在列表中检查Chapter4.Tuples.TupleLib：

1. 点击“确定”。

2. 现在，展开“页面”节点。

3. 右键单击“页面”标签，然后选择“添加 | Razor 页面”。

4. 在“添加模板”对话框中，从模板列表中选择 Razor 页面：

1. 点击“添加”。

2. 在“添加 Razor 页面”对话框中，在 Razor 页面名称：文本框中键入Employee：

1. 点击“添加”。

2. 默认情况下，Visual Studio 将向您展示Employee.chtml.cs文件。如果没有，您始终可以展开Employee.chtml文件的节点，然后双击Employee.chtml.cs标签。

3. 现在，向上滚动直到到达using指令。

4. 在using指令的末尾，添加对我们库的引用：

      using Chapter4.Tuples.TupleLib;

1. 现在，向下滚动直到到达OnGet()方法。

2. 在OnGet()方法的括号内添加以下代码：

      var employee = new Employee();

      (string FirstName, string LastName, int YearsOfExperience) 
          newEmployee = employee.GetBasicDetails();

      ViewData["FirstName"] = newEmployee.FirstName;
      ViewData["LastName"] = newEmployee.LastName;
      ViewData["YearsOfExperience "] = newEmployee.YearsOfExperience;

1. 现在，单击Employee.cshtml选项卡以进入 Razor 页面。

2. 在页面末尾添加以下代码：

      <p>
          <h2>@ViewData["FirstName"] @ViewData["LastName"]</h2> 
          <h3>(@ViewData["YearsOfExperience "] years of experience)
          </h3>
      </p>

1. 现在，保存您的作品。

2. 按F5执行应用程序。

3. 浏览器将显示默认的索引页面如下：

1. 点击地址栏。在 URL 的末尾键入Employee并按Enter键。（整个 URL 应如下所示：localhost:<yourportnumber>/Employee）：

1. 现在，关闭浏览器。

工作原理...

在步骤 1 到 5 中，我们打开了前一个菜谱中的解决方案。我们还执行了快速构建以检查语法。然后，在步骤 6 到 13 中，我们将 ASP.NET Core Web 应用程序添加到解决方案中。在步骤 14 到 16 中，我们将前一个菜谱中构建的库的引用添加到解决方案中。这将允许你在 ASP.NET Core Web 应用程序项目中使用库中的可用功能。

在步骤 20 到 24 中，我们向项目中添加了一个新的 Razor 页面。Razor 页面包含两个文件。一个是 .chtml 文件，它包含外观和感觉，另一个文件包含该 Razor 文件的代码。这与 ASP.NET Web Forms 应用程序中的 .aspx 页面及其代码隐藏文件类似。

在步骤 27 中，我们将引用代码添加到我们的库中。然后，在步骤 29 中，我们添加了使用库功能的代码。在代码的第一行中，我们创建了一个 Employee 类的实例并将其存储在一个变量中。然后，在第二行中，我们使用 GetBasicDetails() 方法通过元组访问员工详细信息。最后，我们将这些值存储在 ViewData 辅助类中。

在步骤 31 中，我们使用了 ViewData 辅助类来向用户显示值。在这个步骤中，我们使用了 HTML 标记和 Razor 语法来显示信息。最后，在步骤 33 到 36 中，我们执行了应用程序并在默认浏览器中进行了测试。

创建一个使用委托和 lambda 表达式的 .NET Standard 2.0 库

在这个菜谱中，我们将使用 C# 中可用的另一个功能。这些被称为委托和 lambda 表达式。C# 中的委托是什么？根据微软文档，它说：

"委托是一种表示具有特定参数列表和返回类型的方法引用的类型。"

简而言之，委托用于将方法作为参数传递给其他方法，而 lambda 表达式是一个匿名函数，你可以用它来创建委托或表达式树类型。

准备工作

确保已安装并更新到最新版本的 Visual Studio 2017。

如何操作...

1. 打开 Visual Studio 2017。

2. 点击文件 | 新建 | 项目以创建一个项目。

3. 在“新建项目”对话框中，展开左侧窗格中的“其他项目类型”节点，并选择 Visual Studio 解决方案。在右侧窗格中，选择空白解决方案。

4. 在“名称”文本框中，键入 Chapter4.Delegates，并在“位置”文本框中，从下拉框中选择一个路径或点击浏览...按钮定位路径：

1. 点击确定。

2. 现在，你的解决方案资源管理器 (Ctrl + Alt + L) 应该看起来像这样：

1. 现在，在解决方案资源管理器中的 Chapter4.Delegates 标签上右键单击，并选择添加 | 新项目。

2. 在“新建项目”对话框中，展开 Visual C# 节点。

3. 在左侧窗格中选择.NET Standard，在右侧窗格中选择类库 (.NET Standard)：

1. 现在，在“名称：”文本框中，键入Chapter4.Delegates.DelegateLib。保留其他默认设置，然后点击“确定”：

1. 现在，解决方案资源管理器 (Ctrl + Alt + L) 应该看起来像这样：

1. 现在，在解决方案资源管理器中选择Class1.cs，并按F2重命名文件为Calculator.cs。

2. 在询问是否重命名类名的确认对话框中回答“是”。

3. 现在，选择Calculators.cs标签，双击它以打开代码窗口。

4. 将以下using指令添加到代码顶部：

      using System.Linq;

1. 现在，在Calculator类的花括号之间向下滚动，并添加以下代码：

      public delegate string Message(string msg);
      public string AddTwoNumbers(int n1, int n2, Message msg)
      {
          return msg($"The answer is : {n1 + n2}");
      }

1. 现在，在AddTwoNumbers()方法的末尾花括号旁边添加以下代码：

      public string CountScoresMoreThan80(int[] scores)
      {
          var count = scores.Where(s => s > 80).Count();

          return $"There are {count} scores more than 80";
      }

1. 通过按Ctrl + Shift + B进行快速构建，并确认所有语法都正确。

它是如何工作的...

我们在步骤 1 到 5 中创建了一个空白解决方案。在步骤 7 到 10 中，我们将.NET Standard 2.0 类库项目添加到解决方案中。在这些步骤中，我们为项目赋予了有意义的名称。我们在步骤 12 和 13 中重命名了模板生成的默认类名。我们在步骤 14 中添加了 LINQ 的using语句。这是必要的，以便解释使用 LINQ 的 lambda 表达式。

在步骤 16 中，我们添加了代码来创建一个委托和一个方法，以便将委托作为参数使用。委托Message接受一个string类型的参数，并返回一个string类型的输出。然后，我们添加了一个方法来添加两个数字，并以消息的形式返回答案作为字符串。正如你所看到的，AddTwoNumbers()方法有三个参数。前两个是整数，最后一个参数是我们创建的委托。

在步骤 17 中，我们创建了一个新方法来计算整数数组中数字的出现次数。在CountScoresMoreThan80()方法的第 1 行，我们使用了 LINQ 提供的Where()方法。在Where()方法内部，我们使用 lambda 表达式检查大于80的数字。然后，我们使用Count()方法来计算通过Where()方法过滤后的出现次数，并将答案作为string返回。

最后，我们执行了快速构建以确认语法正确。

创建一个.NET 控制台应用程序以使用库

在这个菜谱中，我们将构建一个基于.NET 控制台的应用程序来测试我们的库。我们将使用完整的.NET Framework，它仅适用于 Windows。

准备工作

确保你已经找到了之前菜谱中构建的解决方案，并且快速执行了Ctrl + Shift + B来构建解决方案。我们现在已经准备好测试库，让我们开始吧。

如何做到这一点...

1. 打开 Visual Studio 2017。

2. 现在，打开之前菜谱中构建的解决方案。

3. 解决方案资源管理器应该看起来像这样：

1. 按 Ctrl + Shift + B 快速构建以检查语法。

2. 现在，让我们选择解决方案名称并右键单击。

3. 从菜单中选择“添加 | 新项目”。

4. 在“新建项目”对话框中，展开“Visual C#”节点，并在左侧窗格中选择“Windows Classic Desktop”。

5. 在右侧窗格中，选择“控制台应用程序 (.NET Framework)”。

1. 在“名称：”文本框中，键入Chapter4.Delegates.ConsoleApp并保留默认设置：

1. 现在，解决方案资源管理器应该看起来像这样：

1. 现在，在“解决方案资源管理器”中，选择Chapter4.Delegates.ConsoleApp标签。

2. 右键单击“引用”标签并选择“添加引用”。

3. 在“引用管理器”对话框中，在左侧窗格中，选择“项目”。

4. 在右侧窗格中，检查列表中的Chapter4.Delegates.DelegateLib。

1. 点击“确定”。

2. 现在，双击Program.cs标签以打开代码窗口。

3. 在代码窗口中，向上滚动直到看到using指令。

4. 在所有using指令的末尾添加以下using指令：

      using Chapter4.Delegates.DelegateLib;

1. 现在，在Main()方法的末尾花括号旁边，添加以下代码：

      static string DelegateMessage(string msg)
      {
          return msg;
      }

1. 现在，向下滚动到Main()方法，并在Main()方法的括号之间添加以下代码：

      var calculator = new Calculator();

      Calculator.Message message = DelegateMessage;
      Console.WriteLine(calculator.AddTwoNumbers(10, 20, message));

      int[] scores = new int[] { 10, 90, 50, 85, 30, 100, 45, 60 };
      Console.WriteLine(calculator.CountScoresMoreThan80(scores));

      Console.ReadLine();

1. 让我们按 F5 执行程序。

2. 你应该看到类似以下输出：

1. 按下 Enter 键关闭控制台窗口。

它是如何工作的...

在步骤 1 到 5 中，我们从上一个菜谱中打开了解决方案并进行了快速构建。这将确保代码语法正确。如果构建失败，你可能需要检查任何拼写错误并更正它们。在关闭解决方案或将其发送到源代码控制之前确保代码成功构建总是一个好习惯。在步骤 6 到 10 中，我们在解决方案中添加了一个新项目。我们选择了控制台应用程序模板，该模板在 Windows 下支持完整的.NET Framework。

然后，在步骤 12 到 15 中，我们将.NET Standard 2.0 库的引用添加到我们的控制台应用程序中。这将允许你访问库中所有可用的功能。在步骤 18 中，我们添加了对库的引用。我们使用了using语句。然后，在步骤 19 中，我们添加了一个用于库中委托的方法。

在步骤 20 中，第一行我们创建了一个 Calculator 类的实例并将其存储在一个变量中，然后，在第二行中，我们在类内部使用了代理，并将其从步骤 19 中创建的方法中赋值。接着，我们使用AddTwoNumbers()方法，传入两个整数值和代理变量作为参数，并将输出打印到控制台窗口。在第四行，我们创建了一个整数数组，存储了一些值，使用CountScoresMoreThan80()方法，将整数数组作为参数传递，并将输出打印到控制台。

最后，在步骤 21 和 22 中，我们执行了代码并检查了输出结果。

第五章：XML 和数据

在本章中，我们将探讨以下食谱：

• 创建一个读取和写入 XML 文件的库

• 创建一个用于使用 XMLLib 库的 ASP.NET MVC 应用程序

• 使用 LINQ to XML 处理 XML 文件

• 创建一个用于使用库的.NET Core 控制台应用程序

技术要求

读者应具备基本的 C#知识。他们还应具备使用 Visual Studio、使用 NuGet 安装包以及在其他项目中引用库的基本知识。

本章的代码文件可以在 GitHub 上找到：

github.com/PacktPublishing/DotNET-Standard-2-Cookbook/tree/master/Chapter05

查看以下视频以查看代码的实际操作：

goo.gl/uQTMeB

简介

XML 代表可扩展标记语言，类似于 HTML。XML 用于存储和读取数据。主要来说，XML 是一个数据存储系统，也用于传输数据。C#使用System.XML命名空间在语言内部支持 XML。您将能够使用此命名空间读取、写入和解析 XML 数据。有了 LINQ 的支持，处理基于 XML 的数据变得更加容易。

创建一个读取和写入 XML 文件的库

在这个食谱中，我们将使用.NET Standard 2.0 库来创建和写入 XML 文件。我们还将使用相同的库将数据写入 XML 文件。

准备工作

让我们启动 Visual Studio 2017 并完成任务。请确保您已安装 Visual Studio 2017 的最新版本。

如何操作...

1. 打开 Visual Studio 2017。

2. 点击“文件”|“新建”|“项目”以创建项目。

3. 在“新建项目”对话框中，展开左侧窗格中的“其他项目类型”节点，并选择“Visual Studio 解决方案”。在右侧窗格中，选择“空白解决方案”。

4. 在“名称：”文本框中，键入Chapter5.XmlDoc，并在“位置：”文本框中，从下拉框中选择路径或点击“浏览...”按钮定位路径：

1. 点击“确定”。

2. 现在，解决方案资源管理器（Ctrl + Alt + L）应该看起来像这样：

1. 现在，在解决方案资源管理器中的Chapter5.XmlDoc标签上右键单击，然后选择“添加”|“新建项目”。

2. 在“新建项目”对话框中，展开“Visual C#”节点。

3. 在左侧窗格中选择.NET Standard，在右侧窗格中选择类库(.NET Standard)：

1. 现在，在“名称：”文本框中，键入Chapter5.XmlDoc.XmlLib，保留其他默认设置，然后点击“确定”：

1. 现在，解决方案资源管理器（Ctrl + Alt + L）应该看起来像这样：

1. 现在，在解决方案资源管理器中选择Class1.cs，然后按F2键重命名文件为XMLLog.cs。

2. 在确认对话框中回答“是”，以将类名也重命名。

3. 现在，在解决方案资源管理器中双击XMLLog.cs标签。

4. 向上滚动，直到到达using指令，并在最后一个using指令的末尾添加以下内容：

        using System.Xml;
        using System.IO;
        using System.Xml.Linq;
        using System.Collections.Generic;
        using System.Linq;

1. 现在，向下滚动并在XMLLog类上方添加以下类变量：

        private string _xmlFile;

1. 让我们为XMLLog类添加构造函数：

        public XMLLog(string xmlFile)
        {
          _xmlFile = xmlFile;
        }

1. 在类的构造函数之后添加以下公共方法：

        public void WriteToLog(string message)
        {

          if (!File.Exists(_xmlFile))
          {
            using (XmlWriter xmlWriter = XmlWriter.Create(_xmlFile))
            {
              xmlWriter.WriteStartDocument();
              xmlWriter.WriteStartElement("Log");
              xmlWriter.WriteStartElement("LogEntry");
              xmlWriter.WriteElementString("LogDate", DateTime.Now.ToString());
              xmlWriter.WriteElementString("Message", message);
              xmlWriter.WriteEndElement();
              xmlWriter.WriteEndElement();
              xmlWriter.WriteEndDocument();

              xmlWriter.Flush();
              xmlWriter.Close();
            }
          }
          else
          {
            XDocument xDoc = XDocument.Load(_xmlFile);
            XElement root = xDoc.Element("Log");
            IEnumerable<XElement> rows = root.Descendants("LogEntry");

            XElement lastRow = rows.Last();
            lastRow.AddAfterSelf(
              new XElement("LogEntry",
              new XElement("LogDate", DateTime.Now.ToString()),
              new XElement("Message", message)));

            xDoc.Save(_xmlFile);
          }
        }

1. 现在，在WriteToLog()方法旁边添加以下代码：

        public Dictionary<string, string> ReadLog()
        {

          var xmlOutPut = new Dictionary<string, string>();
          var line = 0;

          if (File.Exists(_xmlFile))
          {
            using (XmlReader xmlReader = XmlReader.Create(_xmlFile))
            {
              while(xmlReader.Read())
              {

                if (xmlReader.IsStartElement())
                {

                  switch (xmlReader.Name)
                  {
                    case "LogDate":
                      xmlOutPut.Add($"LogDate - {line}", xmlReader.ReadElementContentAsString());
                      break;
                    case "Message":
                      xmlOutPut.Add($"Message - {line}", xmlReader.ReadElementContentAsString());
                      break;    
                  }
                }
                line++;
              }
            }

            return xmlOutPut;
          }
        }

1. 让我们按Ctrl + Shift + B进行快速构建。

它是如何工作的...

在步骤 1 到 5 中，我们创建了一个空白解决方案，并为解决方案赋予了合适的名称。然后，在步骤 6 到 10 中，我们将一个.NET Standard 2.0 库项目添加到解决方案中。在步骤 11、12 和 13 中，我们将 Visual Studio 生成的默认类模板重命名。

在步骤 15 中，我们为我们的库添加了所有必需的命名空间。System.Xml和System.Xml.Linq是我们将要关注的两个命名空间。System.Xml提供了创建和维护 XML 文档的功能。System.Xml.Linq是 LINQ 的扩展，用于操作 XML 数据。

在步骤 16 中，我们创建了一个类级别的私有变量来存储 XML 文件的路径。在步骤 17 中，我们为类创建了一个构造函数，该构造函数接受一个字符串参数。该参数是带有 XML 文件路径的文件名。它还填充了步骤 16 中创建的私有变量。在步骤 18 中，我们添加了一个公共方法来写入 XML 文件。

在代码的第一行，我们检查 XML 文件是否存在。如果它不存在，以下代码块将接管：

using (XmlWriter xmlWriter = XmlWriter.Create(_xmlFile))
{
    xmlWriter.WriteStartDocument();
    xmlWriter.WriteStartElement("Log");
    xmlWriter.WriteStartElement("LogEntry");
    xmlWriter.WriteElementString("LogDate", DateTime.Now.ToString());
    xmlWriter.WriteElementString("Message", message);
    xmlWriter.WriteEndElement();
    xmlWriter.WriteEndElement();
    xmlWriter.WriteEndDocument();

    xmlWriter.Flush();
    xmlWriter.Close();
}

我们使用了XmlWriter类及其Create方法来创建 XML 文件。在这种情况下，它被包含在一个using关键字中。如果类实现了IDisposable接口，并且其生命周期限制在方法内，这是一个好的实践。using语句以正确的方式调用对象的Dispose方法，并且一旦调用Dispose，对象本身就会超出作用域。最后，XmlWriter类的Flush()方法将清除缓冲区，而Close()方法将关闭写入流。

在接下来的几行代码中，我们开始编写文档，并最终澄清了问题并关闭了XmlWriter。如果文件存在，我们编写了一些代码来处理现有的 XML 文档并将其数据附加到它上。代码如下：

XDocument xDoc = XDocument.Load(_xmlFile);
XElement root = xDoc.Element("Log");
IEnumerable<XElement> rows = root.Descendants("LogEntry");

XElement lastRow = rows.Last();
lastRow.AddAfterSelf(
    new XElement("LogEntry",
        new XElement("LogDate", DateTime.Now.ToString()),
            new XElement("Message", message)));

xDoc.Save(_xmlFile);

在这段代码中，我们创建了一个XDocument类来处理现有的 XML 文件。这个类是从System.Xml.Linq命名空间引用的。在第一行，我们加载了现有的 XML 文件。在第二行，我们查找文档的根元素。我们从根元素的子元素中选取所有后代，并从该列表中选取最后一个元素。这就是我们将添加新数据的位置。我们使用了AddAfterSelf()方法将新条目添加到 XML 文档中，并最终保存了文档。

在第 19 步中，我们创建了一个读取现有 XML 文档的方法。在第一行，我们创建了一个字典来存储我们从 XML 文档中读取的数据。然后，我们检查文件是否存在以进行读取，并创建了读取文件的代码。这次我们使用了 XmlReader() 类来读取数据并将其存储在字典中：

while(xmlReader.Read())
{
    if (xmlReader.IsStartElement())
    {

        switch (xmlReader.Name)
        {
            case "LogDate":
                xmlOutPut.Add($"LogDate - {line}", xmlReader.ReadElementContentAsString());
                break;
            case "Message":
                xmlOutPut.Add($"Message - {line}", xmlReader.ReadElementContentAsString());
                break;    
        }
     }
     line++;
 }

我们使用了一个 while 循环来遍历 XML 文档的每一行，并使用 switch 语句来检查正确的元素并将其存储在字典中。如您所见，通过使用 counter (line) 变量，我们还为字典创建了一个唯一的键。最后，我们返回了已填充的字典。在第 20 步中，我们执行了快速构建以检查语法是否正确。

创建一个用于使用 XMLLib 库的 ASP.NET MVC 应用程序

在这个配方中，我们将创建一个 ASP.NET MVC 应用程序来使用这个库。这次，它将在 Windows 下运行，并将在 Windows 下使用完整的 .NET Framework。

准备工作

确保我们已经完成了之前的配方。在那个配方中，我们构建了一个 .NET Standard 2.0 库来创建和读取 XML 文档。现在让我们创建一个 ASP.NET MVC 应用程序来使用这个库。

如何操作...

1. 打开 Visual Studio 2017。

2. 现在，打开上一个配方中的解决方案。点击 文件 | 打开 | 打开项目/解决方案，或按 Ctrl + Shift + O，然后选择 Chapter5.XmlDoc 解决方案。

3. 按 Ctrl + Shift + B 进行快速构建以检查一切是否正常。

4. 现在，单击 Chapter5.XmlDoc 解决方案标签。点击 文件 | 添加 | 新项目。

5. 在“添加新项目”模板对话框中，展开左侧窗格中的 Visual C# 节点。

6. 选择 Web，然后在右侧窗格中选择 ASP.NET Web 应用程序（.NET Framework）：

1. 现在，在“名称：”文本框中，键入 Chapter5.XmlDoc.XmlMVC 作为名称，并将“位置：”文本框保留在默认值：

1. 在“新建 ASP.NET 网络应用程序”对话框中，从模板列表中选择空模板。

2. 在“添加文件夹和核心引用”选项中，选择 MVC。

1. 其余保持不变，点击确定以创建默认的 ASP.NET MVC 网络应用程序模板。

2. 现在，解决方案资源管理器应该看起来像这样：

1. 现在，在 Chapter5.XmlDoc.XmlMVC 项目下的引用标签上右键单击，并选择添加引用。

2. 在“引用管理器”对话框中，在左侧窗格中选择项目，然后在右侧窗格中选择 Chapter5.XmlDoc.XmLib：

1. 点击确定。

2. 现在，在 Chapter5.XmlDoc.XmlMVC 项目中的 Controllers 文件夹上右键单击。

3. 选择 添加 | 控制器。

4. 在“添加模板”对话框中，从模板列表中选择 MVC 5 控制器 – 空模板，然后点击添加：

1. 现在，在添加控制器对话框中，在控制器名称：文本框中键入HomeController：

1. 点击添加。

2. 现在双击Controllers文件夹下的HomeController.cs标签。

3. 在代码窗口中，右键单击Index()方法名称并选择添加视图。

4. 在添加视图对话框中保留默认设置并点击添加：

1. 点击代码窗口中的HomeController.cs标签页。

2. 将此using指令添加到代码的顶部，紧邻指令的最后一行：

        using Chapter5.XmlDoc.XmlLib;

1. 现在，让我们将此代码添加到Index()方法中，并在return语句之前：

        var xmlFile = $"{Server.MapPath("~")}/testlog.xml";

        var xmlLog = new XMLLog(xmlFile);
        xmlLog.WriteToLog("Start at the Index() method");
        xmlLog.WriteToLog("Another log entry here");
        xmlLog.WriteToLog("Before the return statement");

1. 按F5测试我们的代码，你应该得到如下输出：

1. 现在关闭浏览器，然后在解决方案资源管理器中点击显示所有文件图标：

1. 现在，你应该看到创建了textlog.xml标签，解决方案资源管理器应该看起来像这样：

1. 点击testlog.xml标签，你应该看到类似的输出：

1. 现在，让我们点击HomeController.cs标签页，并在Index()方法旁边添加此代码：

        public ActionResult Display()
        {

            var xmlFile = $"{Server.MapPath("~")}/testlog.xml";
            var xmlLog = new XMLLog(xmlFile);

            ViewBag.LogDetails = xmlLog.ReadLog();

            return View();
        }

1. 现在，右键单击Display()方法名称并选择添加视图。

2. 按照步骤 22 添加视图。

3. 现在，在Display.cshtml中，在<h2>标签旁边添加以下代码：

        @{ 

            var xmlLogDetails = (Dictionary<string, string>)ViewBag.LogDetails;

            foreach (var log in xmlLogDetails)
            {
                <p>@log.Key.Split('-')[0]: @log.Value.Split('-')[0]</p>
            }
        }

1. 现在，让我们按F5来调试代码。默认情况下，这应该在浏览器中加载Display.chtml；如果不是，请输入http://locahost<portnumber>/Home/Display并按Enter。

2. 你应该看到类似的输出：

1. 现在，关闭你的浏览器，我们就完成了。

它是如何工作的...

在步骤 1 到 10 中，我们打开了一个包含用于读取和写入 XML 文件库的现有解决方案。然后，在这些步骤中，我们向该解决方案添加了一个 ASP.NET MVC 项目。在步骤 13 中，我们添加了对之前菜谱中构建的库的引用。这将允许你访问库中的可用方法。

在步骤 16 到 20 中，我们向项目中添加了一个控制器，并将其命名为HomeController。在步骤 24 中，我们添加了一个using指令来引用库。在步骤 25 中，我们编写了创建XMLLog类实例的代码，并在创建和写入 XML 文档的方法中使用它。在以下代码行中，我们提供了我们的 XML 文件的路径和名称：

var xmlFile = $"{Server.MapPath("~")}/testlog.xml";

Server.MapPath("~")确保文件被创建在我们的 Web 文件夹的根目录。在步骤 26 到 29 中，我们确认了我们的代码正在工作，并且 XML 文件已创建并包含日志条目。在步骤 30 中，我们为HomeController创建了一个新的操作。我们创建了一个XMLLog类的实例，并在方法中使用它来从日志文件中读取信息。然后我们将值存储在ViewBag中：

ViewBag.LogDetails = xmlLog.ReadLog();

在步骤 32 中，我们为Display操作创建了一个视图，就像我们在步骤 22 中所做的那样。然后在步骤 32 中为视图添加了代码，将ViewBag转换为字典并显示其内容。最后，我们在步骤 34 和 35 中测试了输出。

使用 LINQ to XML 处理 XML 文件

在本食谱中，我们将构建一个.NET Standard 2.0 库，该库使用 LINQ to XML 读取 XML 数据。LINQ to XML 是一个启用 LINQ 的内存编程接口。它允许你使用你喜欢的.NET 语言处理 XML。本书使用 C#来描述代码。在本食谱中，我们将主要查看使用 LINQ to XML 查询 XML 文档。我们在“A library that reads and writes to an XML file”食谱中使用了 LINQ to XML 来写入 XML 文件。

准备工作

本食谱假设你已经使用了 LINQ。我们专注于使用 XML 文档的 LINQ。让我们启动 Visual Studio 并开始吧。

如何操作...

1. 打开 Visual Studio 2017。

2. 点击文件 | 新建 | 项目以创建项目。

3. 在“新建项目”对话框中，展开左侧窗格中的“其他项目类型”节点，并选择 Visual Studio 解决方案。在右侧窗格中选择空白解决方案。

4. 在“名称”文本框中，输入Chapter5.XmlLinq，在“位置”文本框中，从下拉框中选择路径或点击浏览...按钮定位路径：

1. 点击确定。

2. 现在，解决方案资源管理器（Ctrl + Alt + L）应该看起来像这样：

1. 现在，在解决方案资源管理器中的Chapter5.XmlLinq标签上右键单击，并选择添加 | 新项目。

2. 在“新建项目”对话框中，展开 Visual C#节点。

3. 在左侧窗格中选择.NET Standard，在右侧窗格中选择类库(.NET Standard)：

1. 现在，在“名称”文本框中，输入Chapter5.XmlLinq.XmlLinqLib，保留其他默认设置，然后点击确定：

1. 现在，解决方案资源管理器（Ctrl + Alt + L）应该看起来像这样：

1. 现在，在解决方案资源管理器中选择Class1.cs，并按F2重命名文件为XmlBooks.cs。

2. 在询问是否重命名类名的确认对话框中回答“是”。

3. 现在，在解决方案资源管理器中双击XmlBooks.cs标签。

4. 在列表中的最后一个指令旁边添加以下using指令：

        using System.Collections.Generic;
        using System.Xml;
        using System.Xml.Linq;

1. 添加以下私有变量以存储 XML 文件名：

        private string _xmlFile;

1. 创建如下默认构造函数：

        public XmlBooks(string xmlFile)
        {
            _xmlFile = xmlFile;
        }

1. 现在添加以下方法来读取 XML 文件：

        public List<string> GetBookTitles()
        {

            var titles = new List<string>();
            XDocument xDoc = XDocument.Load(_xmlFile);

            var books = xDoc.Descendants("book"); 

            foreach (var book in books)
            {
                titles.Add(book.Element("title").Value);
            }

            return titles;
        }

1. 现在，让我们按Ctrl + Shift + B进行快速构建，以检查所有语法是否正确。

工作原理...

在步骤 1 到 10 中，我们将一个空白解决方案和一个 .NET Standard 2.0 类库添加到项目中。我们为我们的解决方案和类库项目分配了合适的名称。然后在步骤 15 中，我们添加了使用指令。这些指令帮助我们获取所需的泛型集合和 XML 的 LINQ 支持。

在步骤 16 中，我们添加了一个私有变量来存储 XML 文件名。然后在步骤 17 中，我们使用 XmlBooks 类的默认构造函数来创建填充此变量的代码。在步骤 18 中，我们创建了一个读取 XML 文件中包含的书籍标题的方法。此 XML 文件将在下一个食谱中创建。在代码中，我们使用了 XDocument 来加载 XML 文件，该文件由 System.Xml.Linq 命名空间支持。我们将后代存储在一个变量中，迭代每个元素，并将它们存储在一个 List<string> 泛型集合中。

最后，我们构建了代码以检查语法。

创建一个 .NET Core 控制台应用程序来使用该库

在本食谱中，我们将创建一个 .NET Core 控制台应用程序来使用上一食谱中创建的库。您可以在任何平台上尝试此食谱，例如 Linux 或 macOS，因为 .NET Core 是一个跨平台库。在本食谱中，我们将专注于 Windows。

准备工作

让我们通过查看之前构建的 .NET Standard 2.0 库来做好准备，该库用于读取 XML 文件。请确保您已经在项目中创建了此 XML 文件。我们将使用此文件进行读取。此示例来自 MSDN 库本身：

<?xml version="1.0"?>
<catalog>
   <book id="bk101">
      <author>Gambardella, Matthew</author>
      <title>XML Developer's Guide</title>
      <genre>Computer</genre>
      <price>44.95</price>
      <publish_date>2000-10-01</publish_date>
      <description>An in-depth look at creating applications 
      with XML.</description>
   </book>
   <book id="bk102">
      <author>Ralls, Kim</author>
      <title>Midnight Rain</title>
      <genre>Fantasy</genre>
      <price>5.95</price>
      <publish_date>2000-12-16</publish_date>
      <description>A former architect battles corporate zombies, 
      an evil sorceress, and her own childhood to become queen 
      of the world.</description>
   </book>
   <book id="bk103">
      <author>Corets, Eva</author>
      <title>Maeve Ascendant</title>
      <genre>Fantasy</genre>
      <price>5.95</price>
      <publish_date>2000-11-17</publish_date>
      <description>After the collapse of a nanotechnology 
      society in England, the young survivors lay the 
      foundation for a new society.</description>
   </book>
   <book id="bk104">
      <author>Corets, Eva</author>
      <title>Oberon's Legacy</title>
      <genre>Fantasy</genre>
      <price>5.95</price>
      <publish_date>2001-03-10</publish_date>
      <description>In post-apocalypse England, the mysterious 
      agent known only as Oberon helps to create a new life 
      for the inhabitants of London. Sequel to Maeve 
      Ascendant.</description>
   </book>
   <book id="bk105">
      <author>Corets, Eva</author>
      <title>The Sundered Grail</title>
      <genre>Fantasy</genre>
      <price>5.95</price>
      <publish_date>2001-09-10</publish_date>
      <description>The two daughters of Maeve, half-sisters, 
      battle one another for control of England. Sequel to 
      Oberon's Legacy.</description>
   </book>
</catalog>

如何操作...

1. 打开 Visual Studio 2017。

2. 现在，打开上一个食谱中的解决方案。点击 文件 | 打开 | 打开项目/解决方案，或按 Ctrl + Shift + O，然后选择 Chapter5.XmlLinq 解决方案。

3. 按 Ctrl + Shift + B 进行快速构建以检查一切是否正常。

4. 现在，单击 Chapter5.XmlLinq 解决方案标签。点击 文件 | 添加 | 新项目。

5. 在“添加新项目”模板对话框中，展开左侧窗格中的 Visual C# 节点。

6. 在右侧窗格中，选择 .NET Core 并选择 Console App (.NET Core):

1. 现在，在“名称：”文本框中，键入 Chapter5.XmlLinq.XmlCore 作为项目的名称。其余字段可以保持不变：

1. 点击确定。

2. 现在，解决方案资源管理器（按 Ctrl + Alt + L）应显示如下：

1. 在 Chapter5.XmlLinq.XmlCore 下的“依赖项”标签上右键单击。

2. 选择添加引用。

3. 在引用管理器中，单击右侧窗格中的“项目”标签：

1. 在左侧窗格中检查 Chapter5.XmlLinq.XmlLinqLib 项目。

2. 点击确定。

3. 现在，单击项目名称标签 Chapter5.XmlLinq.XmlCore 并选择添加 | 新项。

4. 在“添加新项”对话框中，在左侧窗格中，选择 Visual C# 项下的数据，在右侧窗格中选择 XML 文件：

1. 在名称：文本框中键入 books.xml 并点击添加。

2. 现在将现有代码替换为以下内容：

        <?xml version="1.0"?>
        <catalog>
          <book id="bk101">
              <author>Gambardella, Matthew</author>
              <title>XML Developer's Guide</title>
              <genre>Computer</genre>
              <price>44.95</price>
              <publish_date>2000-10-01</publish_date>
              <description>An in-depth look at creating applications 
              with XML.</description>
           </book>
           <book id="bk102">
              <author>Ralls, Kim</author>
              <title>Midnight Rain</title>
              <genre>Fantasy</genre>
              <price>5.95</price>
              <publish_date>2000-12-16</publish_date>
              <description>A former architect battles corporate zombies, 
               an evil sorceress, and her own childhood to become queen 
               of the world.</description>
           </book>
           <book id="bk103">
              <author>Corets, Eva</author>
              <title>Maeve Ascendant</title>
              <genre>Fantasy</genre>
              <price>5.95</price>
              <publish_date>2000-11-17</publish_date>
              <description>After the collapse of a nanotechnology 
              society in England, the young survivors lay the 
              foundation for a new society.</description>
           </book>
           <book id="bk104">
              <author>Corets, Eva</author>
              <title>Oberon's Legacy</title>
              <genre>Fantasy</genre>
              <price>5.95</price>
              <publish_date>2001-03-10</publish_date>
              <description>In post-apocalypse England, the mysterious 
              agent known only as Oberon helps to create a new life 
              for the inhabitants of London. Sequel to Maeve 
              Ascendant.</description>
           </book>
           <book id="bk105">
              <author>Corets, Eva</author>
              <title>The Sundered Grail</title>
              <genre>Fantasy</genre>
              <price>5.95</price>
              <publish_date>2001-09-10</publish_date>
              <description>The two daughters of Maeve, half-sisters, 
              battle one another for control of England. Sequel to 
              Oberon's Legacy.</description>
           </book>
        </catalog>

1. 现在双击 Program.cs 以打开代码窗口。

2. 在代码窗口中，滚动到屏幕顶部。

3. 在 using 指令的最后一条语句旁边，添加以下 using 指令：

        using Chapter5.XmlLinq.XmlLinqLib;

1. 现在将 Main() 方法中的现有代码替换为以下代码：

        var xmlFile = @"C:\Projects\Chapter5\Chapter5.XmlLinq\Chapter5.XmlLinq.XmlCore\books.xml";

        var books = new XmlBooks(xmlFile);
        var titles = books.GetBookTitles();

        foreach (var title in titles)
        {

            Console.WriteLine(title);
        }

        Console.ReadLine();

1. 按 F5 查看输出，它应该看起来像这样：

1. 按 Enter 退出。

工作原理...

在步骤 1 到 9 中，我们打开了一个现有的解决方案。然后，我们将一个 .NET Core 控制台应用程序添加到解决方案中。在这些步骤中，我们为项目分配了一个合适的名称。在步骤 10 到 13 中，我们将项目引用添加到我们在上一个菜谱中创建的库中。这些步骤将允许您使用库中可用的方法。

在步骤 15 到 18 中，我们将一个 XML 文件项添加到项目中，然后填充了一些示例数据。在步骤 21 中，我们从 .NET Core 控制台应用程序中引用了我们的库。在步骤 22 中，我们在控制台应用程序的 Main() 方法中添加了代码。第一行存储了我们的 XML 文件路径。这可能在您的设置中有所不同。在接下来的两行中，我们创建了一个 XmlBooks 类的实例，使用其 GetBookTitles() 方法，并将其存储在一个变量中。然后，使用 foreach 语句遍历 GetBookTitles() 方法返回的列表。最后，我们执行了代码。

第六章：探索线程

在本章中，我们将探讨以下食谱：

• 创建一个可以同时执行多项操作的库

• 创建一个用于使用库的 .NET Core 控制台应用程序

• 创建一个使用任务的无阻塞方法

• 创建一个用于使用库的 WPF 应用程序

• 创建线程池

• 创建一个用于使用库的 .NET 控制台应用程序

技术要求

读者应具备基本的 C# 知识。他们还应具备使用 Visual Studio、使用 NuGet 安装包以及在其他项目中引用库的基本知识。

本章的代码文件可以在 GitHub 上找到：

github.com/PacktPublishing/DotNET-Standard-2-Cookbook/tree/master/Chapter06

查看以下视频以查看代码的实际效果：

goo.gl/BhsEpf

简介

线程使您的 C# 应用程序能够同时执行多个操作。简单来说，您可以在执行后台进程的同时允许用户输入个人信息并监控它。例如，在策略游戏中，一个角色可能正在从森林中获取一些木材。同时，另一个角色可能正在建造一堵墙，另一个角色正在射击敌人。让我们看看如何在 .NET Standard 2.0 库中实现线程。

创建一个可以同时执行多项操作库

在本食谱中，我们将探讨线程的基础知识，并在 .NET Standard 2.0 库中使用 System.Threading 命名空间。

准备工作

在我们开始构建我们的库之前，让我们确保已经安装并配置了最新的 Visual Studio 2017 以创建 .NET Standard 2.0 库。

如何操作...

1. 打开 Visual Studio 2017。

2. 点击文件 | 新建 | 项目以创建一个项目。

3. 在新建项目对话框中，展开左侧窗格中的其他项目类型节点，并选择 Visual Studio 解决方案。在右侧窗格中，选择空白解决方案****。

4. 在名称：文本框中，键入 Chapter6.Threads，并在位置：文本框中，从下拉框中选择一个路径或点击浏览...按钮定位路径：

1. 点击确定。

2. 现在，解决方案资源管理器 (Ctrl + Alt + L) 应该看起来像这样：

1. 现在，在解决方案资源管理器中右键单击 Chapter6.Threads 标签，然后选择添加 | 新项目****。

2. 在新建项目对话框中，展开 Visual C# 节点。

3. 在左侧窗格中选择 .NET Standard，在右侧窗格中选择类库 (.NET Standard)：

1. 现在，在名称：文本框中键入 Chapter6.Threads.ThreadLib。保留其他默认设置，然后点击确定：

1. 现在，解决方案资源管理器 (Ctrl + Alt + L) 应该看起来像这样：

1. 现在，在解决方案资源管理器中选择Class1.cs文件，然后按F2键重命名文件为ThreadGenerator.cs。

2. 在确认对话框中回答“是”，以将类名也重命名。

3. 现在，在解决方案资源管理器中双击ThreadGenerator.cs标签。

4. 让我们在代码窗口中向上滚动并添加以下using指令：

      using System.Threading;
      using System.Text

1. 现在，让我们添加这个类级别变量来存储我们的文本消息：

      StringBuilder messages = new StringBuilder(); 

1. 在ThreadGenerator类中创建此方法：

      public StringBuilder StartThreads()
      {
          var mainThread = Thread.CurrentThread;
          mainThread.Name = "MainThread";

          messages.Append($"This is the {mainThread.Name}\n");

          Thread anotherThread = new Thread(CountTo100);
          messages.Append("Start a new thread\n");
          anotherThread.Start();

          messages.Append($"Now call {mainThread.Name} will count to 50\n");

          for (int j=0; j<50; j++)
          {
              messages.Append($"MT-{j + 1}\n");
              Thread.Sleep(80);
          }

          messages.Append($"{mainThread.Name} finished\n");

          return messages;
      }

1. 最后，为主StartThreads()方法创建此支持方法：

      private void CountTo100()
      {
          for (int i=0; i<100; i++)
          {
              messages.Append($"Thread 2 counting {i + 1}\n");
              Thread.Sleep(100);
          }
      }

1. 通过按Ctrl + Shift + B来执行快速构建，以检查语法。

它是如何工作的...

在步骤 1 到 14 中，我们创建了一个新的空白解决方案，并添加了一个.NET Standard 2.0 类库。然后我们给默认模板类取了一个合适的名字。在步骤 15 中，我们添加了用于线程支持的必需的using指令，即System.Threading，并且我们使用了System.Text命名空间来获取StringBuilder类以存储我们的消息。

我们使用了StringBuilder而不是String。如果你想知道为什么，那是因为StringBuilder是可变的。当你执行插入、替换或追加等操作时，StringBuilder对象不会每次都创建一个新的实例。它将在内存中更新一个空间，而不在内存中创建新的空间。然而，String是不可变的，这意味着如果你创建了一个String对象，那么你无法修改它，并且它总是在内存中创建一个新的String对象。

在步骤 16 中，我们创建了一个StringBuilder类的实例，它将处理所有消息并将它们存储起来。然后，我们创建了一个返回StringBuilder的方法。这个StringBuilder将包含在步骤 17 中创建的StartThreads()方法执行期间生成的所有消息。

在这三行中，我们获取了当前正在运行的线程，即主线程，并给它起了一个名字。然后，我们在StringBuilder中存储了一条消息：

var mainThread = Thread.CurrentThread;
mainThread.Name = "MainThread";

messages.Append($"This is the {mainThread.Name}\n");

在这些行中，我们创建了另一个新的线程，并使用步骤 18 中创建的helper方法来执行线程。这个private helper方法循环 100 步，向字符串构建器添加一条消息，并在每一步暂停 100 毫秒：

private void CountTo100()
{
    for (int i=0; i<100; i++)
    {
        messages.Append($"Thread 2 counting {i + 1}\n");
        Thread.Sleep(100);
    }
}

它还按照以下方式在StringBuilder中存储相关消息：

Thread anotherThread = new Thread(CountTo100);
messages.Append("Start a new thread\n");
anotherThread.Start();

在代码的最后几行中，我们在主线程中执行了另一个循环，并将消息存储在StringBuilder中，以识别正在执行的线程。最后，我们进行了快速构建以检查语法。

创建一个.NET Core 控制台应用程序以使用库

在这个菜谱中，我们将构建一个.NET Core 控制台应用程序。这个应用程序将使用我们在上一个菜谱中构建的库。

准备中

确保你已经完成了上一个菜谱，并且它构建正确。让我们开始构建使用库的应用程序。

如何操作...

1. 打开 Visual Studio 2017。

2. 现在，打开上一个菜谱中的解决方案。点击“文件”|“打开”|“打开项目/解决方案”，或者按Ctrl + Shift + O，并选择Chapter6.Threads解决方案。

3. 按Ctrl + Shift + B进行快速构建以检查一切是否正常。

4. 点击Chapter6.Threads解决方案标签。点击“文件”|“添加”|“新建项目”。

5. 在“添加新项目”模板对话框中，展开左侧窗格中的“Visual C#”节点。

6. 在右侧窗格中选择.NET Core，并选择“控制台应用程序 (.NET Core)”：

1. 现在，在“名称：”文本框中，将项目名称输入为Chapter6.Threads.ThreadsCore。其余字段应保持不变：

1. 点击“确定”。

2. 现在，解决方案资源管理器（按Ctrl + Alt + L）应该显示如下：

1. 在Chapter6.Threads.ThreadsCore中的“依赖项”标签上右键单击。

2. 选择“添加引用”。

3. 在引用管理器中，点击右侧窗格中的“项目”标签：

1. 在左侧窗格中检查Chapter6.Threads.ThreadLib项目。

2. 点击“确定”。

3. 现在，在解决方案资源管理器中双击Program.cs标签。

4. 在代码窗口中向上滚动并添加以下using指令：

      using Chapter6.Threads.ThreadLib;

1. 现在，删除Main()方法中由 Visual Studio 生成的任何现有代码，并添加以下代码：

      var threads = new ThreadGenerator();
      var output = threads.StartThreads();

      Console.WriteLine(output);
      Console.ReadLine();

1. 按F5执行应用程序。

2. 你应该看到如下输出：

1. 按Enter键退出。

它是如何工作的...

在步骤 1 到 9 中，我们打开了一个现有的解决方案，其中包含一个.NET Standard 2.0 库项目。然后，我们将.NET Core 控制台应用程序添加到该解决方案中。在步骤 10 到 14 中，我们将.NET Standard 2.0 库项目作为依赖项添加到控制台应用程序中。然后在步骤 16 中，我们使用using指令来引用类库。这将使我们能够访问库中的可用功能。

在第 17 步中，我们在类库中创建了一个ThreadGenerator类的实例。然后，我们使用了它的StartThreads()方法，并将返回的StringBuilder存储在一个变量中。最后，我们使用Console.WriteLine显示了输出，并在最后一行等待用户按键。在第 18 到 20 步中，我们执行了应用程序并看到了输出。

使用任务创建异步方法

在这个菜谱中，我们将探讨 C#语言中找到的异步编程能力。C#具有语言级别的异步能力，因此你不必依赖第三方库。如果你有 I/O 操作，例如从网络或数据库读取数据，你可以利用异步编程。你也可以为 CPU 密集型、昂贵的计算使用异步编程。

准备工作

确保你的 Visual Studio 2017 已经更新。还假设你之前有异步编程的经验以及它的含义。

如何做...

1. 打开 Visual Studio 2017。

2. 点击 File | New | Project 来创建一个项目。

3. 在新项目对话框中，展开左侧窗格中的 Other Project Types 节点，并选择 Visual Studio Solutions。在右侧窗格中，选择 Blank Solution.

4. 在 Name: 文本框中，键入 Chapter6.AsyncTasks，并在 Location: 文本框中，从下拉框中选择一个路径或点击 Browse... 按钮定位路径：

1. 点击 OK。

2. 现在，解决方案资源管理器 (Ctrl + Alt + L) 应该看起来像这样：

1. 现在，在解决方案资源管理器中的 Chapter6.AsyncTasks 标签上右键单击，然后选择 Add | New Project.

2. 在新项目对话框中，展开 Visual C# 节点。

3. 在左侧窗格中选择 .NET Standard，在右侧窗格中选择 Class Library (.NET Standard)：

1. 现在，在 Name: 文本框中，键入 Chapter6.AsyncTasks.AsyncLib。保留其他默认设置，然后点击 OK：

1. 现在，解决方案资源管理器 (Ctrl + Alt + L) 应该看起来像这样：

1. 现在，在解决方案资源管理器中选择 Class1.cs，然后按 F2 重命名文件为 SiteReader.cs。

2. 在确认对话框中回答 Yes，询问是否也要重命名类名。

3. 现在，双击解决方案资源管理器中的 SiteReader.cs 标签。

4. 让我们在代码窗口中向上滚动并添加以下 using 指令：

      using System.Net.Http;
      using System.Threading.Tasks;

1. 现在，让我们添加这个类级别的变量：

      private HttpClient _httpClient = new HttpClient();

1. 在 SiteReader 类的开放和闭合花括号内添加以下方法：

      public async Task<string> ReadSiteContent(string url)
      {
          var htmlContent = await _httpClient.GetStringAsync(url);

          return htmlContent;
      }

1. 按 Ctrl + Shift + B 进行快速构建。

它是如何工作的...

在步骤 1 到 12 中，我们添加了一个空白解决方案，然后向解决方案中添加了一个 .NET Standard 2.0 类库。在这些步骤中，我们为解决方案和项目分配了合适的名称。在步骤 13 和 14 中，我们将默认类模板重命名为更有意义的内容。你也可以删除这个类并创建一个新的。

在步骤 15 中，我们向代码中添加了两个命名空间。在步骤 16 中，我们创建了一个类级别的变量并创建了一个 HttpClient 类的实例。在步骤 17 中，我们创建了一个异步的公共方法，该方法将给定的网站内容作为 string 读取并返回读取的内容。

最后，我们进行了快速构建以检查语法。

创建一个用于使用库的 WPF 应用程序

在这个菜谱中，我们将创建一个用于使用库的 Windows Presentation Foundation 应用程序。将创建一个基本的用户界面来显示内容。

准备工作

确保你已经打开了我们在上一道菜谱中构建的 .NET Standard 2.0 类库。如果没有，请确保在深入这一道之前完成上一道菜谱。

如何做...

1. 打开 Visual Studio 2017。

2. 现在，打开前一个菜谱中的解决方案。点击“文件”|“打开”|“打开项目/解决方案”，或者按Ctrl + Shift + O，然后选择Chapter6.AsyncTasks解决方案。

3. 按Ctrl + Shift + B进行快速构建以检查一切是否正常。

4. 点击Chapter6.AsyncTasks解决方案标签。点击“文件”|“添加”|“新建项目”。

5. 在“添加新项目”模板对话框中，展开左侧窗格中的“Visual C#”节点。

6. 在右侧窗格中选择“Windows Classic Desktop”，然后选择“WPF App (.NET Framework)”：

1. 现在，在“名称：”文本框中，输入Chapter6.AsyncTasks.WPFSiteContent作为项目的名称。其余字段可以保持不变：

1. 点击“确定”。

2. 现在，解决方案资源管理器（按Ctrl + Alt + L）应该看起来像这样：

1. 在Chapter6.AsyncTasks.WPFSiteContent中，右键点击“引用”标签。

2. 选择“添加引用”。

3. 在参考管理器中，点击右侧窗格中的“项目”标签：

1. 在左侧窗格中检查Chapter6.AsyncTasks.AsyncLib项目。

2. 点击“确定”。

3. 现在，点击MainWindow.xaml选项卡。

4. 从工具箱中，向 MainWindow 窗体添加一个 TextBox 控件、一个 Button 控件和一个 WebBrowser 控件：

1. 选择 TextBox 并按F4加载属性窗口。

2. 更改以下属性：

   控件	属性	值
   TextBox	Name	UrlTextBox
   TextBox	Text	删除现有文本并留空
   Button	Name	GoButton
   Button	Content	Go
   WebBrowser	Name	ContentBrowser

3. 双击“Go”按钮进入代码窗口。

4. 向上滚动直到到达using指令。

5. 将以下using指令添加到指令的最后一行：

      using Chapter6.AsyncTasks.AsyncLib;

1. 向下滚动并在GoButton_Click()事件内添加以下代码。

2. 按如下方式更改GoButton_Click：

      private async void GoButton_Click(object sender, RoutedEventArgs e)

1. 在GoButton_Click()方法内添加以下代码：

      var url = UrlTextBox.Text;
      var siteReader = new SiteReader();
      var content = await siteReader.ReadSiteContent(url);

      ContentBrowser.NavigateToString(content);

1. 按F5执行应用程序。

2. 在文本框内输入一个 URL 并点击“Go”按钮。

3. 你应该看到类似以下输出：

1. 关闭应用程序。

它是如何工作的...

在步骤 1 到 10 中，我们打开了现有的.NET Standard 2.0 库项目解决方案。然后我们向解决方案中添加了一个 WPF 项目。在步骤 11 到 14 中，我们添加了对之前菜谱中构建的类库的引用。在步骤 16 到 18 中，我们向 WPF 应用程序的MainWindow添加了控件，并更改了一些属性。

在步骤 21 中，我们使用using指令引用了类库。在步骤 23 中，我们使用async关键字装饰了GoButton_Click()方法。在步骤 24 中，代码的前三行演示了我们在创建SiteReader类实例后创建了一个变量来存储从 TextBox 中获取的 URL。然后，我们使用ReadSiteContent()异步方法读取给定 URL 的内容。最后，我们在WebBrowser控件中显示该内容。

在步骤 25 到 27 中，我们测试了应用程序。

创建线程池

在本食谱中，我们将探讨 C# 中的线程池。基本上，线程池是一组可以用于在后台执行任务的线程。一旦线程完成其任务，它就会被发送到等待线程的池中，以便可以重用。让我们创建一个使用线程池的 .NET Standard 2.0 库。

准备工作

确保您已安装并运行了最新版本的 Visual Studio 2017。

如何操作...

1. 打开 Visual Studio 2017。

2. 点击“文件”|“新建”|“项目”来创建一个项目。

3. 在“新建项目”对话框中，展开左侧窗格中的“其他项目类型”节点，并选择“Visual Studio 解决方案”。在右侧窗格中，选择“空白解决方案”。

4. 在“名称：”文本框中，键入Chapter6.ThreadPools，并在“位置：”文本框中，从下拉框中选择一个路径或点击“浏览...”按钮来定位路径：

1. 点击“确定”。

2. 现在，解决方案资源管理器 (Ctrl + Alt + L) 应该看起来像这样：

1. 在解决方案资源管理器中的Chapter6.ThreadPools标签上右键单击，并选择“添加”|“新建项目”。

2. 在“新建项目”对话框中，展开“Visual C#”节点。

3. 在左侧窗格中选择.NET Standard，在右侧窗格中选择“类库 (.NET Standard)”：

1. 在“名称：”文本框中，键入Chapter6.ThreadPools.PoolLib。保留其他默认设置并点击“确定”：

1. 现在，解决方案资源管理器 (Ctrl + Alt + L) 应该看起来像这样：

1. 在解决方案资源管理器中选择Class1.cs，然后按F2键重命名文件为ThreadList.cs。

2. 在确认对话框中回答“是”，询问是否重命名类名。

3. 双击解决方案资源管理器中的ThreadList.cs标签。

4. 让我们在代码窗口中向上滚动并添加以下using指令：

      using System.Text;
      using System.Threading;

1. 让我们添加一个类级别的变量来保存StringBuilder：

      StringBuilder messages = new StringBuilder();

1. 在类中添加一个主ProcessPool()方法：

      public StringBuilder ProcessPool()
      {
          for (int i=0; i<5; i++)
          {
              ThreadPool.QueueUserWorkItem(new WaitCallback(Process));
          }

          for (int k=0; k<10; k++)
          {
              messages.AppendLine($"Main Thread - {k + 1}");
          }

          return messages;
       }

1. 最后，让我们添加一个辅助方法来处理线程：

private void Process(object callback)
{
    for (int j=0; j<10; j++)
    {
        messages.AppendLine($"Thread - {j + 1}");
    }
}

1. 通过按Ctrl + Shift + B进行快速构建。

它是如何工作的...

在步骤 1 到 10 中，我们创建了一个空白解决方案，并将.NET Standard 2.0 库添加到项目中。在此期间，我们为项目和解决方案分配了有意义的名称。在第 12 步中，我们重命名了 Visual Studio 创建的默认类。在第 15 步中，我们添加了构建库所需的命名空间。

在第 16 步中，我们使用StringBuilder类创建了一个变量来存储消息。这是一个类级别的变量，在类内的方法之间共享。在第 17 步中，我们创建了一个方法，使用第 18 步中的辅助方法创建线程池。在该方法内部，我们使用messages变量在过程中存储消息。

最后，在第 19 步中，我们进行了快速构建以检查语法是否正确。

创建一个.NET 控制台应用程序来使用库

在本食谱中，我们将查看一个基于.NET 控制台的应用程序来使用库。这个控制台应用程序将引用上一食谱中创建的库并使用它。

准备工作

确保你已经完成了上一食谱。如果你已经完成，请使用 Visual Studio 2017 打开它并执行快速构建以检查一切是否正常。

如何操作...

1. 打开 Visual Studio 2017。

2. 现在，打开上一食谱中的解决方案。点击文件 | 打开 | 打开项目/解决方案，或按Ctrl + Shift + O，并选择Chapter6.ThreadPools解决方案。

3. 按Ctrl + Shift + B进行快速构建以检查一切是否正常。

4. 点击解决方案资源管理器中的Chapter6.ThreadPools解决方案标签。点击文件 | 添加 | 新项目。

5. 在“添加新项目”模板对话框中，展开左侧窗格中的 Visual C#节点。

6. 在右侧窗格中选择 Windows 经典桌面，并选择 Console App (.NET Framework)：

1. 在“名称”文本框中，输入Chapter6.ThreadPools.PoolConsole作为项目的名称。其余字段可以保持不变：

1. 点击确定。

2. 现在，解决方案资源管理器（按Ctrl + Alt + L）应该看起来像这样：

1. 在Chapter6.ThreadPools.PoolConsole的引用标签上右键单击。

2. 选择添加引用。

3. 在引用管理器中，点击右侧窗格中的项目标签：

1. 在左侧窗格中检查Chapter6.ThreadPools.PoolLib项目。

2. 点击确定。

3. 双击解决方案资源管理器中的Program.cs标签。

4. 在代码窗口中向上滚动并添加以下using指令：

      using Chapter6.ThreadPools.PoolLib;

1. 让我们在Main()方法中添加代码：

      var pool = new ThreadList();
      var output = pool.ProcessPool();

      Console.WriteLine(output);

      Console.ReadLine();

1. 现在，按F5测试我们的应用程序：

1. 按下Enter键退出应用程序。

它是如何工作的...

在步骤 1 到 9 中，我们打开了上一道菜谱中创建的解决方案。然后，我们将一个 .NET 控制台应用程序添加到项目中。在步骤 10 到 14 中，我们添加了对上一道菜谱中创建的库的引用。在步骤 16 中，我们在代码中创建了库的引用。在步骤 17 中，我们添加了代码来创建 ThreadList 类的实例。我们调用了 ProcessPool() 并将返回值存储在一个变量中。

最后，我们在控制台窗口中显示了输出，并在步骤 18 和 19 中测试了应用程序。

第七章：网络编程

在本章中，我们将探讨以下食谱：

• 使用套接字显示 IP 地址和名称的库

• 创建一个用于使用库的经典 Windows 应用程序

• 创建一个发送邮件的库

• 创建一个用于使用库的 WPF 应用程序

• 创建一个用于调用 REST API 的库

• 创建一个用于使用库的 ASP.NET MVC 应用程序

技术要求

读者应具备基本的 C#知识。他们还应了解如何使用 Visual Studio，使用 NuGet 安装包，以及在其他项目中引用项目中的库。

本章的代码文件可以在 GitHub 上找到：

github.com/PacktPublishing/DotNET-Standard-2-Cookbook/tree/master/Chapter07

查看以下视频以查看代码的实际运行情况：

goo.gl/Wj2VD9

简介

Microsoft .NET Framework 为您提供了一套类库，使您能够轻松地与互联网服务一起工作。这些库允许您轻松地将服务集成到您的应用程序中。在本章中，我们将使用 System.Net 命名空间中的几个这些类。我们将探讨如何将这些类放入.NET Standard 2.0 库中，并在不同的.NET 应用程序版本中使用它。

使用套接字显示 IP 地址和名称的库

在本食谱中，我们将构建一个.NET Standard 2.0 类库，该类库可以显示当前机器的 IP 地址。然后，我们将创建一个使用该库的应用程序。

准备工作

在开始构建库之前，请确保已安装并配置了最新的 Visual Studio 2017，用于创建.NET Standard 2.0 库。

如何操作...

1. 打开 Visual Studio 2017。

2. 点击“文件”|“项目”以创建项目。

3. 在“新建项目”对话框中，展开左侧窗格中的“其他项目类型”节点，并选择“Visual Studio 解决方案”。在右侧窗格中，选择“空白解决方案”。

4. 在“名称”文本框中，键入Chapter7.Networking，并在“位置”文本框中选择下拉框中的路径或单击“浏览...”按钮定位路径：

1. 点击“确定”。

2. 现在，您的解决方案资源管理器（Ctrl + Alt + L）应如下所示：

1. 现在，在解决方案资源管理器中右键单击Chapter7.Networking标签，并选择“添加”|“新建项目”。

2. 在“新建项目”对话框中，展开“Visual C#”节点。

3. 在左侧窗格中选择.NET Standard，在右侧窗格中选择类库 (.NET Standard)：

1. 在“名称”文本框中，键入Chapter7.Networking.ReadIPLib，保留其他默认设置，然后单击“确定”：

1. 现在，解决方案资源管理器（Ctrl + Alt + L）应如下所示：

1. 现在，在解决方案资源管理器中选择Class1.cs，并按F2将文件重命名为IPReader.cs。

2. 确认对话框中询问是否重命名类名时，请回答“是”。

3. 在解决方案资源管理器中双击IPReader.cs标签。

4. 让我们在代码窗口中向上滚动并添加以下using指令：

      using System.Net;
      using System.Net.Sockets;
      using System.Collections.Generic;

1. 现在，让我们在IPReader类中创建这个public方法：

      public List<string> GetMyIPAddress()
      {
          var hostName = Dns.GetHostName();
          var hostAddress = Dns.GetHostAddresses(hostName);

          var ipList = new List<string>();

          foreach (var ipaddres in hostAddress)
          {
              if (ipaddres.AddressFamily == AddressFamily.InterNetwork)
              {
                  ipList.Add(ipaddres.ToString());
              }
          }

          return ipList;
      }

1. 按Ctrl + Shift + B进行快速构建以检查语法。

它是如何工作的...

在步骤 1 到 11 中，我们添加了一个空白解决方案，并将一个.NET Standard 2.0 类库添加到解决方案中。在这些步骤中，我们已为解决方案和项目赋予了适当的名称。然后，在第 12 步中，我们将 Visual Studio 生成的默认Class1.cs的名称进行了更改。在第 15 步中，我们向代码中添加了所需的using指令。我们主要使用了System.Net和System.Net.Sockets来访问所需的类并读取 IP 地址，然后添加了System.Collections.Generic命名空间以创建一个通用的string List来存储 IP 地址。

在第 16 步中，我们添加了一个公共方法，该方法将读取您所在本地计算机上的所有可用 IP 地址。在第一行中，我们将系统主机名存储在一个变量中，在第二行中，我们使用它来获取主机地址。然后，我们创建了一个空列表来存储 IP 地址。

之后，我们使用foreach循环遍历所有找到的 IP 地址，并在检查是否为内部网络上的 IP 地址后，将它们存储在列表中。最后，我们返回存储的 IP 地址列表。

在第 17 步中，我们进行了快速构建以检查语法。

创建一个经典 Windows 应用程序以使用库

在这个配方中，我们将创建一个经典 Windows 应用程序来使用库。我们将使用 Visual Studio 设计器创建 UI，添加代码以使用库，并显示从库本身选择的 IP 地址列表。

准备工作

确保您拥有 Visual Studio 2017 的最新版本，并且已经完成了前面的配方。我们将使用前面配方中构建的解决方案。

如何操作...

1. 打开 Visual Studio 2017。

2. 现在打开前面配方中的解决方案。点击 文件 | 打开 | 打开项目/解决方案 或按 Ctrl + Shift + O 并选择Chapter7.Networkings解决方案。

3. 按Ctrl + Shift + B进行快速构建以检查一切是否正常。

4. 现在，点击Chapter7.Networking解决方案标签。点击 文件 | 添加 | 新项目。

5. 在“添加新项目”模板对话框中，展开左侧窗格中的 Visual C#节点。

6. 在右侧窗格中，选择 Windows 经典桌面，并选择 Windows 窗体应用程序(.NET Framework)：

1. 在“名称：”文本框中，将项目名称输入为Chapter7.Networking.IPListWindows。其余字段可以保留默认值：

1. 点击“确定”。

2. 现在，解决方案资源管理器（按Ctrl + Alt + L）应该看起来像这样：

1. 在Chapter7.Networking.IPListWindows中的“引用”标签上点击鼠标右键。

2. 选择“添加引用”。

3. 在引用管理器中，点击右侧面板中的“项目”标签：

1. 在左侧面板中检查Chapter7.Networking.ReadIPLib项目。

2. 点击“确定”。

3. 现在点击项目列表中的Form1.cs并将其重命名为MainForm.cs。

4. 对确认对话框回答“是”。

5. 现在点击“MainForm.cs[设计]”选项卡。

6. 从工具箱中，将一个按钮控件和一个列表框控件添加到 MainWindow 窗体：

1. 选择按钮并按F4加载属性窗口。

2. 现在更改以下属性：

   控件	属性	值
   表单	文本	IP 列表
   按钮	名称	ShowButton
   按钮	文本	显示 IP 列表
   列表框	名称	IPListBox

3. 双击“显示 IP 列表”按钮以到达代码窗口。

4. 向上滚动，直到你到达using指令。

5. 将以下using指令添加到指令的最后一行：

      using Chapter7.Networking.ReadIPLib;

1. 现在，再次向下滚动，直到你到达ShowButton_Click()方法。

2. 在方法内部输入以下代码：

      var ipLib = new IPReader();
      IPListBox.Items.AddRange(ipLib.GetMyIPAddress().ToArray());

1. 现在按F5调试代码。

2. 点击“显示 IP 列表”按钮。

3. 你应该看到如下输出：

1. 关闭窗口。

它是如何工作的...

在步骤 1 到 10 中，我们打开了之前构建的解决方案并快速构建以检查一切是否完好。然后，我们向解决方案中添加了一个经典 Windows 窗体应用程序。在步骤 11 到 14 中，我们添加了对我们在上一个菜谱中构建的.NET Standard 2.0 类库的引用。在步骤 15 到 20 中，我们重命名了主窗口并添加了 UI。最后，我们以有意义的方式更改了控件属性。

在步骤 23 中，我们在代码中引用了类库。在步骤 25 中，我们创建了一个IPReader类的实例，然后使用了GetMyIPAddress()方法。在同一行中，我们将返回的List<string>作为数组输出，并使用ListBox和AddRange方法填充列表框。

在步骤 26 到 29 中，我们执行了代码并测试了结果。

创建一个发送邮件的库

在这个菜谱中，我们将探讨System.Net命名空间中的另一个区域。我们将使用它来创建和发送电子邮件。主要，我们将查看SmtpClient类来为我们做艰苦的工作。

准备工作

确保您已安装 Visual Studio 2017 的最新版本和所有更新。我们将构建一个.NET Standard 2.0 库来发送电子邮件。

如何做到这一点...

1. 打开 Visual Studio 2017。

2. 点击文件 | 新建 | 项目 以创建一个项目。

3. 在“新建项目”对话框中，展开左侧面板中的“其他项目类型”节点，并选择 Visual Studio 解决方案。在右侧面板中，选择空白解决方案。

4. 在“名称”文本框中，键入Chapter7.MailBox，并在“位置”文本框中选择下拉框中的路径或单击“浏览...”按钮以定位路径：

1. 点击“确定”。

2. 现在，你的解决方案资源管理器（Ctrl + Alt + L）应该看起来像这样：

1. 现在，在解决方案资源管理器中的Chapter7.MailBox标签上右击，然后选择“添加”|“新建项目”。

2. 在“新建项目”对话框中，展开 Visual C# 节点。

3. 在左侧面板中选择.NET Standard，在右侧面板中选择类库 (.NET Standard)：

1. 在“名称”文本框中，键入Chapter7.MailBox.MailerLib，保留其他默认设置，然后单击“确定”：

1. 现在，解决方案资源管理器（Ctrl + Alt + L）应该看起来像这样：

1. 现在，在解决方案资源管理器中选择Class1.cs，然后按F2键将文件重命名为SendMail.cs。

2. 对确认对话框中的问题回答“是”，以将类名也重命名。

3. 现在，在解决方案资源管理器中双击SendMail.cs标签。

4. 让我们在代码窗口中向上滚动并添加以下using指令：

      using System.Net;
      using System.Net.Mail;

1. 将以下四个属性添加到SendMail类中：

      public string From { get; set; }
      public string To { get; set; }
      public string Subject { get; set; }
      public string Body { get; set; }

1. 最后，添加以下public方法以创建和发送邮件：

      public void Send()
      {
          var toAddress = new MailAddress(To);
          var fromAddress = new MailAddress(From);

          var message = new MailMessage(fromAddress, toAddress);
          message.Subject = Subject;
          message.Body = Body;

          var credentials = new NetworkCredential("<your_smtp_username>", "<your_smtp_password>"); 

          var smtp = new SmtpClient();
          smtp.Host = "<smtp_host>";
          smtp.Port = <port>;
          smtp.EnableSsl = true;
          smtp.Credentials = credentials;
          smtp.DeliveryMethod = SmtpDeliveryMethod.Network;

          smtp.Send(message); 
      }

1. 让我们按Ctrl + Shift + B进行快速构建。

它是如何工作的...

在步骤 1 到 11 中，我们创建了一个空白解决方案，并向其中添加了一个 .NET Standard 2.0 类库项目。然后，我们正确地命名了解决方案及其项目。在步骤 12 到 14 中，我们将 Visual Studio 生成的默认类重命名。在步骤 15 中，我们在 using 指令部分添加了必要的命名空间以发送邮件。在步骤 16 中，我们在主类中添加了四个属性。这些属性将存储邮件地址、主题和邮件正文。

在步骤 17 中，我们编写了准备和发送邮件的实际代码。在前两行中，我们使用了发件人和收件人地址，并将它们转换为MailAddress类型。然后，我们创建了一个MailMessage，并附加了正文和主题，以及地址。然后，我们创建了访问给定 SMTP 服务器的网络凭证。

然后，我们创建了一个SmtpClient对象，附加了凭证并发送了邮件。最后，我们快速构建以检查语法。

创建一个 WPF 应用程序以使用库

在本食谱中，我们将创建一个 Windows 表单应用程序来使用我们创建的库。我们将创建一个用户界面，使用库发送电子邮件。

准备工作

确保你已经完成了发送电子邮件的先前食谱。如果你已经完成，请打开它并快速构建以检查一切是否正常工作。

如何操作...

1. 打开 Visual Studio 2017。

2. 现在打开上一个菜谱中的解决方案。点击 文件 | 打开 | 打开项目/解决方案 或按 Ctrl + Shift + O 并选择 Chapter7.MailBox 解决方案。

3. 按 Ctrl + Shift + B 进行快速构建以检查一切是否正常。

4. 点击 Chapter7.MailBox 解决方案标签。点击 文件 | 添加 | 新项目。

5. 在 添加新项目 模板对话框中，展开左侧窗格中的 Visual C# 节点。

6. 在右侧窗格中选择 Windows Classic Desktop 并选择 WPF 应用 (.NET Framework)：

1. 现在，在 名称：文本框中输入 Chapter7.MailBox.WPFMail 作为项目的名称。其余字段可以保留默认值：

1. 点击确定。

2. 现在，解决方案资源管理器（按 Ctrl + Alt + L）应该看起来像这样：

1. 在 Chapter7.MailBox.WPFMail 上的 引用 标签上单击鼠标右键。

2. 选择添加引用。

3. 在引用管理器中，点击右侧窗格中的 项目 标签：

1. 在左侧窗格中检查 Chapter7.MailBox.MailerLib 项目。

2. 点击确定。

3. 现在，点击 MainWindow.xaml 选项卡。

4. 从工具箱中，向 MainWindow 表单添加四个文本框控件和一个按钮控件。按照以下方式排列：

1. 选择文本框并按 F4 加载属性窗口。

2. 现在更改以下属性（按照上一个 UI 中的顺序从顶部开始）：

   控件	属性	值
   文本框	名称	FromTextBox
   文本框	文本	发件人地址
   文本框	名称	ToTextBox
   文本框	文本	收件人地址
   文本框	名称	SubjectTextBox
   文本框	文本	主题
   文本框	名称	BodyTextBox
   文本框	文本	正文
   文本框	接受回车 (开启此属性将使文本框多行)	是
   按钮	名称	SendButton
   按钮	文本	发送

3. 现在，你的 UI 应该看起来像这样：

1. 双击发送按钮以打开代码窗口。

2. 向上滚动，直到你到达 using 指令。

3. 将以下 using 指令添加到指令的最后一行：

      using Chapter7.MailBox.MailerLib;

1. 滚动到 SendButton_Click() 方法，并添加以下代码：

      var mailer = new SendMail();

      mailer.From = FromTextBox.Text;
      mailer.To = ToTextBox.Text;
      mailer.Subject = SubjectTextBox.Text;
      mailer.Body = BodyTextBox.Text;

      mailer.Send();

      MessageBox.Show("Your mail has been sent");

1. 确保您已更改库中 SMTP 服务器所需的凭据。

2. 通过按 F5 来测试我们的应用程序：

1. 点击确定并关闭窗口。

它是如何工作的...

在步骤 1 到 14 中，我们打开了带有库的解决方案。然后，我们将 WPF 应用程序项目添加到解决方案中。稍后，我们添加了对类库的引用。在步骤 16 到 20 中，我们构建了 UI 并更改了一些属性。在步骤 22 中，我们在代码级别创建了到库的引用。

最后，我们添加了按钮点击的代码，这是直接的，创建了一个SendMail类的实例，然后从 UI 本身填充了属性。最后，在步骤 24 和 25 中测试了输出。

创建一个库来调用 REST API

在这个菜谱中，我们将查看一个调用 REST API 的.NET Standard 2.0 库。RESTful API 是允许你通过 HTTP 访问其功能的服务。我们将在库中使用System.Net.Http命名空间向 API 发送消息并获取结果。

准备工作

确保你有 Visual Studio 2017 的最新版本。同时确保你有一个基本的了解，如何访问 Web 服务，什么是GET方法，什么是POST方法等等。我们将使用由JSONPlaceHolder提供的测试 API 服务。它是一个简单的 REST API 测试平台，供开发者使用。

如何操作...

1. 打开 Visual Studio 2017。

2. 点击“文件 | 新建 | 项目”来创建一个项目。

3. 在“新建项目”对话框中，展开左侧窗格中的“其他项目类型”节点，并选择“Visual Studio 解决方案”。在右侧窗格中，选择“空白解决方案”。

4. 在“名称：”文本框中输入Chapter7.RestAPI，在“位置：”文本框中选择下拉框中的路径或点击“浏览...”按钮定位路径：

1. 点击“确定”。

2. 现在，你的解决方案资源管理器（Ctrl + Alt + L）应该看起来像这样：

1. 现在，在解决方案资源管理器中的Chapter7.RestAPI标签上右击鼠标，然后选择“添加 | 新建项目”。

2. 在“新建项目”对话框中，展开“Visual C#”节点。

3. 在左侧窗格中选择.NET Standard，在右侧窗格中选择类库(.NET Standard)：

1. 现在，在“名称：”文本框中输入Chapter7.RestAPI.RestLib，保留其他默认设置，然后点击“确定”：

1. 现在，解决方案资源管理器（Ctrl + Alt + L）应该看起来像这样：

1. 现在，在解决方案资源管理器中选择Class1.cs，然后按F2将文件重命名为PostsReader.cs。

2. 对确认对话框中的将类名重命名的问题回答“是”。

3. 现在，在解决方案资源管理器中双击PostsReader.cs标签。

4. 让我们在代码窗口中向上滚动并添加以下using指令：

      using System.Net.Http;
      using System.Threading.Tasks;

1. 现在，创建一个用于存储 URL 的类级private变量：

      private string _serviceURL;

1. 让我们创建默认构造函数来更新之前的变量：

      public PostsReader(string serviceURL)
      {
          _serviceURL = serviceURL;
      }

1. 最后，让我们添加从 REST 服务读取的方法：

      public async Task<string> GetPostById(int id)
      {
          string output; 

          using (var httpClient = new HttpClient())
          {

              Uri uri = new Uri($"{_serviceURL}/posts/{id}");
              using (HttpResponseMessage response = 
                  await httpClient.GetAsync(uri))
              {
                  output = await response.Content.ReadAsStringAsync();
              }
          }

          return output;
      }

1. 按Ctrl + Shift + B进行快速构建以检查语法。

它是如何工作的...

在步骤 1 到 11 中，我们创建了一个空解决方案。然后我们向该解决方案添加了一个 .NET Standard 2.0 库。再次，作为一个好的实践，我们正确地命名了解决方案和类库项目。在步骤 12 和 13 中，我们更改了 Visual Studio 默认创建的 Class1.cs 的名称。在步骤 15 中，我们添加了执行任务所需的 using 指令。在步骤 16 中，我们创建了一个类级别的私有变量来保存服务 URL。然后，在步骤 16 中，我们创建了一个带有 string 参数的默认构造函数，该参数更新了步骤 15 中的私有变量。

在步骤 18 中，我们创建了执行读取 RESTful API 实际工作的 public 方法。在代码的第一行，我们创建了一个 string 变量，用于保存服务的输出。然后，我们在 using 语句内部创建了一个 HttpClient 类的实例。这是一个好的实践，它将确保在退出 using 语句后销毁该类。

然后，我们将 通用资源标识符 (URI) 填充到服务中。之后，我们实际调用服务，并将结果存储在 HttpResponseMessage 变量中。最后，我们从响应中获取输出并返回输出。

创建一个用于使用库的 ASP.NET MVC 应用程序

在这个菜谱中，我们将创建一个 ASP.NET MVC 应用程序来使用我们创建的库。

准备中

确保你已经完成了上一个菜谱。如果没有，你需要在此之前完成它。如果你已经完成了，请打开它，在我们开始之前进行快速构建。

如何操作...

1. 打开 Visual Studio 2017。

2. 现在，打开上一个菜谱中的解决方案。点击“文件”|“打开”|“打开项目/解决方案”或按 Ctrl + Shift + O 并选择 Chapter7.RestAPI 解决方案。

3. 按 Ctrl + Shift + B 进行快速构建以检查一切是否正常。

4. 现在，单击Chapter7.RestAPI解决方案标签。点击“文件”|“添加”|“新建项目”。

5. 在“添加新项目”模板对话框中，展开左侧窗格中的“Visual C#”节点。

6. 在右侧窗格中选择 Web，然后选择 ASP.NET Web 应用程序 (.NET Framework)：

1. 现在，在“名称：”文本框中输入 Chapter7.RestAPI.RestMVC 作为名称，并将“位置：”文本框保留为其默认值：

1. 在“新建 ASP.NET Web 应用程序”对话框中，从模板列表中选择“空”。

2. 选择“MVC”作为“添加文件夹和核心引用”选项：

1. 保持其他设置不变，然后点击“确定”以创建默认的 ASP.NET MVC Web 应用程序模板。

2. 现在，解决方案资源管理器应该看起来像这样：

1. 现在，右键单击 Chapter7.RestAPI.RestMVC 项目下的“引用”标签，并选择“添加引用”。

2. 在“引用管理器”对话框中，在左侧窗格中选择“项目”，并在右侧窗格中选择 Chapter7.RestAPI.RestLib：

1. 点击“确定”。

2. 现在，在Chapter7.RestAPI.RestMVC项目中的Controllers文件夹内，右键单击Controllers文件夹。

3. 选择“添加”|“控制器”。

4. 在“添加 Scaffold”对话框中，从模板列表中选择“MVC 5 Controller - Empty”并点击“添加”：

1. 现在，在“添加控制器”对话框中，在“控制器名称”文本框中输入HomeController：

1. 点击“添加”。

2. 双击Controllers文件夹下的HomeController.cs标签。

3. 在代码窗口中，右键单击Index()方法名称，并选择“添加视图”。

4. 在“添加视图”对话框中保留默认设置，然后点击“添加”：

1. 在代码窗口中点击HomeController.cs标签页。

2. 在代码顶部，紧邻所有指令的最后一行旁边添加此using指令：

      using System.Threading.Tasks;
      using System.Web.Script.Serialization;
      using Chapter7.RestAPI.RestLib;

1. 现在将default Index()动作更改为以下内容：

      public async Task<ActionResult> Index()

1. 在Index()方法内部添加以下代码：

      var service = "https://jsonplaceholder.typicode.com";
      var restClient = new PostsReader(service);

      var result = await restClient.GetPostById(1);
      ViewBag.Post = new JavaScriptSerializer().Deserialize<Dictionary
          <string, string>>(result);

      return View();

1. 现在，让我们打开Index.cshtml文件，并在<h2>Index</h2>标签下方添加以下代码：

      @{
          var post = (Dictionary<string, string>)ViewBag.Post;
      }

      @foreach (var item in post)
      {
          <p>
              <strong>@item.Key</strong> : @item.Value
          </p>
      }

1. 现在，确保您已将 MVC 项目设置为默认项目。

2. 按F5键，你应该会看到如下输出：

工作原理...

在步骤 1 到 11 中，我们打开了解决方案并添加了一个 ASP.NET MVC 项目。然后，我们为项目命名。在步骤 12 和 13 中，我们添加了之前食谱中构建的库的引用。在步骤 16 到 18 中，我们向项目中添加了一个空控制器。然后，在步骤 21 和 22 中，我们在HomeController中添加了一个视图到Index()动作。

在步骤 23 中，我们添加了对库本身的代码级引用，并添加了两个我们任务所需的更多命名空间。在步骤 24 中，我们将Index()动作更改为async方法。这是必需的，因为我们将从库本身使用async方法。在步骤 26 中，我们为测试床创建了服务 URL。然后，我们创建了一个PostsReader类的实例。在第三行中，我们使用GetPostById()方法从服务中获取结果。再次，在代码的第四行中，我们使用JavaScriptSerializer类的一个方法将来自服务的结果反序列化为字典。

最后，我们将结果存储在ViewBag中，并将其传递给Index视图。在第 27 步中，我们从ViewBag中获取了字典，并使用Razor语法显示内容。

最后，我们在第 29 步测试了输出。

第八章：使用 Xamarin 进入 iOS

在本章中，我们将探讨以下菜谱：

• 安装 Visual Studio for Mac

• Hello iOS – 创建一个 Xamarin iOS 应用

• 创建.NET Standard 2.0 库

• 整合组件并测试应用

技术要求

读者应具备 C#的基本知识。他们还应具备使用 Visual Studio、使用 NuGet 安装包以及在项目中引用其他项目库的基本知识。

本章的代码文件可以在 GitHub 上找到：

github.com/PacktPublishing/DotNET-Standard-2-Cookbook/tree/master/Chapter08

查看以下视频以查看代码的实际操作：

goo.gl/fG1ErJ

简介

Xamarin 是一个开发平台，允许您为 iOS、Android 和 Windows 构建原生应用。Xamarin 最令人惊奇之处在于，您可以使用现有的 C#技能来开发这些应用。最初，Xamarin 被称为 Xamarin Studio，用于在 macOS 和 Windows 上构建应用。Windows 用户有额外特权使用 Visual Studio。在微软收购后，Xamarin Studio 变成了 Visual Studio for Mac。在本章中，我们将使用 Visual Studio for Mac 构建我们的应用，贯穿整个菜谱。

安装 Visual Studio for Mac

在这个菜谱中，我们将探讨如何获取 Visual Studio for Mac 并安装它。我们还将探讨设置一些其他事情。

准备工作

确保您有一台 Mac 来完成此菜谱。目前，我正在使用 macOS High Sierra 版本 10.13.3。同时，请确保您已经安装了最新的 XCode 版本。XCode 是 Mac 构建 iOS 应用时所需的，与 Visual Studio 一起使用。

如何操作...

1. 让我们打开您最喜欢的浏览器。

2. 在地址栏中输入www.xamarin.com/download，然后按Enter。

3. 你应该看到一个类似的屏幕：

1. 现在，填写您的详细信息并按下“下载 VS for Mac Community”按钮。

2. 这将默认将文件下载到“下载”目录，命名为VisualStudioForMacInstaller__215259590.1517557727.dmg或类似名称（下载时末尾数字可能会变化。）

3. 双击该文件。

4. 你应该看到一个类似的窗口：

1. 双击下箭头。在下一个屏幕中，选择要安装的组件：

1. 点击安装按钮安装所有组件。请确保您已选择了 Android 和 iOS。

2. 安装成功后，你应该看到这个：

1. 现在，您可以点击完成以退出，并启动 Visual Studio for Mac 以打开 IDE：

Visual Studio for Mac

它是如何工作的...

这些是安装 Visual Studio for Mac 的简单步骤。在第 8 步，你应该看到安装而不是更新。这个屏幕出现是因为我已经安装了 Visual Studio for Mac 的一个版本。

Hello iOS – 创建一个 Xamarin iOS 应用

在本菜谱中，我们将创建我们的第一个 iOS 应用程序。这将是一个类似于Hello World的应用程序。稍后，我们将修改这个应用程序以使用 .NET Standard 2.0 库。

准备工作

确保你已经完成了上一个菜谱，并且安装了 Visual Studio for Mac。同时，请确保你已经安装了与 Visual Studio for Mac 一起使用的 XCode。

如何操作...

1. 打开 Finder。

2. 在左侧面板中点击应用程序。

3. 现在，双击 Visual Studio 图标。

4. 现在，点击新建项目按钮。

5. 在选择项目模板对话框中，向下滚动直到到达其他部分。

6. 在左侧面板的 iOS 部分，选择杂项，然后在通用部分选择空白解决方案：

1. 现在，点击下一步按钮。

2. 在解决方案名称：文本框中输入 Chapter8.Xamarin。同时确保你已经选择了合适的存储位置：

1. 现在，点击创建。

2. 现在，解决方案资源管理器应该看起来像这样：

1. 现在，Ctrl + 点击 Chapter8.Xamarin 标签并选择添加 | 新项目。

2. 在左侧面板的 iOS 部分，选择应用程序，然后在右侧面板中选择单视图应用程序。

3. 确保选择 C# 作为编程语言：

1. 点击下一步按钮。

2. 新建项目对话框将显示。

3. 在应用程序名称：文本框中输入 Chapter8.Xamarin.iOSApp，在组织标识符：文本框中输入 com.chapter8，并取消选中 iPad。保持目标：操作系统不变：

1. 点击下一步。

2. 保持一切不变并点击创建：

1. 现在，解决方案资源管理器应该看起来像这样：

解决方案资源管理器

1. 现在，按下 command + return 以调试应用程序或按下解决方案资源管理器顶部的播放按钮。

2. 现在，你应该能看到 iOS 模拟器启动，它显示了应用的第一屏：

1. 恭喜！你已经测试了你的第一个 iOS 应用程序。

2. 现在，通过按下 shift + command + return 停止调试器。

它是如何工作的...

在步骤 1 到 3 中，我们打开了 Visual Studio for Mac，在步骤 6 到 9 中，我们创建了一个空白解决方案。我们还为该解决方案分配了一个合适的名称。这个空白解决方案将作为本章的基础。在步骤 11 到 18 中，我们将 iOS 单视图应用程序添加到解决方案中。在步骤 16 中，我们添加了一个组织标识符，这是在您部署到应用商店时识别您的应用程序的唯一标识符。单视图应用程序是一个入门模板，帮助开发者为 iOS 开发，并附带一个自定义的 ViewController 以便开始。我们也给它起了一个合适的名称。最后，在步骤 20 到 23 中，我们测试了 Visual Studio for Mac 生成的默认模板。

我们将在后面的菜谱中回到这个应用程序，并添加一些控件和一些代码。

创建 .NET Standard 2.0 库

在这个菜谱中，我们将使用 Visual Studio for Mac 构建 .NET Standard 2.0 库。我们将使用之前菜谱中的相同解决方案。

准备工作

确保您已经完成了之前菜谱中添加的 iOS 项目。如果是这样，让我们开始添加库并编写一些代码。

如何操作...

1. 打开 Finder。

2. 在左侧窗格中点击“应用程序”。

3. 现在，双击 Visual Studio 图标。

4. 现在，点击“打开”，定位到 Chapter8.Xamarin 解决方案，并打开它。

5. 解决方案资源管理器应该看起来像这样：

1. 现在，按住控制键 (^) + 点击 Chapter8.Xamarin 标签，然后选择“添加”|“新建项目”。

2. 在“新建项目”对话框中，滚动左侧窗格，直到看到“多平台”部分。

3. 在右侧窗格中点击“库”，然后在“常规”下选择 .NET Standard 库。同时确保已选择 C#：

1. 点击“下一步”。

2. 选择“目标框架：”为 .NET Standard 2.0 并点击“下一步”：

1. 在“项目名称：”文本框中，输入 Chapter8.Xamarin.iOSLib 作为名称，其余保持不变：

1. 点击“创建”。

2. 现在，解决方案资源管理器应该看起来像这样：

1. 选择 Class1.cs 标签并按 command + R 重命名。

2. 将其重命名为 HelloLib.cs。

3. 确保您还将类名从 Class1 更改为 HelloLib。

4. 现在，在 HelloLib 类内部，添加以下代码：

      public string SayHello(string yourName)
      {
          return $"Hello {yourName}, Greetings from iOS";
      }

1. 点击“生成”|“生成所有”以检查所有语法是否正确。

作用原理...

在步骤 1 到 4 中，我们打开了之前菜谱中创建的解决方案。在步骤 6 到 12 中，我们将 .NET Standard 2.0 库添加到解决方案中。现在，解决方案有两个项目，一个 iOS 项目和一个 .NET Standard 2.0 库项目。在步骤 14 到 16 中，我们重命名了 Visual Studio 创建的类。我们还重命名了实际的类名以匹配文件名。

在步骤 17 中，我们添加了一个公共方法，该方法接受一个 string 参数并返回一个欢迎消息作为字符串。最后，我们进行了快速构建以检查语法是否正确。

整合事物并测试应用程序

在这个菜谱中，我们将向 iOS 应用程序添加一些控件，并使用之前菜谱中创建的.NET Standard 2.0 库。

准备工作

确保你已经完成了前面的两个菜谱。它们是继续的必要条件。如果你已经完成了它们，让我们快速构建并开始。

如何操作...

1. 打开 Finder。

2. 在左侧窗格中点击“应用程序”。

3. 双击 Visual Studio 图标。

4. 点击“打开”，定位 Chapter8.Xamarin 解决方案，并打开它。

5. 解决方案资源管理器应该看起来像这样：

1. 现在，展开 Chapter8.Xamarin.iOSApp 项目节点。

2. 双击 Main.storyboard 文件。

3. 这将打开应用程序的故事板选项卡。

4. 你应该看到 iOS 应用程序的默认布局如下：

iOS 应用程序的默认布局

1. 现在，选择工具箱窗口。

2. 在 search 文本框内点击并输入 Button。

3. 现在，将按钮控件拖到画布中间的主白色区域。

4. 选择按钮。在属性窗口中，在标题标签下输入 Say Hello，在名称属性中输入 HelloButton。

5. 现在，你的画布应该看起来像这样：

1. 现在，在解决方案资源管理器中，control (^) + 点击“引用”标签并选择“编辑引用”。

2. 在“编辑引用”对话框中，点击“项目”选项卡。

3. 在列表中勾选 Chapter8.Xamarin.iOSLib 并点击确定：

1. 现在，双击 VeiwController.cs 文件以打开其代码。

2. 向上滚动到 using 指令，并添加以下 using 指令以访问库：

      using Chapter8.Xamarin.iOSLib;

1. 现在，向下滚动到 ViewDidLoad() 方法。

2. 在 base.ViewDidLoad() 行旁边添加以下代码：

      HelloButton.TouchUpInside += (object sender, EventArgs e) =>
      {
          var greetings = new HelloLib();
          var message = greetings.SayHello("Fiqri Ismail");

          //Create an alert box    
          var greetingsAlert = UIAlertController.Create("Hello", 
              message, UIAlertControllerStyle.Alert);
          greetingsAlert.AddAction(UIAlertAction.Create("OK", 
              UIAlertActionStyle.Default, null));

          PresentViewController(greetingsAlert, true, null);
       };

1. 现在，按 command + return 键来调试应用程序。

2. 你应该看到以下输出：

1. 现在，点击“说你好”按钮：

1. 现在，点击确定并停止调试。

工作原理...

在步骤 1 到 6 中，我们打开了一个现有的项目解决方案。在步骤 10 到 13 中，我们在画布上添加了一个简单的按钮控件。之后，我们更改了按钮的标题和名称属性。在步骤 17 中，我们从 iOS 项目添加了对库的引用。同样，在步骤 19 中，我们从代码级别添加了对.NET Standard 库的引用。

在第 21 步中，我们添加了代码来触发按钮触摸抬起事件。此事件在您在真实设备上触摸并抬起手指时触发，但在模拟器中，它会在您点击按钮时触发。我们是在ViewDidLoad()方法中添加的这段代码。该方法在视图加载后触发。在代码的前两行中，我们从一个库中创建了一个HelloLib类的实例。然后，我们执行了SayHello方法，并将返回值保存在一个变量中。

然后，我们创建了一个警报框来显示加尔各答消息，并附带一个确定按钮。最后，在第 23 步和第 24 步中，我们测试了我们刚刚构建的 iOS 应用程序。

第九章：使用 Xamarin 进入 Android

在本章中，我们将探讨以下食谱：

• Hello Android – 创建 Xamarin Android 应用程序

• 将.NET Standard 2.0 库添加到 Xamarin 项目

• 将事物组合在一起并测试应用程序

技术要求

读者应具备 C#的基本知识。他们还应具备使用 Visual Studio、使用 NuGet 安装包以及在其他项目中引用库的基本知识。

本章的代码文件可以在 GitHub 上找到：

github.com/PacktPublishing/DotNET-Standard-2-Cookbook/tree/master/Chapter09/Chapter9.Xamarin

查看以下视频以查看代码的实际操作：

goo.gl/dMi9PZ

简介

在本章中，我们将探讨使用 Visual Studio for Mac 构建 Android 应用程序。我们还将构建一个 Android 应用程序将使用的.NET Standard 2.0 类库。Visual Studio for Mac 允许您使用您喜欢的 C#编程语言构建基于 Xamarin 的应用程序，用于 iOS、Android 和 Windows。它还默认支持 F#。在前一章第八章“使用 Xamarin 进入 iOS”中，我们讨论了如何安装 Visual Studio for Mac。

Hello Android – 创建 Xamarin Android 应用程序

在本食谱中，我们将探讨 Visual Studio for Mac 对基于 Android 的应用程序的支持。我们将查看一个 Android 项目，为其设置解决方案，并检查所需的所有组件。

准备工作

确保您已为 macOS 系统安装了 Visual Studio for Mac。如果没有，请遵循“安装 Visual Studio for Mac”和“准备”食谱，该食谱展示了如何安装它。

如何操作...

1. 打开 Finder。

2. 在左侧窗格中单击“应用程序”。

3. 现在，双击 Visual Studio 图标：

Visual Studio

1. 单击“新建项目”按钮。

2. 在“为您的项目选择模板”对话框中，向下滚动直到到达其他部分。

3. 选择“杂项”，然后在“通用”下选择“空白解决方案”：

1. 现在，单击“下一步”按钮。

2. 在“解决方案名称：”文本框中键入Chapter9.Xamarin。同时确保您已选择合适的位置：

1. 现在，单击“创建”。

2. 现在，解决方案资源管理器应如下所示：

1. 现在，在Chapter9.Xamarin标签上control (^)+单击，然后选择“添加”|“新建项目”。

2. 在左侧窗格的 Android 部分下选择“应用程序”。在右侧窗格中选择“Android 应用程序”。

3. 确保已选择 C#作为编程语言：

1. 单击“下一步”。

2. 现在，在“应用程序名称：”文本框中，键入 Chapter9.Xamarin.AndroidApp，在“组织标识符：”文本框中，键入 com.chapter9。其余的保持不变：

1. 单击下一步。

2. 保持一切不变并单击创建：

1. 现在，解决方案资源管理器应该看起来像这样：

1. 现在，你应该看到默认模板已经有一个工作中的应用程序。

2. 按下 command + return 键来调试应用程序。

3. 现在，你应该在模拟器中看到默认的 HelloWorld 应用程序正在运行：

1. 点击按钮以查看其动作。按 shift + command + return 停止调试。

它是如何工作的...

在步骤 1 到 10 中，我们创建了一个空白解决方案并给它起了个合适的名字。在步骤 10 中，我们向该解决方案添加了一个 Android App 项目。Android App 项目是由 Visual Studio for Mac 创建的默认模板。这是一个用于测试所有内容是否完整的原型应用程序。

如果你查看解决方案资源管理器并单击 MainActivity.cs 文件，你会看到所有的动作。在 OnCreate() 方法中，代码看起来像这样：

base.OnCreate(savedInstanceState);

// Set our view from the "main" layout resource
SetContentView(Resource.Layout.Main);

// Get our button from the layout resource,
// and attach an event to it
Button button = FindViewById<Button>(Resource.Id.myButton);

button.Click += delegate { button.Text = $"{count++} clicks!"; };

你可以看到一个简单的按钮。当你点击按钮时，它的增量会被计数，并且更新按钮标签。FindViewById 会定位按钮并创建一个 Button 类。最后，button.Click 事件触发计数过程并将其存储在按钮标题中。

将 .NET Standard 2.0 库添加到 Xamarin 项目

在这个菜谱中，我们将查看创建一个 .NET Standard 2.0 库并将默认的计数代码移动到库中。计数代码是由 Visual Studio for Mac 为 Android 应用程序创建的默认模板。

准备工作

确保你已经完成了创建默认 Android 应用程序的上一道菜谱。如果你已经完成了，让我们打开那个解决方案并开始吧。

如何操作...

1. 打开 Finder。

2. 在左侧窗格中单击“应用程序”。

3. 现在，双击 Visual Studio 图标。

4. 单击“打开”，定位 Chapter9.Xamarin 解决方案，并打开它。

5. 解决方案资源管理器应该看起来像这样：

1. 现在，按住 control (^) + 点击 Chapter9.Xamarin 标签并选择添加 | 新项目。

2. 在“新建项目”对话框中，将左侧窗格向下滚动，直到看到“多平台”部分。

3. 点击“库”并在右侧窗格的“常规”下选择 .NET Standard 库。同时确保已选择 C#：

1. 单击下一步。

2. 选择目标框架：为 .NET Standard 2.0 并单击下一步：

1. 在“项目名称：”文本框中，键入 Chapter9.Xamarin.AndroidLib 作为名称，其余的保持不变：

1. 单击创建。

2. 现在，解决方案资源管理器应该看起来像这样：

1. 现在，选择Class1.cs标签并按 command + R 来重命名。

2. 将其重命名为CounterLib.cs。

3. 确保您还将类名从Class1更改为CounterLib。

4. 现在，在CounterLib类内部添加以下代码：

      public int IncrementByOne(int value)
      {
          return value++;
      }

1. 点击构建 | 构建全部以检查所有语法是否正确。

它是如何工作的...

在步骤 1 到 4 中，我们打开了之前菜谱中创建的解决方案。在步骤 6 到 12 中，我们将.NET Standard 2.0 库添加到解决方案中。现在，解决方案有两个项目：一个 Android 项目和.NET Standard 2.0 库项目。在步骤 14 到 16 中，我们重命名了在 Visual Studio 中创建的类。我们还重命名了实际的类名以匹配文件名。

在步骤 17 中，我们添加了一个公共方法，该方法接受一个整数参数，并返回一个比提供的值增加 1 的整数值。最后，我们进行了快速构建以检查语法是否正确。

将事物组合在一起并测试应用程序

在这个菜谱中，我们将把所有东西组合在一起并测试最终的应用程序。我们将从 Android 应用程序中引用.NET Standard 2.0 库并使用 Android 应用程序中的库。

准备工作

确保您已经完成了构建.NET Standard 2.0 库的先前菜谱。如果您已经完成，请打开解决方案并开始此应用程序。

如何做...

1. 打开 Finder。

2. 在左侧窗格中点击“应用程序”。

3. 现在，双击 Visual Studio 图标。

4. 点击“打开”，定位到Chapter9.Xamarin解决方案，并打开它。

5. 解决方案资源管理器应该看起来像这样：

1. 现在，展开Chapter9.Xamarin.AndroidApp项目节点。

2. 在解决方案资源管理器中，控制 (^) + 点击“引用”标签并选择“编辑引用”。

3. 在“编辑引用”对话框中，点击“项目”选项卡。

4. 在列表中检查Chapter9.Xamarin.AndroidLib并点击“确定”：

1. 向上滚动直到到达using指令，并添加以下using指令以访问库：

      using Chapter9.Xamarin.AndroidLib;

1. 现在，双击 MainActivity.cs 文件以打开其代码。

2. 在MainActivity类下，找到以下代码：

      int count = 1; 

用以下代码替换之前的代码：

      int count = 0;

1. 现在，向下滚动直到你到达OnCreate()方法。

2. 在base.OnCreate()行旁边添加以下代码：

      CounterLib counter = new CounterLib();

1. 现在，将默认按钮点击代码替换为以下代码：

      button.Click += delegate { 
          count = counter.IncrementByOne(count);
          button.Text = $"{count} clicks!";
      };

1. 按 command + return 来调试应用程序。

2. 点击按钮几次，你应该会看到以下输出：

1. 按 shift + command + return 来停止调试。

它是如何工作的...

在步骤 1 到 6 中，我们打开了之前在先前的菜谱中创建的现有解决方案。在步骤 9 中，我们从 Android 应用程序中添加了对库的引用。在步骤 10 中，我们添加了对库的代码级别引用。这将使我们能够获取库中所有可用的方法。在步骤 12 中，我们修改了现有的代码。在步骤 14 中，我们创建了一个CounterLib()实例并将其存储在一个变量中。

在步骤 15 中，我们又对按钮现有的点击代码进行了一小改动，以使用类库中的IncrementByOne()方法。最后，在步骤 16、17 和 18 中，我们测试了我们的新代码。

第十章：让我们调整我们的库

在本章中，我们将探讨以下食谱：

• 记录库

• 创建一个.NET Core 控制台应用程序以使用库

• 通知最终用户 - 异常处理和错误消息

• 使用 Visual Studio 2017 的诊断和调试工具

技术要求

读者应具备 C#的基本知识。他们还应具备使用 Visual Studio、使用 NuGet 安装包以及在其他项目中引用库的基本知识。

本章的代码文件可以在 GitHub 上找到：

github.com/PacktPublishing/DotNET-Standard-2-Cookbook/tree/master/Chapter10/Chapter10.Logging

查看以下视频以查看代码的实际效果：

goo.gl/HNVQMh

简介

在本章中，我们将探讨如何调整我们的.NET Standard 2.0 库，如何创建日志，以及如何使用 Visual Studio 2017 中可用的调试工具。我们还将探讨异常处理。在前面的章节中，我们一直在探讨如何构建库及其利用。在本章中，我们将使该库变得更好、更稳固。

库会自己记录信息

在这个食谱中，我们将使用文本日志文件来存储有关库如何与其他程序交互的详细信息。这是一个好的做法；边走边记录。然后，您将能够定位错误和其他重要事项，例如库的使用。

准备工作

确保您的系统上已安装最新版本的 Visual Studio 2017。让我们开始我们的食谱。

如何操作...

1. 打开 Visual Studio 2017。

2. 点击文件 | 新建 | 项目创建项目。

3. 在“新建项目”对话框中，展开左侧窗格中的“其他项目类型”节点，并选择 Visual Studio 解决方案。在右侧窗格中，选择空白解决方案。

4. 在“名称”文本框中，输入Chapter10.Logging，并在“位置”文本框中，从下拉框中选择路径或点击浏览...按钮定位路径：

1. 点击确定。

2. 现在，解决方案资源管理器（Ctrl + Alt + L）应该看起来像这样：

1. 现在，在解决方案资源管理器中的Chapter10.Logging标签上右键单击，然后选择添加 | 新项目。

2. 在“新建项目”对话框中，展开 Visual C#节点。

3. 在左侧窗格中选择.NET Standard，在右侧窗格中选择类库(.NET Standard)：

1. 在“名称”文本框中，输入Chapter10.Logging.LogLib，保留其他默认设置，然后点击确定：

1. 现在，解决方案资源管理器（Ctrl + Alt + L）应该看起来像这样：

1. 现在，在解决方案资源管理器中选择Class1.cs，然后按F2重命名文件为LoggerDemo.cs。

2. 在询问是否重命名类名的确认对话框中回答“是”。

3. 双击解决方案资源管理器中的LoggerDemo.cs标签。

4. 让我们在代码窗口中向上滚动并添加以下using指令：

      using System.IO;

1. 现在，创建两个类级别变量来保存文件名和StreamWriter类：

      private string logFileName = "lib_log.txt";
      private StreamWriter logFile;

1. 现在，创建默认构造函数方法如下：

      public LoggerDemo()
      {
          WriteLog("Constructor Called.");
      }

1. 再次创建这个private方法来将日志详细信息写入文件：

      private void WriteLog(string message)
      {
          if (!File.Exists(logFileName))
          {
              logFile = File.CreateText(logFileName);
          }
          else
          {
              logFile = File.AppendText(logFileName);
          }

          logFile.WriteLine($"{DateTime.Now} Log Message: {message} ");
          logFile.Close();
      }

1. 创建以下这三个public方法：

      public void CallMethod1()
      {
          WriteLog("Method 1 Called");
      }

      public void CallMethod2()
      {
          WriteLog("Method 2 Called");
      }

      public void CallMethod3()
      {
          WriteLog("Method 3 Called");
      }

1. 按Ctrl + Shift + B构建解决方案。

工作原理...

在步骤 1 到 11 中，我们在解决方案中创建了一个空白解决方案并添加了一个.NET Standard 2.0 库。在这些步骤中，我们为解决方案和库分配了合适的名称。在步骤 12 和 13 中，我们将 Visual Studio 创建的现有Class1.cs重命名。在步骤 15 中，我们创建了一个using指令来访问文件操作。

在步骤 16 中，我们创建了两个private变量来保存文件名和StreamWriter类。在步骤 17 中，我们创建了默认构造函数，并调用了我们在步骤 18 中创建的WriteLog()方法。在步骤 19 中，我们创建了三个测试方法来演示日志记录。最后，在步骤 20 中，我们进行了快速构建以检查语法。

创建一个.NET Core 控制台应用程序来使用库

在这个配方中，我们将创建一个.NET Core 控制台应用程序来使用前面配方中的库。你还可以在 macOS 或 Linux 上尝试这个配方，因为.NET Core 是跨平台的。

准备工作

确保你已经完成了前面的配方并且构建成功。让我们打开解决方案并做好准备。

如何操作...

1. 打开 Visual Studio 2017。

2. 现在，打开前面配方中的解决方案。点击 文件 | 打开 | 打开项目/解决方案，或按 Ctrl + Shift + O，选择Chapter10.Logging解决方案。

3. 按Ctrl + Shift + B进行快速构建以检查一切是否正常。

4. 点击Chapter10.Logging解决方案标签。点击 文件 | 添加 | 新建项目。

5. 在 添加新项目 模板对话框中，展开左侧窗格中的 Visual C#节点。

6. 选择 .NET Core 并在右侧窗格中选择 控制台应用程序 (.NET Core)：

1. 在名称：文本框中，将项目名称输入为Chapter10.Logging.LogCore。其余字段可以保持不变：

1. 点击“确定”。

2. 现在，解决方案资源管理器（按Ctrl + Alt + L）应该看起来像这样：

1. 右键单击Chapter10.Logging.LogCore下的依赖项标签。

2. 选择添加引用。

3. 在引用管理器中，点击右侧窗格中的项目标签：

1. 在左侧窗格中检查Chapter10.Logging.LogLib项目。

2. 点击“确定”。

3. 现在，双击解决方案资源管理器中的Program.cs标签。

4. 滚动直到看到using指令。

5. 在using指令的最后一行旁边添加以下引用：

      using Chapter10.Logging.LogLib;

1. 现在，将Main()方法中的现有代码替换为以下代码：

      var logDemo = new LoggerDemo();

      Console.WriteLine("Executing method 1");
      logDemo.CallMethod1();

      Console.WriteLine("Executing method 2");
      logDemo.CallMethod2();

      Console.WriteLine("Executing method 3");
      logDemo.CallMethod3();

      Console.WriteLine("Press ENTER to exit.");
      Console.ReadLine();

1. 按F5键进行调试代码。

2. 你应该看到以下输出：

1. 按Enter键退出。

2. 你还会看到在bin/Debug文件夹中创建了一个lib_log.txt文件（确保你已经点击了显示所有文件）：

1. lib_log.txt文件应该有以下输出：

如何工作...

在第 1 步到第 10 步中，我们从上一个菜谱打开了解决方案并添加了一个.NET Core 控制台应用程序。在这些步骤中，我们给它起了个合适的名字。在第 17 步中，我们向库添加了代码级别的引用。在第 18 步中，我们在Main方法中创建了代码。在第一行，我们创建了一个LoggerDemo类的实例并将其存储在一个变量中。在接下来的几行中，我们执行了public方法CallMethod1()、CallMethod2()和CallMethod3()。

最后，在第 19 步和第 20 步中，我们执行了代码并进行了测试。在第 21 步和第 22 步中，我们调查了从库中创建的文本文件。

通知最终用户 – 异常处理和错误消息

在这个菜谱中，我们将查看.NET 类库中的异常处理。我们将重用本章第一个菜谱中创建的相同库。

准备工作

确保你已经完成了本章的两个菜谱。打开解决方案并快速构建以检查一切是否正常且编译良好。

如何做...

1. 打开 Visual Studio 2017。

2. 现在，打开上一个菜谱的解决方案。点击文件 | 打开 | 打开项目/解决方案，或者按Ctrl + Shift + O，然后选择Chapter10.Logging解决方案。

3. 按Ctrl + Shift + B进行快速构建以检查一切是否正常。

4. 解决方案资源管理器应该看起来像这样：

1. 现在，双击LoggerDemo.cs标签以打开代码窗口。

2. 滚动直到到达WriteLog()方法。

3. 将当前代码替换为以下代码：

      try
      {
          if (!File.Exists(logFileName))
          {
              logFile = File.CreateText(logFileName);
          }
          else
          {
              logFile = File.AppendText(logFileName);
          }

          logFile.WriteLine($"{DateTime.Now} Log Message: {message} ");
      }
      catch (FileNotFoundException)
      {
          //Cannot find the file you are looking for
      }
      catch (Exception ex)
      {
          //Catch any exception 
      }
      finally
      {
          logFile.Close(); 
      }

1. 现在，单击.NET Core 控制台应用程序项目并按F5进行测试。

如何工作...

在第 1 步到第 5 步中，我们打开了现有的解决方案。在第 7 步中，我们在库中的WriteLog()方法中添加了异常处理。在代码的第一行中，我们添加了关键字try。 在其中，我们创建了创建文本文件的代码。然后，在第一个catch子句中捕获了一个FileNotFoundException。这是一个好习惯；捕获确切的异常。如果你已经捕获了所有异常，那么你可以捕获默认的exception。

最后，我们使用了一个finally子句来关闭文件流。finally子句将始终在try...catch块中执行。在finally子句中包含清理代码是一个好习惯。

使用 Visual Studio 2017 诊断和调试工具

在这个菜谱中，我们将探讨如何使用 Visual Studio 2017 及其调试工具调试 .NET Standard 2.0 库。我们将使用之前菜谱中创建的相同解决方案。

准备工作

确保你已经完成了之前的菜谱，并且没有问题地构建了它们。让我们开始吧。

如何操作...

1. 打开 Visual Studio 2017。

2. 现在，打开之前菜谱中的解决方案。点击 文件 | 打开 | 打开项目/解决方案，或按 Ctrl + Shift + O，然后选择Chapter10.Logging解决方案。

3. 按Ctrl + Shift + B进行快速构建以检查一切是否正常。

4. 解决方案资源管理器应该看起来像这样：

1. 现在，双击LoggerDemo.cs标签以打开代码窗口。

2. 滚动直到到达WriteLog()方法。

3. 现在，如图所示，点击代码窗口左侧的灰色栏以添加一个调试点：

1. 再次，点击Program.cs标签页。

2. 按F5键以调试代码。

3. 如你所见，光标将停在调试点上：

1. 现在，将鼠标指针移到WriteLog()方法的message参数上：

1. 现在，你可以看到那个变量里面存储的内容了。

2. 点击以下图中突出显示的小绿色箭头：

1. 你应该看到调试点跳转到了logFile.WriteLine方法。

2. 在屏幕的右侧，你应该能看到诊断工具窗口：

1. 此外，在底部，你应该能看到监视窗口和调用堆栈窗口：

1. 现在，通过按Shift + F5停止调试。

它是如何工作的...

在步骤 1 到 5 中，我们打开了包含.NET Standard 库及其配套.NET Core 应用程序的现有解决方案。在步骤 10 中，我们在代码中添加了一个调试点。在步骤 11 中，我们看到它已经停止在.NET Standard 2.0 库本身上。从那时起，它就像一个正常的调试应用程序一样运行。Visual Studio 知道我们正在寻找库中的代码。

在步骤 13 中，我们将鼠标指针移到了库代码本身中的WriteLog()方法的string参数上。Visual Studio 向我们显示了该参数内的值。同样，在步骤 13 中，我们看到我们可以跳转到代码中的任何我们想要的地方。这是 Visual Studio 2017 的新特性。在步骤 15 中，我们看到了可用的诊断工具，包括事件、内存和 CPU 使用情况。这些工具帮助我们像正常的 C#代码一样微调我们的库。

最后，我们查看监视和调用堆栈窗口，它们是自我解释的。

第十一章：打包和交付

在本章中，我们将探讨以下菜谱：

• 创建.NET Standard 2.0 库

• 创建你的库的 NuGet 包

• 将包提交到 NuGet 包管理器

• 创建经典 Windows 应用程序并测试 NuGet 包

技术要求

读者应具备 C#的基本知识。他们还应具备使用 Visual Studio、使用 NuGet 安装包以及在其他项目中引用库的基本知识。

本章的代码文件可以在 GitHub 上找到：

github.com/PacktPublishing/DotNET-Standard-2-Cookbook/tree/master/Chapter11

查看以下视频以查看代码的实际操作：

goo.gl/XuznM7

简介

在本章中，我们将探讨如何创建你的库的 NuGet 包。我们将创建一个基本库，然后创建一个 NuGet 包并提交它。最后，我们将在两个不同的应用程序中使用该包。

NuGet 是.NET 应用程序的包交付工具。它避免了寻找包或库所需的所有依赖项的麻烦。例如，如果你正在寻找库 A，并且它需要几个其他库，如库 B 和库 C，你只需获取库 A。NuGet 将为你节省搜索库 B 和 C 以及安装和配置它们的时间。

创建.NET Standard 2.0 库

在这个菜谱中，我们将创建一个用于打包的基本.NET Standard 2.0 库；为了演示目的，我们将创建一个小计算器库。

准备工作

确保你的系统上已安装并更新了最新版本的 Visual Studio 2017。这个菜谱假设你具备创建.NET Standard 2.0 库的相当多的知识。

如何做...

1. 打开 Visual Studio 2017。

2. 点击文件 | 新建 | 项目，然后在新建项目模板对话框中，在左侧窗格中选择其他项目类型下的Visual Studio 解决方案，在右侧窗格中选择空白解决方案。

3. 在名称：文本框中，键入Chapter11.Packaging作为解决方案的名称，如图所示。在位置下拉列表中选择一个首选位置，或单击浏览...按钮并选择一个位置。保持默认设置不变：

1. 点击“确定”。

2. 现在，在解决方案资源管理器中（或按Ctrl + Alt + L），选择Chapter11.Packaging。右键单击并选择添加 | 新建项目。

3. 在添加新项目对话框中，展开 Visual C#节点，并在左侧窗格中选择.NET Standard。

4. 在右侧窗格中，选择如图所示的类库(.NET Standard)：

1. 现在，在名称文本框中，键入Chapter11.Packaging.CalcLib，并保持位置：文本框不变：

1. 点击确定。

2. 现在，解决方案资源管理器应该看起来像这样：

1. 点击 Class1.cs 并按 F2 重命名它。将新名称输入为 Calculator.cs。

2. 选择是以确认类名的重命名。

3. 现在，将这些两个公共方法添加到类体中：

      public int Add(int num1, int num2)
      {
          return num1 + num2;
      }

      public int Subtract(int num1, int num2)
      {
          return num1 - num2;
      }

1. 按 Ctrl + Shift + B 进行快速构建。

它是如何工作的...

在步骤 1 到 10 中，我们创建了一个空白解决方案并给它起了适当的名字。然后我们向解决方案中添加了一个 .NET Standard 2.0 类库。在步骤 11 和 12 中，我们将默认的 Class1.cs 重命名为更有意义的东西。是的，你可以随时删除这个类并创建一个新的。在步骤 13 中，我们为两个整数的加法和减法创建了两个简单的方法。

最后，我们在步骤 14 中进行了快速构建以进行语法检查。

创建您库的 NuGet 包

在这个食谱中，我们将探讨如何从上一个食谱中刚刚构建的库中创建一个 NuGet 包。

准备工作

确保你已经完成了前面的食谱，或者你已经有一个现成的 .NET Standard 库。让我们开始吧。

如何操作...

1. 打开 Visual Studio 2017。

2. 现在，打开上一个食谱中的解决方案。点击文件 | 打开 | 打开项目/解决方案，或者按 Ctrl + Shift + O，并选择 Chapter11.Packaging 解决方案。

3. 现在，解决方案资源管理器应该看起来像这样：

1. 现在，点击 Chapter11.Packaging.CalcLib 项目标签以选择它。

2. 右键单击并选择属性。

3. 在属性选项卡中，点击包标签：

1. 现在，填写信息，它应该看起来像这样：

1. 现在，保存并关闭。

2. 再次，在工具栏中，从调试区域选择发布：

1. 现在，再次在解决方案资源管理器中，右键单击 Chapter11.Packaging.CalcLib 标签。

2. 选择打包：

1. 这应该在您的位置构建并创建一个 NuGet 包。

2. 你可以在输出窗口中看到位置，如下所示：

它是如何工作的...

这些步骤是自我解释的。当你遵循这些步骤时，你将能够看到选中的 NuGet 包。在第 7 步中，如果你真的想让你的客户明确接受你的模块的许可条款，可以将“要求接受许可”设置为 true。最重要的步骤是第 9 步，其中你将构建选项设置为发布。确保当你将库上传到那里时，你做了这件事——不是调试版本，总是发布版本。

将包提交到 NuGet 包管理器

在本教程中，我们将探讨如何提交在前一个教程中创建的 NuGet 包。要向 NuGet 提交包，您将需要登录。如果您有 Microsoft Live 账户，这很简单；否则，您始终可以在 NuGet 网站本身创建一个 nuget.org 账户。

准备中

确保您已经完成了前面的教程并创建了一个 NuGet 包。另外，拥有一个 Microsoft Live 账户可以让登录过程更加顺畅，但是的，您始终可以创建一个 NuGet 账户。

如何操作...

1. 打开您首选的浏览器。

2. 在地址栏中，键入 www.nuget.org 并按 Enter。

3. 现在，点击右上角的“登录”链接：

1. 使用您的 Microsoft 账户或创建一个 NuGet 账户然后登录：

1. 登录成功后，点击“上传”链接。

2. 现在，在这个屏幕上，您可以拖放您的包，或者您可以浏览包：

1. 现在，点击“浏览...”按钮并定位您的包（或者您可以将包拖放到这里）：

1. 点击“打开”。

2. 在下一屏，您将需要确认您的包的详细信息。

3. 如果您对此满意，请点击屏幕底部的“提交”按钮：

1. 成功提交后，您应该看到这个屏幕：

1. 几分钟后，您应该会看到您包的安装说明：

它是如何工作的...

所有这些步骤都解释了如何创建和提交您的 NuGet 包。但是，您需要记住一些事情，比如适当的命名和提交库之前的测试。始终确保您更新库到新版本，因为它们将包含修复错误的补丁，这将使您最终能够交付一个非常好的产品。

创建经典 Windows 应用程序并测试 NuGet 包

在本教程中，我们将探讨创建经典 Windows 应用程序并使用前一章中提交的 NuGet 包。我们将创建一个新的项目并使用这个库。

准备中

确保您已经完成了提交 NuGet 包的前一个教程。确保包在 nuget.org 上已准备好安装。

如何操作...

1. 打开 Visual Studio 2017。

2. 点击“文件”|“新建项目”并在 Visual C# 下的右侧窗格中选择 Windows Classic Desktop：

3. 在右侧窗格中选择 Windows Forms App (.NET Framework)：

1. 现在，在“名称：”文本框中，键入 Chapter11.Packaging.WinAppUsage，并在“位置：”文本框下选择一个合适的地点，其他字段保持不变：

1. 点击“确定”。

2. 解决方案资源管理器（Ctrl + Alt + L）应该看起来像这样：

1. 现在，点击Form1.cs并将其名称更改为MainForm.cs。

2. 确认更改类名。

3. 现在，将两个按钮拖到设计器中的表单上。

4. 按照以下方式更改按钮的属性：

   控件	属性	值
   按钮	名称	BtnAdd
   按钮	文本	Add
   按钮	名称	BtnSub
   按钮	文本	Subtract
   表单	名称	MainForm
   表单	文本	Simple Calculator

5. 现在，你的表单应该看起来像这样：

1. 现在，在引用标签上右键单击。

2. 选择管理 NuGet 包。

3. 点击浏览，在搜索框中输入你上传时选择的包 ID。

4. 在这个情况下，输入Packt_DotNetStandard_CookBook_Chap1，然后按Enter：

1. 现在，点击该包。

2. 在右侧窗格中点击安装按钮：

1. 在确认对话框中点击确定：

1. 现在，在解决方案资源管理器中，展开引用标签，你应该在那里看到我们的库：

1. 现在，双击添加按钮进入代码窗口。

2. 向上滚动直到看到using指令。

3. 在using指令的末尾添加以下指令。

      using Chapter11.Packaging.CalcLib;

1. 现在，向下滚动直到到达BtnAdd_Click()方法。

2. 在方法内部添加以下代码：

      var calculator = new Calculator();
      var answer = calculator.Add(10, 20);

      MessageBox.Show($"The answer is {answer}");

1. 现在，双击减按钮，并在click方法内部添加以下代码：

      var calculator = new Calculator();
      var answer = calculator.Subtract(50, 20);

      MessageBox.Show($"The answer is {answer}");

1. 现在，按F5测试应用程序。

2. 点击添加按钮，你应该会看到如下输出：

1. 对减按钮也做同样的操作。

2. 点击确定并关闭窗口。

它是如何工作的...

在步骤 1 到 7 中，我们创建了一个经典的 Windows 应用程序项目。然后，在步骤 9 到 11 中，我们创建了 Windows 项目的 UI。在步骤 14 和 15 中，我们打开了 NuGet 包管理器。然后我们搜索我们的包并确认它已加载。在步骤 18 到 20 中，我们安装了我们的包并确认它已安装。

在步骤 24 中，我们添加了使用 NuGet 包管理器安装的库的引用。在步骤 25 和 26 中，我们创建了一个Calculator类的实例并使用了它的Add()和Subtract()方法。最后，在步骤 28 到 30 中，我们测试了应用程序。

使用包管理器是从 NuGet 安装包的一种方式。但你可以使用 NuGet 包管理器控制台来完成同样的操作。要访问包管理器控制台，你可以点击工具 | NuGet 包管理器 | 包管理器控制台：

在控制台中，你可以输入：

Install-Package Packt_DotNetStandard_CookBook_Chap11 -Version 1.0.0

此方法将执行相同操作并将您的包安装到项目中。

第十二章：部署

在本章中，我们将查看以下菜谱：

• 创建免费的 Azure 云订阅

• 创建一个 ASP.NET Core 网络应用程序以使用来自 NuGet 的库

• 将应用程序部署到 Azure 云

技术要求

读者应该具备基本的 C# 知识。他们还应该了解如何使用 Visual Studio，使用 NuGet 安装包，以及在其他项目中引用项目中的库。

本章的代码文件可以在 GitHub 上找到：

github.com/PacktPublishing/DotNET-Standard-2-Cookbook/tree/master/Chapter12/Chapter12.Azure.WebAppCore

查看以下视频以查看代码的实际操作：

goo.gl/syvoGK

简介

在本章中，我们将使用我们在上一章中工作的库。在那个章节中，我们创建了一个库并将其提交到 NuGet。我们将使用相同的库与 ASP.NET core 应用程序一起部署到 Azure 并进行测试。

创建免费的 Azure 云订阅

在这个菜谱中，我们将为您创建一个 Azure 免费帐户。这将帮助您在 Azure 上部署应用程序。我们将使用 Visual Studio 的 Azure 工具来部署我们的项目。在撰写本书时，Microsoft 允许您创建一个价值 200 美元的免费帐户；它也免费提供一年。

准备工作

在开始此过程之前，请确保您有一张有效的信用卡。信用卡仅用于验证目的。

如何操作...

1. 打开您喜欢的浏览器。

2. 输入 azure.microsoft.com，然后按 Enter：

1. 现在，点击右上角的绿色“免费帐户”按钮，或点击左侧的“开始免费”按钮。

2. 之后，您将看到一个信息屏幕。

3. 再次，点击右上角的“开始免费”按钮，或点击左侧的“开始免费”按钮。

4. 然后，您将被要求使用 Microsoft 帐户或任何其他帐户登录。

5. 登录后，您将被要求提供付款信息。按照说明操作，您就可以使用新的 Azure 帐户开始了。

6. 完成所有这些后，您将看到 Azure 门户。

7. 否则，在地址栏中输入 portal.azure.com，然后按 Enter。

8. 你应该会看到 Azure 门户，并且屏幕应该类似于以下内容：

Azure 门户

它是如何工作的...

步骤很简单，您只需按照 Azure 门户上的说明创建新的订阅即可。

创建一个 ASP.NET core 网络应用程序以使用来自 NuGet 的库

在这个菜谱中，我们将创建一个 ASP.NET core 网络应用程序，然后我们将安装我们在上一章上传到 NuGet 的 .NET Standard 2.0 库。

准备工作

确保您已安装并更新了最新的 Visual Studio 2017 版本，并且已经完成了上一章的内容。

如何操作...

1. 打开 Visual Studio 2017。

2. 点击文件 | 新建 | 项目，然后在 Visual C#下的右侧窗格中选择 Web。

3. 在右侧窗格中选择 ASP.NET Core Web 应用程序：

1. 现在，在名称：文本框中，输入Chapter12.Azure.WebAppCore，并在位置：文本框下选择一个合适的位置，其他字段保持不变：

1. 点击确定。

2. 在新的 ASP.NET Core Web 应用程序对话框中，选择空，其他字段保持不变：

1. 点击确定。

2. 解决方案资源管理器(Ctrl + Alt + L)应该看起来像这样：

1. 现在，右键单击依赖项标签。

2. 选择管理 NuGet 包。

3. 点击浏览，并在搜索框中输入您在上传时选择的包 ID。

4. 在这种情况下，输入Packt_DotNetStandard_CookBook_Chap1并按Enter键：

1. 现在，点击包。

2. 在右侧窗格中点击安装按钮：

1. 在确认对话框中点击确定。

1. 安装成功后，输出窗口应该看起来像这样：

1. 现在，在解决方案资源管理器中，展开依赖项| NuGet 选项卡，你应该在那里看到我们的库：

1. 现在，双击Startup.cs按钮以进入代码窗口。

2. 向上滚动，直到看到using指令。

3. 在using指令的末尾添加以下指令：

      using Chapter11.Packaging.CalcLib;

1. 现在，向下滚动，直到到达Configure()方法内的app.Run()方法。

2. 用以下代码替换：

      var calculator = new Calculator();
      var answer = calculator.Add(10, 50);

      await context.Response.WriteAsync($"Answer for 10+50 
          is {answer}");

1. 按F5进行调试。

2. 你应该得到如下输出：

它是如何工作的...

在步骤 1 到 9 中，我们创建了一个 ASP.NET 核心项目。我们为这个食谱选择了一个空项目。之后，在步骤 10 到 17 中，我们安装了上一章创建的库。我们使用 NuGet 包管理器安装它，并确认库已成功安装。

在步骤 20 中，我们使用using指令引用了库。最后，在步骤 22 中，我们创建了一个Calculator类的实例并将其存储在一个变量中。最后，我们使用WriteAsync()方法将输出发送到浏览器。在步骤 24 中，我们在浏览器中测试了我们的应用程序。

将应用程序部署到 Azure 云

在本食谱中，我们将探讨如何将我们的应用程序部署到 Azure。我们将使用 Visual Studio 2017 将应用程序部署到 Azure App Service。

准备工作

确保您有一个 Azure 账户。如果没有，您可以在 azure.microsoft.com 创建一个免费账户。此外，请确保您已经完成了之前的食谱。我们将需要带有最新更新的 Visual Studio 2017。让我们开始吧。

如何操作...

1. 打开 Visual Studio 2017。

2. 现在，打开之前食谱中的解决方案。点击文件 | 打开 | 打开项目/解决方案，或者按 Ctrl + Shift + O，并选择 Chapter12.Azure.WebAppCore 解决方案。

3. 解决方案资源管理器 (Ctrl + Alt + L) 应该看起来像这样：

1. 现在，右键单击 Chapter12.Azure.WebAppCore 并选择发布。

2. 在选择发布目标窗口中，在左侧窗格中选择应用程序服务，在右侧窗格中选择创建新：

1. 点击发布。

2. 现在，在创建应用程序服务屏幕中，提供一个合适的应用程序名称，并选择资源组和托管计划：

1. 点击创建。

2. 这将部署您的应用程序到 Azure。

3. 如果一切顺利，您应该在浏览器中看到这个：

它是如何工作的...

在步骤 1、2 和 3 中，我们打开了之前食谱中创建的现有解决方案。我们进行了快速构建以检查任何语法错误并确认一切正常。在步骤 5 中，我们使用 Visual Studio 工具将应用程序发布到 Azure。在这种情况下，我们选择了一个新的应用程序服务。在下一屏幕的步骤 7 中，我们必须使用与您的登录绑定的 Azure 订阅。这应该是您在之前的食谱中创建的账户。您在这里可以选择一个现有的资源组，或者通过点击新建链接创建一个新的资源组。您将看到一个类似于这样的对话框：

您必须为您的资源组命名并点击确定。资源组是您在 Azure 中分类资源的一种方式。再次提醒，您可以通过点击新建链接选择一个新的托管计划。再次提醒，您应该看到一个类似于这样的屏幕来选择您的新计划：

位置和大小下拉列表提供了不同的选项供您选择。位置将帮助您选择靠近您客户的区域。这将帮助您快速访问您的网站。此外，大小将告诉您将为这个应用程序服务使用什么处理器和 RAM。最后，您点击创建按钮，Visual Studio 将负责整个过程。这包括将您的文件上传到 Azure、打开浏览器并显示最终结果。在 Azure 门户中，您的应用程序服务应该像这样出现在列表中：

如您所见，Visual Studio 已经为您完成了所有艰苦的工作。