.net core底层入门学习笔记（六-异常）

最新推荐文章于 2022-12-17 19:41:17 发布
最新推荐文章于 2022-12-17 19:41:17 发布
阅读量306 收藏
点赞数
分类专栏： .NET 文章标签： .net
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kylinok/article/details/118511556
版权

.net core底层入门学习笔记（六）

本篇开始主要记录.net core的异常处理机制

文章目录

前言

处理意外情况的传统方式，通过函数返回值报告给调用函数，是否发生错误，并通过线程本地变量存储最后一次发生错误的原因。这样做会导致很多问题，例如：

  • 每次调用函数都要检查返回值，容易忽略
  • 详细的错误信息需要自定义结构体，且很难阅读
  • 如果当前调用函数无法处理异常，则要向上传递，传递过程冗长且传递处理很麻烦
  • 函数重构后，异常信息结构变动，很多调用代码都要相应修改

.net core提供了新的机制，使用异常来报告错误，需要编译器和运行时的支持。编译器要帮助用户自动生成异常处理使用的数据，运行时需要读取与分析这些数据。
使用异常机制，用户通过抛出异常与捕捉传递错误，不要调用函数通过检查返回值来检测异常，并且还能包含更为详细的错误信息。
使用异常还有一个特征，就是如果不处理错误，异常会自动向上传递。
虽然异常很好用，但是异常发生时的处理成本很高，所以需要用户按需使用返回值，或者异常的方式处理异常。

提示：以下是本篇文章正文内容，下面案例可供参考

一、.net中的异常

.net中异常处理由try,catch，when,finally组成，且支持多层嵌套。try块中的代码无论是否抛出异常，都会执行finally中的内容。
如果try中抛出了异常，.net运行时会根据catch指定的异常类型，以及when返回的结果找到对应的catch块，将抛出的异常对象传递给catch块进行处理，接着程序恢复运行。

.net中异常结构保存方式

.net程序中，每个托管函数都有对应的异常处理表，异常处理表记录了try,catch，catch过滤器（when），以及finally块的范围与他们的对应关系。

class  ExceptionExample
    {

        public static void example()
        {
            try
            {
                Console.WriteLine("try outer");
                try
                {
                    Console.WriteLine("try inner");
                }
                catch (Exception e)
                {
                    Console.WriteLine("catch inner");
                    throw;
                }
            }
            catch (ArgumentException e)
            {
                Console.WriteLine("catch ArgumentException outer");
            }
            catch (Exception e)
            {
                Console.WriteLine("catch Exception outer");
            }
            finally
            {
                Console.WriteLine("finally outer");
            }
        }
        
        
        
    }

class private auto ansi beforefieldinit
  dotnet_test.ExceptionExample
    extends [System.Runtime]System.Object
{

  .method public hidebysig static void
    example() cil managed
  {
    .maxstack 1
    .locals init (
      [0] class [System.Runtime]System.Exception e,
      [1] class [System.Runtime]System.ArgumentException e_V_1,
      [2] class [System.Runtime]System.Exception e_V_2
    )

    // [66 9 - 66 10]
    IL_0000: nop
    .try
    {
      .try
      {

        // [68 13 - 68 14]
        IL_0001: nop

        // [69 17 - 69 48]
        IL_0002: ldstr        "try outer"
        IL_0007: call         void [System.Console]System.Console::WriteLine(string)
        IL_000c: nop
        .try
        {

          // [71 17 - 71 18]
          IL_000d: nop

          // [72 21 - 72 52]
          IL_000e: ldstr        "try inner"
          IL_0013: call         void [System.Console]System.Console::WriteLine(string)
          IL_0018: nop

          // [73 17 - 73 18]
          IL_0019: nop
          IL_001a: leave.s      IL_002b
        } // end of .try
        catch [System.Runtime]System.Exception
        {

          // [74 17 - 74 36]
          IL_001c: stloc.0      // e

          // [75 17 - 75 18]
          IL_001d: nop

          // [76 21 - 76 54]
          IL_001e: ldstr        "catch inner"
          IL_0023: call         void [System.Console]System.Console::WriteLine(string)
          IL_0028: nop

          // [77 21 - 77 27]
          IL_0029: rethrow
        } // end of catch

        // [79 13 - 79 14]
        IL_002b: nop
        IL_002c: leave.s      IL_004e
      } // end of .try
      catch [System.Runtime]System.ArgumentException
      {

        // [80 13 - 80 40]
        IL_002e: stloc.1      // e_V_1

        // [81 13 - 81 14]
        IL_002f: nop

        // [82 17 - 82 68]
        IL_0030: ldstr        "catch ArgumentException outer"
        IL_0035: call         void [System.Console]System.Console::WriteLine(string)
        IL_003a: nop

        // [83 13 - 83 14]
        IL_003b: nop
        IL_003c: leave.s      IL_004e
      } // end of catch
      catch [System.Runtime]System.Exception
      {

        // [84 13 - 84 32]
        IL_003e: stloc.2      // e_V_2

        // [85 13 - 85 14]
        IL_003f: nop

        // [86 17 - 86 60]
        IL_0040: ldstr        "catch Exception outer"
        IL_0045: call         void [System.Console]System.Console::WriteLine(string)
        IL_004a: nop

        // [87 13 - 87 14]
        IL_004b: nop
        IL_004c: leave.s      IL_004e
      } // end of catch

      IL_004e: leave.s      IL_005e
    } // end of .try
    finally
    {

      // [89 13 - 89 14]
      IL_0050: nop

      // [90 17 - 90 52]
      IL_0051: ldstr        "finally outer"
      IL_0056: call         void [System.Console]System.Console::WriteLine(string)
      IL_005b: nop

      // [91 13 - 91 14]
      IL_005c: nop
      IL_005d: endfinally
    } // end of finally

    // [92 9 - 92 10]
    IL_005e: ret

  } // end of method ExceptionExample::example

  .method public hidebysig specialname rtspecialname instance void
    .ctor() cil managed
  {
    .maxstack 8

    IL_0000: ldarg.0      // this
    IL_0001: call         instance void [System.Runtime]System.Object::.ctor()
    IL_0006: nop
    IL_0007: ret

  } // end of method ExceptionExample::.ctor
} // end of class dotnet_test.ExceptionExample

通过ILDASM工具查看：

.method public hidebysig static void  example() cil managed
{
  // Code size       97 (0x61)
  .maxstack  1
  .locals init (int32 V_0,
           class [System.Runtime]System.Exception V_1,
           class [System.Runtime]System.ArgumentException V_2,
           class [System.Runtime]System.Exception V_3)
  IL_0000:  nop
  IL_0001:  ldc.i4.5
  IL_0002:  stloc.0
  IL_0003:  nop
  IL_0004:  ldstr      "try outer"
  IL_0009:  call       void [System.Console]System.Console::WriteLine(string)
  IL_000e:  nop
  IL_000f:  nop
  IL_0010:  ldstr      "try inner"
  IL_0015:  call       void [System.Console]System.Console::WriteLine(string)
  IL_001a:  nop
  IL_001b:  nop
  IL_001c:  leave.s    IL_002d
  IL_001e:  stloc.1
  IL_001f:  nop
  IL_0020:  ldstr      "catch inner"
  IL_0025:  call       void [System.Console]System.Console::WriteLine(string)
  IL_002a:  nop
  IL_002b:  rethrow
  IL_002d:  nop
  IL_002e:  leave.s    IL_0050
  IL_0030:  stloc.2
  IL_0031:  nop
  IL_0032:  ldstr      "catch ArgumentException outer"
  IL_0037:  call       void [System.Console]System.Console::WriteLine(string)
  IL_003c:  nop
  IL_003d:  nop
  IL_003e:  leave.s    IL_0050
  IL_0040:  stloc.3
  IL_0041:  nop
  IL_0042:  ldstr      "catch Exception outer"
  IL_0047:  call       void [System.Console]System.Console::WriteLine(string)
  IL_004c:  nop
  IL_004d:  nop
  IL_004e:  leave.s    IL_0050
  IL_0050:  leave.s    IL_0060
  IL_0052:  nop
  IL_0053:  ldstr      "finally outer"
  IL_0058:  call       void [System.Console]System.Console::WriteLine(string)
  IL_005d:  nop
  IL_005e:  nop
  IL_005f:  endfinally
  IL_0060:  ret
  IL_0061:  
  // Exception count 4
  .try IL_000f to IL_001e catch [System.Runtime]System.Exception handler IL_001e to IL_002d
  .try IL_0003 to IL_0030 catch [System.Runtime]System.ArgumentException handler IL_0030 to IL_0040
  .try IL_0003 to IL_0030 catch [System.Runtime]System.Exception handler IL_0040 to IL_0050
  .try IL_0003 to IL_0052 finally handler IL_0052 to IL_0060
} // end of method ExceptionExample::example

对比C#代码与对应的IL代码发现：

  • try catch finally，会被转化成try{try{}catch{}}finally{}结构，意义是一样的。
  • 本地变量表中，包含了几个异常需要的本地变量
  • 在dotpeek中查看的，与在ildasm中查看的不一致，因为一般编译器会隐藏异常处理表的信息，并生成结构更好理解的IL代码，在ildasm中取消expand try/catch选项，则可以直接看到异常表的信息，如上图中的最下面几行IL代码
  • 异常处理表中，规定了异常捕捉的范围，异常捕捉的类型，以及异常处理的指令范围
  • 发生异常时，.net运行时会按顺序检索异常处理表，找到对应的且合适的catch
  • 实际运行.net程序时，JIT编译器会把IL代码转换为机器码，将异常处理表生成机器码对应的异常处理表

二、用户异常的触发

上面提到异常的结构与异常表，下面记录异常将如何触发。

1.用户异常

异常按触发方式分为：用户异常，硬件异常。
用户异常：程序代码主动请求.net运行时抛出的异常：

  • 使用IL代码中的throw指令抛出异常对象
  • 调用.net内部函数抛出异常，如：托管堆分配对象，内存不足；转换对象类型不匹配等
  • JIT编译时，自动插入的异常代码，如：checked块内执行的算术运算，会插入溢出检测异常，数组访问插入数组索引越界异常等
1.通过throw抛出异常：
public static void Example(){
	throw new ArgumentException("Something is wrong!");
}

生成的IL代码如下：

 .method public hidebysig static void
    example() cil managed
  {
    .maxstack 8

    // [99 9 - 99 10]
    IL_0000: nop

    // [100 13 - 100 64]
    IL_0001: ldstr        "something is wrong!"
    IL_0006: newobj       instance void [System.Runtime]System.ArgumentException::.ctor(string)
    IL_000b: throw

  } // end of method ExceptionThrowExample::example

其中关键代码：

  • newobj指令，实例化异常对象
  • throw，抛出异常实例

对应的关键汇编代码：

call CORINFO_HELP_NEWSFAST     //.net内部函数从托管堆分配对象
move rsi,rax				//将上面函数得到的对象地址，分配到rsi寄存器中
.....省略字符串常量的获取与参数设置
call CORINFO_HELP_STRCNS	//.net内部函数获取字符串
move rdx,rax				//设置字符串为第二个参数
move rcx,rsi				//设置第一个参数为异常对象地址
call System.ArgumentException:.ctor(ref):this		//调用异常对象的构造函数，并使用上面的参数
call CORINFO_HELP_THROW		//.net内部函数，抛出异常

上面就是最简单的使用throw指令抛出异常的流程。注意几个内部函数的使用，这些函数是.net运行时提供给托管代码调用的内部函数，使用原生代码编写，这些函数本身可能会抛出原生异常，抛出的异常会通过不同平台的异常处理机制，传递到.net内部的异常处理入口，包装为托管异常，交给托管代码处理。
而使用throw指令抛出的异常，会先包装成原生异常，然后调用不同平台操作系统函数抛出原生异常，此时原生异常与原生代码抛出的异常，走统一逻辑最后都交给.net内部的ProcessCLRException函数，这个函数就是.net异常处理的入口。

2. 调用.net内部函数抛出异常

这些异常都会通过平台的异常处理机制，传递到.net内部的异常处理入口继续处理。

3. 编译器自动插入的抛出异常代码

Jit编译器根据传入的IL代码自动插入检查错误并抛出异常的指令。

2.硬件异常

CPU执行指令出现异常后，由CPU通知操作系统，操作系统再通知进程触发异常。X86平台上出现硬件异常，CPU会查找操作系统预先注册的中断处理表，再由操作系统通知进程发生异常，通知方式因操作系统而不同

1. 访问null对象的字段抛出异常

主流的.net运行时检查对象是否为null，不使用分支判断，交由硬件异常触发。.net中未插入引及期货你 用类型的分支判断，是因为.net使用对象频率很高，插入这样的代码会使得机器码变得非常庞大，且添加过多的分支，会影响cpu流水线以及分支预测的效率。
具体表现：move ecx,dword ptr[rcx + 8]假设rcx寄存器是某个对象obj的地址，8是其内部字段的偏移值地址，4是字段大小，如果这个时候obj对象为null，那么rcx就是0，这条指令会从地址8读取数据。虚拟内存8所在虚拟页没有对应的物理页，CPU通知操作系统发生硬件异常（缺页中断），操作系统判断改进程是否分配过该虚拟内存页，由于太低的地址页不允许进程申请，所以发生内存访问异常。
在windows上会检查进程是否注册SEH异常处理器，如果已经注册则调用异常处理器处理这个异常，没有则结束进程运行。
如果访问一个很大的偏移值字段，就有可能获取到非正常内存数据，这个时候.net会自动插入一条指令检查cmp dword prt[rcx],ecx,直接从rcx地址读取数据，不使用偏移值，如果obj还是为null，则这条指令就会触发异常。

2. 调用null对象方法抛出异常

.net会额外插入一条指令move eax,dword ptr[rcx]在调用方法前，原理与上面相同。结论：访问对象字段时，如果字段偏移值小于一定值，则不需要出入指令检测，调用方法时总需要插入检测指令。

3. 对整数进行零除抛出异常

相关指令：idiv edx:eax,dword ptr[reloc classVar[0xffffffff]]计算edx与eax寄存器组成的64位数值除以全局变量，这里后面的全局变量，还是本地变量，或者其他寄存器的值，都是根据用户程序决定的。
流程与上类似，抛出异常-操作系统捕捉-异常处理器-进程通知。需要注意的是浮点数的除法运算不会发生零除异常。

三、异常处理实现

1.异常处理过程

通过返回值报错错误时，错误逻辑处理嵌入在程序逻辑中。而通过抛出异常这种处理，需要在程序流程之外进行处理。
.net运行时，处理异常主要实现以下两个功能：
1.执行清理：调用沿途的finally块
2.恢复程序执行：调用对应的catch块并跳转到catch块后的代码。
实现的操作：
1.捕捉异常获取异常发生的位置
2.通过调用链跟踪获取抛出异常函数以及所有调用来源
3.获取元数据中的异常处理表（注：每个函数都有自己的异常处理表）
4.枚举异常处理表调用对应的finally块与catch块

2.捕捉异常并获取抛出异常的位置

通过汇编指令那一块内容可知，每个进程调用都有自己的栈空间，里面包含了函数调用的一套规则。利用这个规则，可以获取调用链。
抛出异常的位置实际上就是程序计数器的值（即当前指令地址），用户异常抛出位置在.net运行时内部，硬件异常，抛出位置等于执行失败指令地址，通常在托管代码中。
不同操作系统有不同的通知异常机制：
windows：用户异常直接到达异常处理入口，包装PEXCEPTION_RECORD,包含程序计数器的值与异常类型代码。硬件异常到达SEH处理器，PEXCEPTION_POINTERS包含PEXCEPTION_RECORD对象。
类Unix系统，用户异常使用C++抛出异常，包装成PEXCEPTION_RECORD，硬件异常通过信号处理器，根据上下文修改当前使用栈空间，然后根据信号类型生成PEXCEPTION_RECORD。
两者最终都会进入到统一的异常处理入口：ProcessCLRException中。

3.通过调用链跟踪获取抛出异常函数与所有调用来源

通过之前的x86汇编，通过eip程序计数器结合元数据，可以获得当前调用的函数，通过ebp+4的方式可以获得上一个函数返回地址，以及上一个函数的ebp备份地址，来获得调用链查找所有调用来源。
而X86-64不允许rbp寄存器保存进入函数时的栈顶位置，.net运行时借助函数对应的元数据计算函数帧大小，来找到上一个函数的返回地址。使用这种方式必须知道函数元数据，而.net允许托管函数与非托管函数互相调用。托管函数元数据，通过JIT编译器生成并由运行时管理，非托管函数如何处理呢？
.net托管线程对象，有一个列表用于专门记录托管函数与非托管函数之间的切换。调用链先枚举这个列表，再扫描栈内容，这样来跳过没有元数据，只查找栈中的托管函数来确定调用来源。

4.获取函数元数据中的异常处理表

之前IL代码中已经看过IL的异常处理表的数据格式，在真实处理异常时，使用的是机器码对应的异常处理表，这些异常处理表，是在.net异常处理入口接收到操作系统传递给进程异常时，.net内部对异常处理所定义的结构。

5.枚举异常处理表，找到catch与finally

主要步骤：

  1. 遍历调用链，找到对应的catch块（只要catch块与抛出的异常类型对应，则终止查找，因为已经找到可以处理异常的代码块了）
  2. 回滚调用链，调用沿途的finally块与最终的catch块

回滚调用链的过程：

  1. 调整栈顶，移除抛出异常的函数帧
  2. 调用调用链中函数的finally块（如果有的话），如果不是对应的catch块，则移除此函数帧
  3. 一直执行2，直到发现对应的函数帧中有指定的catch块，执行catch块内容（其实就是跳转到catch块指令），执行完毕后，再次跳转到catch后续代码指令地址。

移除函数帧，通过栈顶寄存器实现，而执行指令通过程序计数器实现，一旦移除相当于函数后的指令都不会再执行了，且此时的函数调用链丢失。

6.重新抛出的异常

如果finally块或catch块代码抛出异常，程序会再次进入异常处理流程，此时调用链已经丢失。如果是有意抛出异常，则需要使用无参数throw或ExceptionDispatchInfo.Capture(ex).Throw函数，相当于承接了上一次的异常，这样原始来源的异常也可以传递到上层函数。

namespace dotnet_test
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                A();
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }
        }

        private static void C()
        {
            throw new Exception("aaa");
        }
        
        private static void B()
        {
            C();
        }
        
        private static void A()
        {
            try
            {
                B();
            }
            catch (Exception e)
            {
               1. throw e;
               2. throw;
               3. ExceptionDispatchInfo.Capture(e).Throw();
               4. throw new Exception("bbb");
				
            }
        }
        

    }

    
}

System.Exception: aaa
   at dotnet_test.Program.A() in H:\dotnet_test\Program.cs:line 38
   at dotnet_test.Program.Main(String[] args) in H:\dotnet_test\Program.cs:line
12


System.Exception: aaa
   at dotnet_test.Program.C() in H:\dotnet_test\Program.cs:line 22
   at dotnet_test.Program.B() in H:\dotnet_test\Program.cs:line 27
   at dotnet_test.Program.A() in H:\dotnet_test\Program.cs:line 34
   at dotnet_test.Program.Main(String[] args) in H:\dotnet_test\Program.cs:line 12


System.Exception: aaa
   at dotnet_test.Program.C() in H:\dotnet_test\Program.cs:line 23
   at dotnet_test.Program.B() in H:\dotnet_test\Program.cs:line 28
   at dotnet_test.Program.A() in H:\dotnet_test\Program.cs:line 35
--- End of stack trace from previous location ---
   at dotnet_test.Program.A() in H:\dotnet_test\Program.cs:line 39
   at dotnet_test.Program.Main(String[] args) in H:\dotnet_test\Program.cs:line 13


System.Exception: bbb
   at dotnet_test.Program.A() in H:\dotnet_test\Program.cs:line 39
   at dotnet_test.Program.Main(String[] args) in H:\dotnet_test\Program.cs:line 13

以上四种方式抛出的结果，显而易见，ExceptionDispatchInfo.Capture(e).Throw()能够最大程度的保留所有信息。这里如果A的捕捉类型改为其他，则A无法捕捉到相应的异常，但是依然会调用A里面的finally内容。所以得出结论：try用于捕捉异常，catch用于处理异常，finally无论是否捕捉到都会执行。

catch (FormatException e)
            {
                throw new Exception("bbb");
                ;
            }
            finally
            {
                Console.WriteLine("123");
            }

7.异常处理对于性能影响

具体的测试用例，就是循环执行，通过对比，使用返回值与抛出异常两种方式查看执行消耗的时间对比。之类就不具体放出来了，主要就是通过stopwatch类进行统计运行时长。

结论：异常发生频率越高，抛出异常消耗远大于返回错误放方式，如果异常发生频率较低，则两者消耗差不多。即：如果在函数使用不当，实现不正确，文件访问错误等低频可能发生的错误，使用异常抛出的方式处理，如果是高频的发生错误，或者错误由第三方来源触发，最好使用返回值错误方式处理异常。

总结

本节主要介绍.NET中异常处理方式，流程，机制，以及各种异常触发方式；还介绍了异常处理表，调用链跟踪（X86-64的处理，非托管函数处理等），最后介绍了重新抛出异常的几种捕捉结果，以及最终抛出异常性能消耗，得出在低频错误应使用抛出异常的方式处理的结论。

kylinok
关注
专栏目录
OpenCV学习笔记： 快速入门例程
LinJM-机器视觉
08-14 3445
先期基础： ———————————————————————————— Main函数参数argc，argv说明 C/C++语言中的main函数，经常带有参数argc，argv，如下： int main(int argc, char** argv) int main(int argc, char* argv[]) 这两个参数的作用: argc 是指命令行输入参数的个数(以空白符分隔) argv存储了所有的命令行参数 假如你的程序是hello.exe，如果在命令行运行该程序，（首先应该在命令行下用 cd 命令进入
ASP.NET Core 入门教程
01-17
ASP.NET Core学习教程，详细学习文档，可以学习到详细的基础知识和部分的实践。
.net core底层入门学习笔记（十-GC详细流程）
kylinok的博客
07-31 800
.net core底层入门学习笔记（十） 本节开始记录具体GC的详细流程 文章目录.net core底层入门学习笔记（十）一、标记阶段1.获取根对象2.递归扫描根对象并设置存活标记3.卡片表扫描跨代引用设置存活标记4.强引用GC句柄设置存活标记5.固定GC句柄设置存活标记6.弱引用GC句柄，清空不再存活对象7.扫描析构对象列表，添加不再存活对象到析构队列8.枚举跟踪复活弱引用GC句柄，清空不再存活对象9.是否启用升代二、使用步骤1.引入库2.读入数据总结 一、标记阶段 1.获取根对象 根对象是程序正
.net core底层入门学习笔记（一-介绍与IL）
kylinok的博客
06-27 2219
草稿： 1.await 关键字会自动记录当前的同步上下文，回调时会自动在之前的线程上下文中进行回调。
【.Net Core底层入门】MSIL入门
最新发布
qq_38139418的博客
12-17 326
.net core底层入门之il指令格式
.net core底层入门学习笔记（十三-JIT后台阶段与机器码生成）
kylinok的博客
08-17 493
.net core底层入门学习笔记（十三） 本篇主要记录，基于前面流程分析，变量版本标记等过程后的一些优化操作 文章目录.net core底层入门学习笔记（十三）一、赋值传播二、公共子表达式消除三、断言传播四、边界消除检查二、使用步骤1.引入库2.读入数据总结 一、赋值传播 赋值传播阶段，会替换变量到其他拥有相同值(VN)的变量以减少赋值次数删除多余的本地变量。 RyuJIT实现赋值传播的流程：1.为每个本地变量分配一个栈结构，根据支配顺序枚举基础块，遇到变量赋值往栈结构推入新版本；遇到本地变量使用，
Vue快速入门学习笔记(更新ing)
喜欢前端的后端 MelodyJerry
11-15 4178
原在博客园发布，先同步到CSDN：https://www.cnblogs.com/melodyjerry/p/13768594.html 本笔记综合了视频狂神说的Vue快速上手和菜鸟教程、CSDN等博客文章，以及个人的一些学习见解与体会。 由于是为了团队需要而快速入门，HTML、CSS、JS、Vue等基础均不全，故本笔记仅供参考学习使用。 Vue 的核心库只关注视图层，方便与第三方库或既有项目整合。 HTML + CSS + JS : 视图 ： 给用户看，刷新后台给的数据 网络通信 ： axios.
【学习笔记】大数据技术之Hadoop（入门）
prague6695的博客
03-14 7675
大数据技术之Hadoop1. 概念1.1 Hadoop是什么？1.2 Hadoop发展历史10.3 Hadoop的三大发行版本1.4 Hadoop优势（4高）1.5 Hadoop组成，1.x 2.x 3.x区别（重点）1.5.1 HDFS架构概述1.5.2 YARN架构概述1.5.3 MapReduce架构概述1.5.4 HDFS、YARN、MapReduce三者关系1.6 大数据技术生态体系1.7 推荐系统框架图2. 环境准备3. Hadoop生产集群搭建4. 常见错误的解决方案 1. 概念 1.1 Ha
【狂神说】Docker 学习笔记【基础篇】
weixin_46703850的博客
02-04 6302
学习思想而非学技术，技术日新月异，唯有思想长盛不衰，润泽后生 学习资料： 【狂神说Java】Docker最新超详细版教程通俗易懂_哔哩哔哩_bilibili Docker快速入门总结笔记_huangjhai的博客-CSDN博客 (74条消息) docker 进阶 之容器数据卷 DockerFile Docker网络 — 狂神说_cheng的博客-CSDN博客 官网：https://www.docker.com/ 文档地址： https://docs.docker.com/ （Docker 官网文档超级详.
asp.net core 2.1教程（全中文版）.pdf
01-15
数百万开发人员使用过（并将继续使用） ASP.NET 4.x 创建 Web 应用。 ASP.NET Core 是重新设计的 ASP.NET 4.x ，更改了体系结构，形成了更精简的模块化框架。 ASP.NET Core 具有如下优点： 生成 Web UI 和 Web API 的统一场景。 集成新式客户端框架和开发工作流。 基于环境的云就绪配置系统。 内置依赖项注入。 轻型的高性能模块化 HTTP 请求管道。 能够在 IIS 、 Nginx 、 Apache 、 Docker 上进行托管或在自己的进程中进行自托管。 定目标到 .NET Core 时，可以使用并行应用版本控制。 简化新式 Web 开发的工具。 能够在 Windows 、 macOS 和 Linux 进行生成和运行。 开放源代码和以社区为中心。
.NET Core 2.1完整中文教程PDF
07-26
最新完整版.NET Core2.1中文文档PDF文件，包含ASP.NET Core、.NET Core MVC、.NET Core Web API，绝对适合新手入门。
_net Core简介和概述.pdf
05-03
NET Core 是一个通用的开放源代码开发平台。 可以使用多种编程语言针对 x64、x86、ARM32 和 ARM64 处理器创 建适用于 Windows、macOS 和 Linux 的 .NET Core 应用。 为云、IoT（物联网）、客户端 UI 和机器学习提供了框架和 API。 下载 .NET CoreSDK，尝试在计算机上使用 .NET Core。 最新版是 .NET Core 3.1。
深入了解ASP.NET底层架构（图书）.pdf
07-21
asp.net的底层架构,深入了解,比较全面的概述了底层框架的知识,有助于程序员提升!
.net core底层入门学习笔记（八-异步与任务并行库Task）
kylinok的博客
07-20 1683
.net core底层入门学习笔记（八） 本篇主要记录.net中的异步操作 文章目录.net core底层入门学习笔记（八）前言一、阻塞操作与事件循环二、.net中的异步编程模型三、任务并行库任务并行库的实现原理二、使用步骤1.引入库2.读入数据总结 前言 异步操作表示，执行某项操作以后不等操作结束，但可以额外在操作结束后收到通知。 一、阻塞操作与事件循环 前面提到线程是CPU可以执行的一段任务。线程可以进入休眠，等待被操作系统唤醒继续执行，切换线程有一定的性能成本。 很多时候程序需要调用一些阻
.NET Core 学习资料精选：入门
IT技术分享社区
07-21 4026
开源跨平台的.NET Core，还没上车的赶紧的，来不及解释了…… 本系列文章，主要分享一些.NET Core比较优秀的社区资料和微软官方资料。我进行了知识...
.NET Core入门学习手册
dotNet全栈开发
08-02 1534
推荐：适合小白入门的Asp.Net Core 开源学习手册 前言 推荐一个入门级的.NET Core开源项目，非常适合新手入门学习.NET Core。 开源地址: https://github.com/windsting/little-aspnetcore-book。 手册在线下载地址： https://nbarbettini.gitbooks.io/little-asp-net-core-book/content/chapters/mvc-basics/create-view.html [外链图片转存失败
.net core 实践笔记（三）--封装底层
weixin_30387339的博客
11-16 253
前言： 　　有了前面的工作，简单的架子基本搭建起来了，因为条件有限，只能先测试SqlServer的了，源码放出来，也希望有兴趣的伙伴可以一起改善，相信可以成为未来进阶架构师的第一步，自己有小项目的时候可以直接拿来修改使用。 　　因为第一次在.net core搭建，经验欠缺，不足之处，欢迎批评指正。 　　后面将增加日志记录。 **温馨提示：如需转载本文，请注明内容出处。** 本...
.Net Core 入门（六）配置管道
weixin_41365424的博客
11-18 317
public class Startup { public void ConfigureService(){} public void Configure(IApplictionBuilder app,IWebHostEnvironment env) { if(env.IsDevelopment()) { app.UseDeveloperExceptionPage(); } app.UseEndpints(endpoints=>{
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值