C#杂项聊一聊

C#是怎么跑起来的

C#源代码生成IL（中间语言）， CLR（公共语言运行时）翻译成机器指令：

坏处

慢，
运行时，
IL更易读更容易反编译

好处

跨平台
承载多语言（VB.NET, F#）

C#编译过程

.netFrameWork, Standard, Core

程序集是由一个或者多个托管模块以及资源文件等共同组成的，C#编译器（csc.exe）再把源码编程成IL代码和元数据的时候，会进一步连同资源文件合并成程序集，

实际上就是个PE32文件，里面包含一个清单文件和多个托管模块和资源（如图），另外程序集中还有一些自描述信息。

2、执行过程

　　编译器生成好程序集以后，如果是可执行的程序集，会在Main方法执行之前，window会预先读取程序集的头文件（pe32），如果是x86则开一个32位的进程，x64的就开一个64位的进程

然后在进程空间里面加载MSCOREE.DLL的x86 或者x64版本或者arm版本，然后进程的主线程会调用MSCOREE.DLL的一个方法，初始化Clr,而Clr会加载程序集exe,再调用其入口方法Main。

3.Main方法内部执行

　在Main执行之前，Clr 会检测出方法引用的所有类型，（Console）,然后在内存中分配对应数据类型的空间，这个地址里面包含着这个类型所有的方法声名，每一项都对应着Clr里面的一个未编档函数（JITCompiler）

首次运行Main方法的试试JITCompiler会被调用，在这个方法里面:

负责在方法的实现类型中（console）程序集元数据中查询该方法的IL方法 ;
动态分配内存块 ;
把IL编译成本机Cpu的指令，存储到动态分配的空间里面;
修改这个条目的地址，使它指向动态分配的地址 , 跳转到内存块中的本机代码执行，这时候执行的就是IL代码的cpu机器码;
再次执行Console.WriteLine的时候，就不会运行JITCompiler,直接运行机器码;

程序集是由元数据和IL组成的。IL是和CPU无关的语言，是微软的几个专家请教了外面的编译器的作则，开发出来的。IL比大多数机器语言都要高级一点。IL能够访问和操作对象类型，并提高了指令来初始化对象，调用对象上的虚方法以及直接操作数组元素。

为了执行这个方法，首先必须要先把方法里面的IL代码转换为本机的CPU指令。这就是CLR里面的JIT（即时）编译器的职责。

JIT的功能主要是这样的：

1、在负责实现类型的（console)程序集的元数据中查找被调用的方法（WriteLine)

2、从元数据里面找到该方法的IL

3、分配内存块

4、将IL编译成本机的cpu指令，然后把这些东西扔进步骤三分配的内存块里面。

5、在Type表中修改对应的方法，让它指向步骤三分配的内存块

6、调到内存块执行本机代码。

当你第二次调用Console.WriteLine的时候，由于之前已经对WriteLine方法进行了验证和编译，所以到了第二次的话，就直接执行内存中的代码块了。

方法在首次被调用的时候，会有一些性能损失。以后对该方法的所有调用都以本机代码的形式全速运行。

1618027497097

Windows UI层和Linux UI层不是在一个层面上，Windows是直接注入到内核中， Linux是在内核层上面的一个应用；Windows UI跨平台不容易；

1618027839258

.netFrameWork 和 Core是运行时， Standard是标准;

Mono是按Standard设计的，

1618028020161

还有Unity，推荐C#作为开发语言；

针对特殊的CPU进行优化， CLR + JIT；

Lambda表达式

CascadiaCode字体下载链接:https://github.com/microsoft/cascadia-code/releases/download/v2102.25/CascadiaCode-2102.25.zip

连字体属性 等宽字体

微软中文docs:https://docs.microsoft.com/zh-cn/

编程另外一个好看的字体: Fira Code， jeb字体

Version1.0

 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


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

namespace LambdaDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            void DoSomething(Func<string, string> do_sth)
            {
                var name = "Bomir";
                var result = do_sth(name);
                WriteLine(result);
            }

            string BomirLoveFSC(string name)
            {
                var result = name + "喜欢FSC";
                return result;
            }

            DoSomething(BomirLoveFSC);
            ReadLine();
        }
    }
}

Version2.0

 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


using System;
using static System.Console;

namespace LambdaDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            void DoSomething(Func<string, string> do_sth)
            {
                var name = "Bomir";
                var result = do_sth(name);
                WriteLine(result);
            }

            DoSomething
            (
                delegate (string name)
                {
                    var result = name + "喜欢FSC";
                    return result;
                }
            );

            ReadLine();
        }
    }
}

Version3.0

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


using System;
using static System.Console;

namespace LambdaDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            void DoSomething(Func<string, string> do_sth)
            {
                var name = "Bomir";
                var result = do_sth(name);
                WriteLine(result);
            }

            DoSomething(name => name + "喜欢FSC");

            ReadLine();
        }
    }
}

由Linq带来的扩展方法

Where(IEnumerable, Func<Tsource, Boolean>),

 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
32
33
34
35


using System;
using System.Collections.Generic;
using System.Linq;
using static System.Console;

namespace LambdaDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            var list = new List<Person>
            {
                new Person{ age = 17, name = "张三"},
                new Person{ age = 33, name = "李四"},
                new Person{ age = 25, name = "王五"},
                new Person{ age = 5, name = "赵六"},
                new Person{ age = 38, name = "唐三"},

            };

            list.Where(p => p.age > 18)
                .ToList()
                .ForEach(c => WriteLine($"{c.name}"));

            ReadLine();
        }

        class Person
        {
            public int age;
            public string name;
        }
    }
}

集合论

委托

delegate void Help(); // 声明委托

变量和函数不能直接存活在命名空间里，类和delegate可以直接放：

普通变量存的是数据，委托变量存的是行为；

1.委托实例化后调用，和函数的直接调用有什么区别？

委托变量可以存放不同的行为，是可以改变的;

1618025883868

委托 + 泛型；

Action委托， Func委托， lambda表达式

异步

winform读取数据库或者文件时候，界面卡住了？（new thread()）

1618021383680

客户点咖啡，可能咖啡店很多人，同步的做法就是在那里排队等待，直到咖啡做完，才给客户送去，等咖啡的人白白浪费时间;

粗浅的想法是：起一个线程，让他去等待，直到完成；（如果很多订单，就会起很多线程，其实这样对系统资源也是一种浪费）

比较好的做法是：起一个线程，不在那里等待，回来做自己的事情，然后当咖啡做完，再去取;

在店里怎么知道咖啡是做好的？

两种方式

事件通知
轮询

C# 5.0才引入async, await, 异步 + 多线程，

Task概念

专注于任务，而不是关注这个任务是谁去完成的， Task.Run( () => {}), 不一定起了新线程，运行时帮忙调度系统资源，

1:1 模型
M:N模型
绿色线程

IO密集型任务: 等别的系统的任务，卡在别人那里（等待数据库，等待系统读取磁盘等等），这时候就适合异步方式；

计算密集型任务

事情卡在计算上面，任务需要实实在在的去处理，走不开，回调没什么作用：

TPL （任务并行库）

并行：时间点上的概念

并发：时间段上的概念

Actor模型

事件就是将上述模式正常化的一个语言特性；
事件是一种结构，为了实现广播者/订阅者模型，它只是暴露了所需委托特性的部分子集；
事件的主要目的就是防止订阅者之间互相打扰；

文章目录