简介

.NET Core是Microsoft最新的通用开发平台。它可以在不同的平台上工作，并且已经被重新设计，使.NET变得快速，灵活和现代。这是微软的主要贡献之一。开发人员现在可以使用.NET构建Android，iOS，Linux，Mac和Windows应用程序，全部使用开放源代码。

在本教程中，我们将介绍.NET Core和一些新的创新，包括.NET Framework更新，.NET标准和通用Windows平台更新等。

.NET Core的特性

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

1. 开源

.NET Core是一个开源实现，使用MIT和Apache 2许可证发布。
.NET Core是一个.NET基础项目，可在GitHub上找到。
作为一个开放源代码项目，它促进了一个更加透明的开发过程，并促进一个积极和参与社区。

2. 跨平台

在.NET Core中实现的应用程序可以运行，其代码可以重复使用，而不需要管平台目标是什么。
它目前支持三种主要的操作系统(OS)：
- Windows
- Linux
- MacOS
受支持的操作系统(OS)，CPU和应用程序方案将随着时间的推移而增长，由微软，其他公司和个人提供。

3. 灵活的部署

.NET Core应用程序有两种类型的部署 –
- 依赖于框架的部署
- 自包含的部署
在依赖于框架的部署中，应用程序依赖于安装了应用程序和第三方依赖项的.NET Core的系统范围版本。
通过自包含的部署，用于构建应用程序的.NET Core版本也与应用程序和第三方依赖项一起部署，并且可以与其他版本并行运行。

4. 命令行工具

所有的产品方案都可以在命令行中执行。

5. 兼容

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

6. 模块化

.NET Core通过NuGet以较小的组装包发布。
.NET Framework是一个包含大多数核心功能的大型程序集。
.NET Core可作为更小的以功能为中心的软件包提供。
这种模块化方法使开发人员能够通过在应用程序中包含他们需要的那些NuGet包来优化他们的应用程序。
较小的应用程序表面积的好处包括更紧密的安全性，更少的服务，更高的性能以及降低付费使用模式的成本。

7. .NET Core平台

.NET核心平台包含以下主要部分 –

.NET运行时 – 它提供了一个类型系统，程序集加载，垃圾回收器，本地互操作和其他基本服务。
基础库 – 一组框架库，提供原始数据类型，应用程序组合类型和基本工具。
SDK和编译器 – 一套SDK工具和语言编译器，支持.NET Core SDK中的基本开发人员体验。
.NET应用程序主机 – 用于启动.NET Core应用程序。它选择运行时间并承载运行时间，提供程序集加载策略并启动应用程序。同样的主机也用于以相同的方式启动SDK工具。

必备条件

在本章中，我们将讨论学习需要部署和运行的各种依赖关系。这些包括使用Visual Studio开发的Windows机器上的.NET Core应用程序。

支持的Windows版本

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

Windows 7 SP1
Windows 8.1
Windows 10
Windows Server 2008 R2 SP1 (Full Server or Server Core)
Windows Server 2012 SP1 (Full Server or Server Core)
Windows Server 2012 R2 SP1 (Full Server or Server Core)
Windows Server 2016 (Full Server, Server Core or Nano Server)

依赖

如果在早于Windows 10和Windows Server 2016的Windows版本上运行.NET Core应用程序，则还需要Visual C++可再发行组件。
如果使用.NET Core安装程序，则会自动安装此依赖项。
如果要通过安装程序脚本安装.NET Core或部署自包含的.NET Core应用程序，则需要手动安装适用于Visual Studio 2015的Visual C++ Redistributable。
对于Windows 7和Windows Server 2008计算机，需要确保您的Windows安装是最新的，并且还包括通过Windows Update安装的修补程序KB2533623。

使用Visual Studio的先决条件

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

但是，如果要使用Visual Studio在Windows上开发.NET Core应用程序，则可以使用以下两个版本 –

Visual Studio 2015
Visual Studio 2017 RC 或以上版本

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

开发环境设置

在本章中，我们将讨论和学习.NET Core的开发环境设置。 .NET Core是.NET框架重新设计的一个重要的框架。要在应用程序中使用.NET Core，可以使用Visual Studio的两个版本 –

Visual Studio 2015
Visual Studio 2017 RC

本教程是以Visual Studio 2017社区版本作为开发环境。

从Visual Studio官方网站下载后，安装即可。

在本教程中，但是如果想使用Visual Studio 2017，Visual Studio 2017 RC中将包含用于Visual Studio的.NET Core工具的实验版本，可以在这里查看安装指南 -http://www.microsoft.com/net/core/#windowsvs2017

在下一个教程中，我们将演示如何使用Visual Studio 2017社区版本来创建一个.Net Core应用程序。

入门程序

Visual Studio 2017为开发.NET Core应用程序提供了一个全功能的开发环境。在本章中，我们将在Visual Studio中创建一个新项目。当安装了Visual Studio 2017工具，您可以开始构建一个新的.NET Core应用程序。

在“新建项目”对话框的“模板”列表中，展开“Visual C# ”节点并选择“.NET Core”，然后应该看到以下三个新项目模板。

类库(.NET Core)
控制台应用程序(.NET Core)
ASP.NET核心Web应用程序(.NET Core)

在“新建项目”对话框的中间窗格中，选择“控制台应用程序(.NET Core)”并将其命名为“FirstApp”，然后单击“确定”。如下图所示 –

Visual Studio将打开新创建的项目，在“解决方案资源管理器”窗口中看到此项目中的所有文件(自动生成)。

要测试.NET Core控制台应用程序是否正常工作，请添加以下代码行。

using System;

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

现在，运行该应用程序。应该看到以下输出。

数字

.NET Core支持标准的数字整数和浮点基元类型。它还支持以下类型 –

System.Numerics.BigInteger是一个整数类型，没有上限或下限。
System.Numerics.Complex是一种表示复数的类型。
System.Numerics命名空间中的一组支持单指令多数据(SIMD)的矢量类型。

整体类型

.NET Core支持从一个字节到八个字节的不同范围的有符号和无符号整数。所有整数都是值类型。

下表列出了整体类型及其大小;

类型	有/无符号	大小(位)	最小值	最大值
Byte	Unsigned	1	0	255
Int16	Signed	2	−32,768	32,767
Int32	Signed	4	−2,147,483,648	2,147,483,647
Int64	Signed	8	−9,223,372,036,854,775,808	9,223,372,036,854,775,807
SByte	Signed	1	-128	127
UInt16	Unsigned	2	0	65,535
UInt32	Unsigned	4	0	4,294,967,295
UInt64	Unsigned	8	0	18,446,744,073,709,551,615

每个整型支持一组标准的算术，比较，等式，显式转换和隐式转换运算符。

也可以使用System.BitConverter类来处理整数值中的各个位。

浮点类型

.NET Core包含三种基本浮点类型，如下表所示。

类型	大小(位)	最小值	最大值
Double	8	`−1.79769313486232e308`	`1.79769313486232e308`
Single	4	`−3.402823e38`	`3.402823e38`
Decimal	16	`−79,228,162,514,264,337,593,5 43,950,335`	`79,228,162,514,264,337,593,543,9 50,335`

每个浮点类型都支持一组标准的算术，比较，相等，显式转换和隐式转换运算符。
还可以使用BitConverter类使用Double和Single值中的各个位。
Decimal结构有自己的方法，Decimal.GetBits和Decimal.Decimal(Int32())，用于处理十进制值的各个位，以及它自己的一组方法来执行一些额外的数学运算。

1. BigInteger

System.Numerics.BigInteger是一个不可变的类型，它表示一个理论值没有上下限的任意大的整数。
BigInteger类型的方法与其他整型类型的方法非常类似。

2. Complex

System.Numerics.Complex类型表示复数，即具有实数部分和虚数部分的数字
它支持一组标准的算术，比较，等式，显式转换和隐式转换运算符，以及数学，代数和三角函数方法。

3. SIMD

Numerics命名空间包含一组用于.NET Core的启用SIMD的矢量类型。
SIMD允许一些操作在硬件级别进行并行化，从而在数学，科学和图形应用程序中执行对矢量进行计算的巨大性能改进。
.NET Core中支持SIMD的矢量类型包括以下内容 –
- System.Numerics.Vector2，System.Numerics.Vector3和System.Numerics.Vector4类型，它们是Single类型的2,3和4维矢量。
- Vector <T>结构可创建任何基本数字类型的向量。基本数字类型包括System名称空间中除Decimal以外的所有数字类型。
- 两个矩阵类型，System.Numerics.Matrix3×2，表示3×2矩阵; 和表示4×4矩阵的System.Numerics.Matrix4×4。
- 表示三维平面的System.Numerics.Plane类型和表示用于对三维物理旋转进行编码的矢量的System.Numerics.Quaternion类型。

垃圾收集

在本章中，我们将介绍垃圾收集的概念，垃圾收集是.NET托管代码平台最重要的特性之一。垃圾收集器(GC)管理内存的分配和释放。垃圾收集器用作自动内存管理器。

我们不需要知道如何分配和释放内存或管理使用该内存的对象的生命周期
每当使用new关键字声明对象或将值类型装箱时，都会进行分配。分配通常非常快。
当没有足够的内存分配一个对象时，GC必须收集和处理垃圾内存以使内存可用于新的分配。

这个过程被称为垃圾收集。

垃圾收集的优势

垃圾收集提供以下好处(优势) –

在开发应用程序时，不需要手动释放内存。
它还有效地在托管堆上分配对象。
当对象不再使用时，它将通过清除内存来回收这些对象，并将内存保留为将来的分配。
托管对象自动获得干净的内容，所以它们的构造函数不必初始化每个数据字段。
它还通过确保对象不能使用其他对象的内容来提供内存安全性。

垃圾收集的条件

垃圾收集在下列条件之一时发生：

当系统的物理内存较低时。
托管堆上分配的对象使用的内存超过了可接受的阈值。该阈值在流程运行时不断调整。
GC.Collect方法被调用，在几乎所有情况下，不必调用此方法，因为垃圾收集器连续运行。这种方法主要用于独特的情况和测试。

阶段过程

.NET垃圾收集器有3代，每一代都有自己的堆，用于存储分配的对象。有一个基本的原则，判定大多数对象是短暂的还是长期的。

1. 第一代(0)

在第0代中，首先分配对象。
在这一代，对象通常不会超越第一代，因为在下一次垃圾收集时，它们不再被使用(超出范围)。
0代很快收集，因为它相关的堆很小。

2. 第二代(1)

在第一代，对象有第二个机会空间。
在第0代收集(通常是基于巧合的时机)下寿命很短的对象会转到第1代。
第一代集合也很快，因为它的关联堆也很小。
前两堆仍然很小，因为对象被收集或提升到下一代堆。

3. 第三代(2)

在第二代，所有的长对象都是活动的，它的堆可以长得很大。
这一代的对象可以长期存活下去，没有下一代堆积对象可以进一步推广。
垃圾收集器有一个额外的堆，用于称为大对象堆(LOH)的大型对象。
它保留85,000字节或更大的对象。
大对象并没有分配到代代堆，而是直接分配给了LOH
第二代和LOH收集可能会花费很长时间运行的程序或运行大量数据的程序。
已知大型服务器程序在十几个GB中堆积如山。
GC采用各种技术来减少阻止程序执行的时间。
主要方法是在后台线程上尽可能多地执行垃圾回收工作，而不会干扰程序执行。
GC还为开发人员提供了一些方法来影响其行为，这对提高性能非常有用。

代码执行

在本章中，我们将了解.NET Core的执行过程，并将其与.NET Framework进行比较。被管理的执行过程包括以下步骤。

选择一个编译器
编译代码成MSIL
将MSIL编译为本地代码
运行代码

参考下图中的流程 –

1. 选择一个编译器

它是一个多语言执行环境，运行时支持各种数据类型和语言功能。
要获得公共语言运行时提供的好处，必须使用一个或多个定位运行时的语言编译器。

2. 编译代码成MSIL

编译将您的源代码翻译成Microsoft中间语言(MSIL)并生成所需的元数据。
元数据描述了代码中的类型，包括每种类型的定义，每种类型成员的签名，代码引用的成员以及运行时在执行时使用的其他数据。
运行时在执行过程中根据需要从文件以及框架类库(FCL)中查找和提取元数据。

3. 将MSIL编译为本地代码

在执行时，即时(JIT)编译器将MSIL转换为本地代码。
在编译期间，代码必须通过验证过程，检查MSIL和元数据，以确定代码是否可以被确定为类型安全的。

4. 运行代码

公共语言运行库提供了执行过程的基础结构和执行过程中可以使用的服务。
在执行期间，托管代码接收垃圾收集，安全性，与非托管代码的互操作性，跨语言调试支持以及增强的部署和版本支持等服务。

.NET Core代码执行过程

现在来看看一下如何使用.NET Core与.NET Framework进行代码执行。在.NET Core中，这些组件的很多替代品都是.NET Framework的一部分。执行流程图如下所示 –

现在在.NET Core中，我们有了一个新的编译器系列，就像用于 C# 和VB的Roslyn一样。
如果想在.NET Core中使用F#，也可以使用新的F# 4.1编译器。
实际上，这些工具是不同的，如果使用C# 6或更高版本，也可以使用Roslyn和.NET Framework，因为C#编译器最多只能支持C# 5。
在.NET Core中，没有框架类库(FCL)，所以使用了一组不同的库，现在有了CoreFx。
CoreFx是.NET Core的类库的重新实现。
也有一个新的运行时间与.NET Core CoreCLR，并利用JIT编译器。

模块化

.NET Core的另一个考虑是构建和实现模块化的应用程序。现在，应用程序现在可以只安装所需的内容，而不是安装整个.NET Framework。下面来看看解决方案浏览器中的模块化。

这是一个简单的.NET Core应用程序，在解决方案资源管理器中展开引用，可以看到对.NETCoreApp的引用，如下图所示 –

会看到整个系列的NuGet包参考。如果使用过.NET Framework，那么很多这样的命名空间看起来很熟悉，因为您已经习惯了在.NET Framework中使用它。

.NET Framework被分割成许多不同的部分，并用CoreFx重新实现; 这些工作被进一步分发为独立包装。

现在，如果展开Microsoft.CodeAnalysis.CSharp，将看到另外的参考。甚至会注意到在这个应用程序中使用的System.Console。
现在，不必在.NET Framework中引入所有内容，只需引入应用程序所需的东西即可。
还有一些其他的好处，例如，如果需要，这些模块可以单独更新。

模块化导致性能优势，并且您的应用程序可以运行得更快，特别是ASP.NET Core应用程序。

项目文件

在本章中，我们将讨论和学习.NET Core项目文件以及如何在项目中添加文件。

下面来了解一个简单的例子，我们有一些已经创建的文件; 我们必须在我们的FirstApp项目中添加这些文件。

这是Student.cs文件的实现 –

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

namespace FirstApp { 
   public class Student { 
	  public int ID { get; set; } 
	  public string LastName { get; set; } 
	  public string FirstMidName { get; set; } 
	  public DateTime EnrollmentDate { get; set; } 
   } 
}

这是Course.cs文件的实现 –

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

namespace FirstApp { 
   public class Course { 
	  public int CourseID { get; set; } 
	  public string Title { get; set; } 
	  public int Credits { get; set; } 
   } 
}

现在将这两个文件保存在一个文件夹中。

现在，如果您熟悉.NET并且这是一个传统的.NET框架控制台应用程序，那么了解如何在Visual Studio中的项目中添加这些文件是非常重要的。
首先需要将文件拖到解决方案资源管理器中，将它们复制到项目文件夹中，因为项目需要引用这些文件。
.NET Core的好处之一就是使用项目文件(project.json)的方法; 可以将文件放到项目的根目录下，然后这些文件会自动包含在项目中。
在Visual Studio中，不必像过去那样手动引用传统的.NET Framework应用程序。

现在打开项目的根目录。将所有这两个文件复制到您的项目的根目录中。

现在让我们来看看Visual Studio中的项目结构。现在Visual Studio将会自动将这些文件包含在您的项目中了。

包的引用

在本章中，我们将讨论如何在.NET Core应用程序中添加包以及如何查找特定的包。我们可以直接去NuGet并添加包，但是在这里可以从其他一些地方查找加入。

现在让我们来看看位于下面链接的.NET Core的源代码 -http://github.com/dotnet/corefx

在CoreFx repo中，打开src文件夹 –

会看到对应于不同包的文件夹的整个列表。现在搜索Json-

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

如果知道该类型，则可以打开http://packagesearch.azurewebsites.net/搜索以反向搜索包。

在这里，您可以输入任何类型并找到包。然后，这个网站将扫描NuGet并找到相关的包。现在假设要搜索：DataContractJson。

现在会看到搜索得到相关的包; 点击这些包查看详细。如下图所示 –

现在将看到NuGet页面; 需要确认需要这个包。您可以使用几种方法将其添加到应用程序中。打开project.json文件。

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

这是新的项目格式，在这个文件里会看到依赖关系部分。添加一个新的依赖关系，如下所示。

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

现在，如果看看项目的引用，那么会看到System.Runtime.Serialization.Json包被添加到项目中了。如下图所示 –

另一种方法是使用NuGet管理器，浏览想添加的包。如下图所示 –

创建UWP应用程序

在本章中，我们将讨论如何使用.NET Core创建UWP应用程序。 UWP也被称为Windows 10 UWP应用程序。此应用程序不能在以前版本的Windows上运行，但只能在未来版本的Windows上运行。

现在按照下面这些步骤来创建并实现一个UWP应用程序。

创建项目的工作区如下 –

要查看运行的示例，可以打开MainPage.XAML并添加下面的代码。

<Page 
   x:Class = "UWPFirstApp.MainPage" 
   xmlns = "http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
   xmlns:x = "http://schemas.microsoft.com/winfx/2006/xaml" 
   xmlns:local = "using:UWPFirstApp" 
   xmlns:d = "http://schemas.microsoft.com/expression/blend/2008" 
   xmlns:mc = "http://schemas.openxmlformats.org/markup-compatibility/2006" 
   mc:Ignorable = "d">  

   <Grid Background = "{ThemeResource ApplicationPageBackgroundThemeBrush}"> 
	  <StackPanel HorizontalAlignment = "Center"> 
		 <TextBlock Text = "Hello, world!"  
			Margin = "20" 
			Width = "200" 
			HorizontalAlignment = "Left"/> 
		 <TextBlock Text = "Write your name." 
			Margin = "20" 
			Width = "200" 
			HorizontalAlignment = "Left"/> 
		 <TextBox x:Name = "txtbox"  
			Width = "280" 
			Margin = "20" 
			HorizontalAlignment = "Left"/> 
		 <Button x:Name = "button" Content = "Click Me" 
			Margin = "20" 
			Click = "button_Click"/> 
		 <TextBlock x:Name = "txtblock"  
			HorizontalAlignment = "Left" 
			Margin = "20"/> 
	  </StackPanel> 
   </Grid> 
</Page>

以下是处理按钮的点击事件的 C# 代码。打开MainPage.XAML.cs并添加下面的代码。

private void button_Click(object sender, RoutedEventArgs e) { 
		 if (txtbox.Text != "") 
			txtblock.Text = "Hello: " + txtbox.Text; 
		 else 
			txtblock.Text = "You have not write your name"; 
	  }

现在在本地机器上运行上面的代码，点击菜单：“生成”->生成UWPFirstApp(可能系统会提示要求设置系统模式，选择“开发人员”)，然后点击Visual Studio正上方绿色箭头的“本地计算机”开始运行，会看到下面的窗口。在文本框中输入字符串名字，然后点击：【Click Me】按钮。得到以下结果 –

MSBuild

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

但是，如果打开前面创建的.NET Core控制台应用程序，那么将看到project.json和* .xproj文件。

.NET Core构建系统或project.json构建系统不足以满足UWP需求; 这就是为什么UWP仍然使用*.csproj(MSBuild)构建系统。
但是就构建系统而言，project.json将会移出。
现在，如果想在控制台应用程序中添加一些现有的文件到UWP应用程序，那么需要将这些文件添加到项目文件夹中。此外，还需要在解决方案资源管理器中包含项目。

现在考虑下面的文件; 将这些文件复制到项目文件夹。

回到Visual Studio并打开解决方案资源管理器。

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

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

这两个文件仍然不包括在项目中。要包含这些文件，请选择这些文件，然后右键单击任何文件，然后选择包含在项目中。

现在这些文件也包括在内。可以预见的一件好事是在未来版本的SKD工具中将*.csproj的文件丢弃到project.json，也是使用Visual Studio这个开发工具可以直接集成操作。

元数据包

在本章中，我们将讨论学习控制台应用程序和UWP应用程序之间的引用。如果查看控制台应用程序的解决方案资源管理器中的引用，您将看到如下所示的.NET CoreApp。

.NETCoreApp是一个面向.NET Core应用程序的新框架。现在，如果查看UWP应用程序的引用，它将看起来有点不同，如下所示。

这样做的主要原因是因为在UWP中有*.csproj，所以回到旧的引用风格，只能使用这个工程类型定位一个框架。
虽然引用是相似的。现在可以看到，在UWP应用程序中，Miscrosoft.NETCore.UniversalWindowsPlatform NuGet包引用类似于Console应用程序中的Microsoft.NETCore.App NuGet引用。
Miscrosoft.NETCore.UniversalWindowsPlatform和Microsoft.NETCore.App都是元程序包，这意味着它们是由其他程序包组成的。
在控制台应用程序中，可以钻取并查看Microsoft.NETCore.App中的其他包，但不能在解决方案资源管理器中执行相同的Microsoft.NETCore.UniversalWindPlatform。
不过，我们可以使用另一个工具，NuGet包资源管理器来看看这个。在浏览器中打开这个URL – http://npe.codeplex.com/downloads/get/clickOnce/NuGetPackageExplorer.application ，会看到一个小工具下载。
下载完成后，双击该文件安装。

点击Install，然后在NuGet Package Explorer上开始安装。

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

现在点击Open a package from online feed选项。

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

点击open的链接，它将打开这个元数据包的顶级依赖项。

现在一起打开.NETCore应用程序的.NETCore元数据包和UWP应用程序的元数据包。

现在可以看到每个元包都由不同的包组成。
.NET Core至少在这个时候是.NET Framework中可用的类的一个子集，但是正在增长，并将按照.NET Framework的基类扩展。
UWP基于.NET Core，它是Windows Store开发可用的API的超集。

由于.NET Core，我们现在有更多可用于开发的API。

Windows 运行时和扩展SDK

Windows运行时组件是自包含的对象，可以从任何语言(包括 C# ，Visual Basic，JavaScript和C++)实例化和使用。除了在上一章中看到的.NET Core元包之外，UWP应用程序还有一个默认的引用 – 通用Windows SDK。

通用Windows是对Windows运行时的引用，它已被考虑到一系列API契约中。

设备系列中的一组API被分解为称为API契约的细分。可以在这里找到不同的API契约列表 -http://msdn.microsoft.com/en-us/library/windows/apps/dn706135.aspx

可以看到各种API的链接，也可以看到Universal家族很大，有12页的文档。您也可以在此页面上搜索phoneAPI契约。

现在让我们点击Windows.Phone.PhoneContract并向下滚动; 将看到电话或移动设备的电池信息。

如果想要将这些信息添加到已有的信息的顶部，那么应该手动添加引用。现在让我们转到Visual Studio并右键单击解决方案资源管理器中的引用。

选择：Add References…，如下所示 –

现在可以看到通用Windows的新引用类别; 在这个类别下有Core，它指核心的Universal Windows API合约。

扩展允许我们扩展功能，您会看到不同的引用移动，桌面和其他扩展。
有不同的SKD扩展，你可以添加到顶部获得更多的API。
也可以看到不同的版本。因此，请确保获取最新版本以获取更新的API，然后单击确定。

现在可以看到添加了用于UWP的Windows Mobile Extensions作为引用了。

创建.NET标准库

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

使用.NET Core开发的类库支持.NET标准库，该标准库允许您的库由任何支持该版本的.NET标准库的.NET平台调用。
当完成类库时，可以决定是将其作为第三方组件来分发，还是要将其作为与一个或多个应用程序捆绑在一起的组件进行包含。

现在开始在控制台应用程序中添加一个类库项目(以前创建的FirstApp项目为基础); 右键单击解决方案资源管理器，然后选择：添加->新建项目…，如下图所示 –

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

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

单击确定以创建类库项目。项目创建完成后，让我们添加一个新的类。在解决方案资源管理器中右键单击项目名称，然后选择：添加->类…，如下图所示 –

在中间窗格中选择类并在名称和字段中输入StringLib.cs，然后单击添加。当类添加了之后，打StringLib.cs文件，并编写下面的代码。参考代码 –

using System;
using System.Collections.Generic;
using System.Text;

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

类库UtilityLibrary.StringLib包含一些方法，例如：StartsWithUpper，StartsWithLower和StartsWithNumber，它们返回一个布尔值，指示当前字符串实例是否分别以大写，小写和数字开头。
在.NET Core中，如果字符是大写字符，则Char.IsUpper方法返回true;如果字符是小写字符，则Char.IsLower方法返回true;如果字符是数字字符，则Char.IsNumber方法返回true。
在菜单栏上，选择Build，Build Solution。该项目应该编译没有错误。
.NET Core控制台项目无法访问这个类库。
现在要使用这个类库，需要在控制台项目中添加这个类库的引用。

为此，展开FirstApp并右键单击在弹出的菜单中选择：添加->引用并选择：添加引用…，如下图所示 –

在“引用管理器”对话框中，选择类库项目UtilityLibrary，然后单击【确定】。
现在打开控制台项目的Program.cs文件，并用下面的代码替换所有的代码。

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

namespace FirstApp { 
   public class Program { 
	  public static void Main(string[] args) { 
		 int rows = Console.WindowHeight; 
		 Console.Clear(); 
		 do { 
			if (Console.CursorTop >= rows || Console.CursorTop == 0) { 
			   Console.Clear(); 
			   Console.WriteLine("\nPress <Enter> only to exit; otherwise, enter a string and press <Enter>:\n"); 
			} 
			string input = Console.ReadLine(); 

			if (String.IsNullOrEmpty(input)) break; 
			Console.WriteLine("Input: {0} {1,30}: {2}\n", input, "Begins with uppercase? ", 
			input.StartsWithUpper() ? "Yes" : "No"); 
		 } while (true); 
	  } 
   } 
}

现在运行应用程序，将看到以下输出。如下所示 –

为了更好的理解，在接下来的章节中也会涉及到如何在项目中使用类库的其他扩展方法。

可移植类库

在本章中，我们将讨论什么是PCL(可移植类库)，以及为什么我们需要PCL。为了理解这个概念，让我们打开在前面章创建的类库项目文件夹。

在这个文件夹中，除了project.json和CS文件之外，还可以看到*.xproj文件，这是因为Visual Studio安装.NET Core项目类型为* .xproj而不是*.csproj。

正如微软所提到的，*.xproj将会消失，但它仍然在预览工具中。UWP应用程序使用*.csproj。

现在把* .csproj引用和* .xproj实际上是不可行的，而且这个功能不会被执行，因为* .xproj将会移出。

相反，我们需要一个可以在控制台应用程序和UWP应用程序之间共享的类库，这就是PCL。

什么是PCL

下面来了解PCL是什么 –

可移植类库项目使我们能够编写和构建在多个.NET Framework平台上工作的受管程序集。
可以创建包含希望在多个项目(如共享业务逻辑)中共享的代码的类，然后引用来自不同类型项目的类。
它还可以帮助您快速轻松地为Microsoft平台构建跨平台的应用程序和库。
可移植类库可以帮助您减少开发和测试代码的时间和成本。
使用此项目类型来编写和构建可移植的.NET Framework程序集，然后从以Windows和Windows Phone等多个平台为目标的应用程序中引用这些程序集。

要从解决方案资源管理器创建类库，这里以前面创建的项目：FirstApp为基础，首先点击解决方案添加一个新的项目。在左窗格中选择Visual C#->Windows 通用模板，然后在中间窗格中选择“类库(通用Windows)”，如下所示 –

在项目名称字段中输入：StringLibrary，然后单击确定以创建此项目。现在需要选择目标框架来引用。选择Windows通用和ASP.NET核心片刻，然后重新定位它。点击【确定】。如下图所示 –

可以看到它已经创建了一个PCF格式的新项目。右键单击解决方案资源管理器中的StringLibrary项目并选择属性。

现在添加一个新的类; 需要在解决方案资源管理器中右键单击项目，然后选择：添加->类…，输入类文件的名称：MyStringLib.cs，如下所示 –

类：MyStringLib.cs-

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

namespace StringLibrary
{
	public static class MyStringLib
	{
		public static bool StartsWithUpper(this String str)
		{
			if (String.IsNullOrWhiteSpace(str))
				return false;
			Char ch = str[0];
			return Char.IsUpper(ch);
		}
		public static bool StartsWithLower(this String str)
		{
			if (String.IsNullOrWhiteSpace(str))
				return false;
			Char ch = str[0];
			return Char.IsLower(ch);
		}
		public static bool StartsWithNumber(this String str)
		{
			if (String.IsNullOrWhiteSpace(str))
				return false;
			Char ch = str[0];
			return Char.IsNumber(ch);
		}
	}
}

下面来构建这个可移植的类库项目，并且应该编译没有错误。需要在控制台项目中添加这个可移植类库的引用。因此，展开FirstApp并右键单击添加->引用，并选择引用…

在“引用管理器”对话框中，选择可移植类库项目：StringLibrary，然后单击【确定】。

可以看到StringLibrary引用已添加到控制台项目中，也可以在Assenblyinfo.json文件中看到。现在修改文件：Program.cs，如下所示 –

using System;
using StringLibrary;

namespace FirstApp
{
	public class Program
	{
		public static void Main(string[] args)
		{
			int rows = Console.WindowHeight;
			Console.Clear();
			do
			{
				if (Console.CursorTop >= rows || Console.CursorTop == 0)
				{
					Console.Clear();
					Console.WriteLine("\nPress <Enter> only to exit; otherwise, enter a string and press <Enter>:\n");
				}
				string input = Console.ReadLine();

				if (String.IsNullOrEmpty(input)) break;
				Console.WriteLine("Input: {0} {1,30}: {2}\n", input, "Begins with uppercase? ",
				input.StartsWithUpper() ? "Yes" : "No");
			} while (true);
		}
	}
}

再次运行该应用程序，将看到相同的输出。

现在，在项目中使用可移植类库的其他扩展方法。UWP应用程序也将使用相同的可移植库。

添加对库的引用

在本章中，我们将讨论如何添加对库的引用。添加对库的引用就像添加对其他项目的引用，如控制台项目和UWP项目。

NuGet软件包管理器添加对库的引用的一种简便方法。右键单击StringLibrary(Universal Windows)项目并选择管理NuGet程序包，如下所示 –

在浏览选项卡上，您可以搜索任何NuGet包; 假设要添加“System.Runtime.Serialization.Primitives”包。可参考以下操作 –

点击安装按钮，如下图所示 –

提示查看更改信息，如下图所示 –

接受协议，如下图所示 –

安装完成，如下图所示 –

那么会看到“System.Runtime.Serialization.Primitives”NuGet包被添加到类库中了。

2022年 1月
一	二	三	四	五	六	日
					1	2
3	4	5	6	7	8	9
10	11	12	13	14	15	16
17	18	19	20	21	22	23
24	25	26	27	28	29	30
31

简介