《ASP.NET Core 高性能系列》致敬伟大的.NET斗士甲骨文!

时间 2019-11-06

标签 asp.net asp core 高性能系列致敬伟大斗士甲骨文栏目 ASP 繁體版

原文原文链接

写在开始

　　三年前,曾写过一篇文章:从.NET和Java之争谈IT这个行业,当时遭到某些自认为懂得java就了不得的Javaer抨击,html

如今能够致敬伟大的.NET斗士甲骨文了java

　　(JDK8以上都须要收费,Android弃用java做为第一语言,别高兴:OpenJDK是甲骨文的).express

　　《ASP.NET Core 高性能系列》是一套如何编写高性能Web应用技术系列文章,缓存

咱们将从.NET 2开始全面升入.其中咱们会讨论互联网当今热门的技术话题:容器、容器编排、服务治理、RPC等数据结构

此文是第一篇,用于此系列的开门篇,后面每周会持续发布.架构

1、Core 2中须要知道的新鲜东西

Core系列有两个主要产品:框架

第一个是.NET Core
异步

　　它是一个低级别的提供基本库的框架。它能够用来编写控制台应用程序，它也是async

更高级别的应用程序框架的基础。分布式

第二个是ASP.NET Core

　　它是一个用于构建Web的跨平台框架

另外.NET Core中的更改也将适用于ASP.NET Core，由于这是基础

2、.NET Core 2的新东西

2.1 API范围更加普遍

　　.NET Core 2的主要焦点是API范围的大幅增长,在1.*的基础上增长了两倍的API,

并且支持.net standard,您也能够引用.NET Framework程序集而无需从新编译,

只要程序集中的API已在.NET Core中实现就能够正常工做。这意味着更多的Nuget包能够在.NET Core中工做,

ASP.NET Core Library and Framework 支持状况的一个统计站点:https://ANCLAFS.com(有点跟不上了)

2.2 性能的大幅度提高

.NET Core 2.0中一些更有趣的变化是在原始的.NET FrameworkAPI上性能改进

,已经对许多框架的实现进行了调整了数据结构。

下面是一些已经看到快速改进的类和方法,已经内存开销的减小包括：

List<T>
Queue<T>
SortedSet<T>
ConcurrentQueue<T>
Lazy<T>
Enumerable.Concat()
Enumerable.OrderBy()
Enumerable.ToList()
Enumerable.ToArray()
DeflateStream
SHA256
BigInteger
BinaryFormatter
Regex
WebUtility.UrlDecode()
Encoding.UTF8.GetBytes()
Enum.Parse()
DateTime.ToString()
String.IndexOf()
String.StartsWith()
FileStream
Socket
NetworkStream
SslStream
ThreadPool
SpinLock

　　另外,对于.NET Core 2的RyuJIT Just In Time编译器进行了改进。

仅做为一个示例就能说明说明其优秀之处，finally块如今几乎与不使用异常同样高效,

这在没有抛出异常的正常状况下是有益的。您如今没有理由不使用try和using{}块，以及checked检查

3、ASP.NET Core 2的新东西

　　ASP.NET Core 2利用了.NET Core 2的全部改进，不只经过即时编译处理程序缩短了启动时间，

涵盖了增长了输出缓存，本地及分布式缓存（SQLSERVER,REDIS).

3.1 metapackage

　　.NET Core包含了一个新metapackage,因此你只用引用一个NuGet项就能够获得全部的东西,metapackage仍然由单个独立的包组成,

一个新的包修剪功能(new package-trimming)确保若是您不使用包，那么它的二进制文件将不会包含在您的部署中，

即便您使用metapackage 来引用它。设置Web主机配置也有合理的默认设置。

您无需单独添加logging, Kestrel, and IIS。logging也变得更简单，由于它是创建的在，你再也没有任何借口不一开始就使用它

3.2 Razor Pages

　　无控制器Razor Pages。这正是它听起来的样子，并且它容许您使用Razor模板编写页面。

它相似于Web Pages产品，没必要和WebForm混淆。你们其实以为是WebForm的卷土重来,我的感受是满怀但愿的卷土重来,

架构作了更多抽象和思考,不会像以前同样,带来如此多的状态与之相伴.

3.3 新的authentication 模型

　　新的 authentication 模型能让更好地使用了依赖注入, ASP.NETCore Identity 容许你使用OpenID 、OAuth 2

来为你的API获取访问tokens .固然你能够研究Identity Server 4 项目,它提供了相同的功能.

3.4 表单请求自动防伪

　　你没必要再为表单添加防伪token(防止跨越伪造请求) (以前你不得不添加一个attribute在Post方法中进行验证),

如今这一切都是自动的.

3.5性能提高

　　ASP.NET Core有一些额外的与.NET Core无关的性能提高:

启动时间经过即时编译处理明显减小,虽然这不是ASP.NET Core 2的新功能;

output caching依然可用,在1.0时,只有response caching*(简化了如何设置http header),

1.1 时,添加了memory cache,如今你能够还使用分布式缓存()SQL Server or Redis)

四 .NET Standard 2.0

　　.NET Standard 是一套正式的 .NET API 规范，目标是在全部 .NET 实现中推出。推出 .NET Standard 的背后动机是要提升 .NET 生态系统中的一致性。

ECMA 335 持续为 .NET 实现行为创建统一性，但适用于 .NET 库实现的 .NET 基类库 (BCL) 没有相似的规范。

.NET Framework 4.6.1实现了.NET Standard 2.0.

.NET Standard 可实现如下重要情境：

1.为要实现的全部 .NET 实现定义一组统一的、与工做负荷无关的 BCL API。

2.使开发人员可以经过同一组 API 生成可在各类 .NET 实现中使用的可移植库。

3.减小甚至消除因为 .NET API 方面的缘由而对共享源代码进行的条件性编译（仅适用于 OS API）。

5、C# 6.0语言级别的新东西

5.1 属性能够连带赋值

public DateTime BirthDay { get; set; } = DateTime.Now.AddYears(-20);

5.2 导入静态类

using static System.Math;

Console.WriteLine($"导入后可直接使用方法: {Pow(4, 2)}");

5.3 字符串格式化的变化

Console.WriteLine(string.Format("当前时间:{0}",DateTime.Now.ToString()));

5.4 空值运算符

Console.WriteLine(name?.ToString()); // 程序不会报错，也不会输出任何值

5.5 对象初始化器

能够经过索引的方式进行赋值

IDictionary<int, string> dictNew = new Dictionary<int, string>()
{
       [4] = "first",
       [5] = "second"
};

5.6 异常过滤器

int exceptionValue = 10;
try
{
       Int32.Parse("s");
}
catch (Exception e) when (exceptionValue > 1)//知足条件才进入catch
{
       Console.WriteLine("catch");
}

5.7 nameof表达式

Console.WriteLine(nameof(People));

5.8 在属性/方法里面使用Lambda表达式

 public void Print() => Console.WriteLine(Name);

6、C# 7.0语言级别的新东西

6.1 out变量不须要申明了

  var input = ReadLine();
  if (int.TryParse(input, out var result))
  {

      WriteLine("您输入的数字是：{0}",result);
  }
  else
  {
      WriteLine("没法解析输入...");
  }

6.2元组

元组（Tuple）在 .Net 4.0 的时候就有了，但元组也有些缺点，如：

1）Tuple 会影响代码的可读性，由于它的属性名都是：Item1，Item2.. 。

2）Tuple 还不够轻量级，由于它是引用类型（Class）。

备注：上述所指 Tuple 还不够轻量级，是从某种意义上来讲的或者是一种假设，即假设分配操做很是的多。

C# 7 中的元组（ValueTuple）解决了上述两个缺点：

1）ValueTuple 支持语义上的字段命名。

2）ValueTuple 是值类型（Struct）。

传统的建立方式

  var tuple = (1, 2);                           // 使用语法糖建立元组

  var tuple2 = ValueTuple.Create(1, 2);         // 使用静态方法【Create】建立元组 

  var tuple3 = new ValueTuple<int, int>(1, 2);  // 使用 new 运算符建立元组 WriteLine($"first：{tuple.Item1}, second：{tuple.Item2}, 上面三种方式都是等价的。");

//建立给字段命名的元组
// 左边指定字段名称
  (int one, int two) tuple = (1, 2);
  WriteLine($"first：{tuple.one}, second：{tuple.two}");
  // 右边指定字段名称
  var tuple2 = (one: 1, two: 2);
  WriteLine($"first：{tuple2.one}, second：{tuple2.two}"); 
  // 左右两边同时指定字段名称
  (int one, int two) tuple3 = (first: 1, second: 2);   
 /* 此处会有警告：因为目标类型（xx）已指定了其它名称，由于忽略元组名称xxx */
  WriteLine($"first：{tuple3.one}, second：{tuple3.two}");

6.3 解构

6.3.1解构元组

var (one, two) = GetTuple();
WriteLine($"first：{one}, second：{two}");
static (int, int) GetTuple() {
  return (12, 2);
}

6.3.2解构能够应用于 .Net 的任意类型，

但须要编写 Deconstruct 方法成员（实例或扩展）

public void Deconstruct(out type variable1, out type variable2...)
public static void Deconstruct(this type instance, out type variable1, out type variable2...)

6.4 模式匹配

6.4.1 is 表达式（is expressions）

static int GetSum(IEnumerable<object> values)
  {
      var sum = 0;
      if (values == null) return sum;  
      foreach (var item in values)    
      {
          if (item is short)     // C# 7 以前的 is expressions
          {
              sum += (short)item;
          }
          else if (item is int val)  // C# 7 的 is expressions
          {
              sum += val;
          }
          else if (item is string str && int.TryParse(str, out var result))
           // is expressions 和 out variables 结合使用
          {
              sum += result;
          }
          else if (item is IEnumerable<object> subList)
          {
              sum += GetSum(subList);
          }
      }  
      return sum;
  }

6.4.2 switch语句

switch (item)
  {
      case type variable1:
          // processing...
          break;
      case type variable2 when predicate:
          // processing...
          break;
      default:
          // processing...
          break;
  }

6.5 Ref locals and returns

static ref int GetLocalRef(int[,] arr, Func<int, bool> func)
  {
      for (int i = 0; i < arr.GetLength(0); i++)
      {
          for (int j = 0; j < arr.GetLength(1); j++)
          {
              if (func(arr[i, j]))
              {
                  return ref arr[i, j];
              }
          }
      }
      throw new InvalidOperationException("Not found");
  }
  int[,] arr = { { 10, 15 }, { 20, 25 } };
  ref var num = ref GetLocalRef(arr, c => c == 20);
  num = 600; 
  Console.WriteLine(arr[1, 0]);

总结：虽然 C# 7 中提供了局部引用和引用返回，但为了防止滥用因此也有诸多约束，如：

1. 你不能将一个值分配给 ref 变量，如：

1 ref int num = 10; // error：没法使用值初始化按引用变量

2. 你不能返回一个生存期不超过方法做用域的变量引用，如：

1 public ref int GetLocalRef(int num) => ref num; // error: 没法按引用返回参数，由于它不是 ref 或 out 参数

3. ref 不能修饰 “属性” 和 “索引器”。

1 var list = new List<int>();2 ref var n = ref list.Count; // error: 属性或索引器不能做为 out 或 ref 参数传递

原理解析：很是简单就是指针传递，而且我的以为此语法的使用场景很是有限，都是用来处理大对象的，目的是减小GC提升性能。

6.5 局部函数

static IEnumerable<char> GetCharList(string str)
   {
       if (IsNullOrWhiteSpace(str))

           throw new ArgumentNullException(nameof(str));

       return GetList();   

       IEnumerable<char> GetList()
       {
           for (int i = 0; i < str.Length; i++)
           {
               yield return str[i];
           }
       }
   }

6.6. 扩展异步返回类型（Generalized async return types）

之前异步的返回类型必须是：Task、Task<T>、void，如今 C# 7 中新增了一种类型：ValueTask<T>，以下所示：

  public async ValueTask<int> Func()
  {
     await Task.Delay(3000);
     return 100;
  }

总结：ValueTask<T> 与 ValueTuple 很是类似，因此就不列举： ValueTask<T> 与 Task 之间的异同了，\但它们都是为了优化特定场景性能而

新增的类型。使用 ValueTask<T> 则须要导入：

Install - Package System.Threading.Tasks.Extensions

6.7. 数字文本语法的改进（Numeric literal syntax improvements）

C# 7 还包含两个新特性：二进制文字、数字分隔符，以下所示：

var one = 0b0001;
var sixteen = 0b0001_0000;
long salary = 1000_000_000;
decimal pi = 3.141_592_653_589m;

注：二进制文本是以0b（零b）开头，字母不区分大小写；数字分隔符只有三个地方不能写：开头，结尾，小数点先后。

总结：二进制文本，数字分隔符可以使常量值更具可读性。

7、异步的优化

　　尽管如此，异步方法能够返回的内容是一些小改进,可是能够在某些状况下提供巨大的性能提高。你再也不须要返回一个Task,若是值已经可用, 这能够减小开销,使用async方法来建立Task对象。

8、总结

　　在这个介绍性章节中，您看到了一个简短而高级的摘要，与先前版本相比，.NET Core 2和ASP.NET Core 2众多变化。

如今，你也知道了.NET Standard 2及其用途。咱们展现了C＃6和C＃7中可用的一些新功能的例子。

这些可能很是有用的是让你用更少的东西编写更多东西，并使你的代码更易读和更容易维护。

《ASP.NET Core 高性能系列》这是一本关于通常Web应用程序性能改进的文章，并且不少无视语言或框架的知识。

　　下一章中，您将了解性能如何重要,并了解崭新的新.NET Core开发栈, 咱们还将看到可用的工具,并了解用图表展现硬件性能。