C#面试题及详细解析

请简述async函数的编译方式

async/await是C#5.0推出的异步代码编程模型，其本质是编译为状态机。只要函数前带上async，就会将函数转换为状态机。

请简述Task状态机的实现和工作机制

CPS全称是Continuation Passing Style,在. NET中,它会自动编译为:

1、将所有引用的局部变量做成闭包，放到一个隐藏的状态机的类中；

2、将所有的await展开成一个状态号，有几个await就有几个状态号；

3、每次执行完一个状态，都重复回调状态机的MoveNext方法，同时指定下一个状态号；

4、MoveNext方法还需处理线程和异常等问题。

请简述await的作用和原理，并说明和GetResult()有什么区别

从状态机的角度出发,await的本质是调用Task. GetAwaiter()的

UnsafeOnCompleted(Action)回调,并指定下一个状态号。

从多线程的角度出发，如果await的Task需要在新的线程上执行，该状态机的MoveNext()方法会立即返回，此时，主线程被释放出来了，然后在

UnsafeOnCompleted回调的action指定的线程上下文中继续MoveNext()和下一个状态的代码。

而相比之下，GetResult()就是在当前线程上立即等待Task的完成，在Task完成前，当前线程不会释放。

注意:Task也可能不一定在新的线程上执行,此时用GetResult()或者await 就只有会不会创建状态机的区别了。

Task和Thread有区别吗?如果有请简述区别

Task和Thread都能创建用多线程的方式执行代码，但它们有较大的区别。

Task 较新,发布于. NET 4.5,能结合新的async/await代码模型写代码,它不止能创建新线程，还能使用线程池(默认)、单线程等方式编程，在UI编程领域，Task还能自动返回UI线程上下文，还提供了许多便利API 以管理多个Task，用表格总结如下：

区别	Task	Thread
.NET版本	4.5	1.1
async/await	支持	不支持
创建新线程	支持	支持
线程池／单线程	支持	不支持
返回主线程	支持	不支持
管理API	支持	不支持

TL;DR就是,用Task就对了。

简述yield的作用

yield需配合IEnumerable<T>一起使用,能在一个函数中支持多次(不是多个)返回,其本质和async/await一样,也是状态机。

如果不使用yield,需实现IEnumerable<T>,它只暴露了

GetEnumerator<T>,这样确保yield是可重入的,比较符合人的习惯。

注意,其它的语言,如C++/Java/ES6实现的yield,都叫generator(生成器),这相当于. NET中的IEnumerator<T>(而不是IEnumerable<T>)。这种设计导致yield不可重入，只要其迭代过一次，就无法重新迭代了，需要注意。

利用IEnumerable<T>实现斐波那契数列生成

IEnumerable<int>GenerateFibonacci(int n)

{

int current =1,next =1;

for (int  i =0;i < n;++i)

{

yield return current;

next=current+(current=next);

}

简述stackless coroutine和stackful coroutine的区别,并指出C#的coroutine是哪一种

1、stackless和stackful对应的是协程中栈的内存,stackless表示栈内存位置不固定，而stackful则需要分配一个固定的栈内存。

2、在继续执行(Continuation/MoveNext())时,stackless 需要编译器生成代码，如闭包，来自定义继续执行逻辑；而stackful则直接从原栈的位置继续执行。

3、性能方面，stackful的中断返回需要依赖控制CPU的跳转位置来实现，属于骚操作，会略微影响CPU的分支预测，从而影响性能(但影响不算大)，这方面stackless无影响。

4、内存方面,stackful需要分配一个固定大小的栈内存(如4kb),而stackless 只需创建带一个状态号变量的状态机，stackful占用的内存更大。

5、骚操作方面，stackful可以轻松实现完全一致的递归/异常处理等，没有任何影响，但stackless需要编译器作者高超的技艺才能实现(如C#的作者)，注意最初的C#5.0在try-catch块中是不能写await的。

6、和已有组件结合/框架依赖方面，stackless需要定义一个状态机类型，如Task<T>/IEnumerable<T>/IAsyncEnumerable<T>等,而stackful不需要,因此这方面stackless较麻烦。

7、Go属于stackful,因此每个goroutine需要分配一个固定大小的内存。

8、C#属于stackless，它会创建一个闭包和状态机，需要编译器生成代码来指定继续执行逻辑。

总结如下：

功能	stackless	stackful
内存位置	不固定	固定
继续执行	编译器定义	CPU跳转
性能／速度	快	快，但影响分支预测
内存占用	低	需要固定大小的栈内存
编译器难度	难	适中
组件依赖	不方便	方便
嵌套	不支持	支持
举例＞	C#/js	Go/C++Boost

请简述SelectMany的作用

相当于js中数组的flatMap，意思是将序列中的每一条数据，转换为0到多条数据。

SelectMany可以实现过滤/. Where,方法如下:

public static IEnumerable<T>MyWhere<T>(this IEnumerable<T>seq,Func<T,bool>predicate)

{

return seq. SelectMany(x =>predicate(x)?

new[]{x}:

Enumerable. Empty<T>());

SelectMany是LINQ中from关键字的组成部分,这一点将在第10题作演示。

请实现一个函数Compose用于将多个函数复合

public static Func<T1,T3>Compose<T1,T2,T3>(this Func<T1,T2>f1,Func<T2,T3>f2)

{

return x=>f2(f1(x));

}

然后使用方式：

Func<int,double>log2 =x=>Math. Log2(x);

Func<double,string>toString=x =>x. ToString();

var log2ToString=log2. Compose(toString);

Console. WriteLine(log2ToString(16));//4

实现Maybe<T>monad,并利用LINQ实现对Nothing(空值)和

Just(有值)的求和

本题比较难懂，经过和大佬确认，本质是要实现如下效果：

void Main()

{

Maybe<int>a=Maybe. Just(5);

Maybe<int>b=Maybe. Nothing<int>();

Maybe<int>c=Maybe. Just(10);

(from a0 in a from b0 in b select a0 +b0). Dump();//Nothing (from a0 in a from c0 in c select a0+c0). Dump();//Just 15

〗

按照我猴子进化来的大脑的理解，应该很自然地能写出如下代码：

public class Maybe<T>:IEnumerable<T>

{

public bool HasValue {get;set;}

public T Value {get;set;}

IEnumerable<T>ToValue()

{

if (HasValue)yield return Value;

}

public IEnumerator<T>GetEnumerator()

{

return ToValue(). GetEnumerator();

}

IEnumerator IEnumerable. GetEnumerator()

{

return ToValue(). GetEnumerator();

}

}

public class Maybe

{

public static Maybe<T>Just<T>(T value)

{

return new Maybe<T>{Value=value,HasValue=true};

}

public static Maybe<T>Nothing<T>()

{

return new Maybe<T>();

}

这种很自然,通过继承IEnumerable<T>来实现LINQ to Objects的基本功能，但却是错误答案。

正确答案：

public struct Maybe<T>

{

public readonly bool HasValue;

public readonly T Value;

public Maybe(bool hasValue,T value)

{

HasValue =hasValue;

Value =value;

}

public Maybe<B>SelectMany<TCollection,B>(Func<T,

Maybe<TCollection>>collectionSelector,Func<T,TCollection,B>f)

{

if (!HasValue)return Maybe. Nothing<B>();

Maybe<TCollection>collection=collectionSelector(Value);if (!collection. HasValue)return Maybe. Nothing<B>0;

return Maybe. Just(f(Value,collection. Value));

}

public override string ToString()=>HasValue?$"Just {Value}":

"Nothing";

}

public class Maybe

{

public static Maybe<T>Just<T>(T value)

{

return new Maybe<T>(true,value);

}

public static Maybe<T>Nothing<T>0

{

return new Maybe<T>();

}

﹞

注意：

首先这是一个函数式编程的应用场景，它应该使用struct——值类型。

其次,不是所有的LINQ都要走IEnumerable<T>,可以用手撸的LINQ表达式——SelectMany来表示。

简述LINQ的lazy computation机制

1、Lazy computation是指延迟计算，它可能体现在解析阶段的表达式树和求值阶段的状态机两方面。

2、首先是解析阶段的表达式树，C#编译器在编译时，它会将这些语句以表达式树的形式保存起来，在求值时，C#编译器会将所有的表达式树翻译成求值方法(如在数据库中执行SQL语句)。

3、其次是求值阶段的状态机,LINQ to Objects可以使用像IEnumemrable<T>接口，它本身不一定保存数据，只有在求值时，它返回一个迭代器/+   IEnumerator<T>/它才会根据MoveNext()/Value 来求值。

4、这两种机制可以确保LINQ是可以延迟计算的。

利用SelectMany实现两个数组中元素做笛卡尔集，然后——相加

//11\、利用`SelectMany`实现两个数组中元素的两两相加

int[] a1   = { 1,2,3,4,5};

int[] a2 = { 5,4,3,2,1 };

a1

. SelectMany(v=>a2,(v1,v2) =>$"{v1}+{v2}={v1 + v2}")

. Dump();

解析与说明：大多数人可能只了解SelectMany 做一转多的场景(两参数重载，类似于flatMap)，但它还提供了这个三参数的重载，可以允许你做多对多一一笛卡尔集。因此这些代码实际上可以用如下LINQ表示：

from v1 in a1

from v2 in a2

select $"{v1}+{v2}={v1+v2}"

执行效果完全一样。

请为三元函数实现柯里化

解析，柯里化是指将f(x，y)转换为f(x)(y)的过程，三元和二元同理：

Func<int,int,int,int>op3 =(a,b,c) =>(a-b)*c;

Func<int,Func<int,Func<int,int>>>op11  =a =>b=>c=>(a-b)*c;

op3(4,2,3). Dump();//6

op11(4)(2)(3). Dump();//6

通过实现一个泛型方法，实现通用的三元函数柯里化：

Func<T1,Func<T2,Func<T3,TR>>>Currylize3<T1,T2,T3,TR>(Func<T1,T2,T3,TR> op)

{

return  a=> b=>c =>op(a,b,c);

//测试代码：

var  op12 = Currylize3(op3);

op12(4)(2)(3). Dump();//(4-2)x3=6

现在了解为啥F#签名也能不用写参数了吧，因为参数确实太长了□

请简述ref struct的作用

ref struct 是C#7.2发布的新功能,主要是为了配合Span<T>,防止Span<T>被误用。

为什么会被误用呢?因为Span<T>表示一段连续、固定的内存，可供托管代码和非托管代码访问(不需要额外的fixed)这些内存可以从stackalloc中来,也能从fixed中获取托管的位置,也能通过Marshal. AllocHGlobal()等方式直接分配。这些内存应该是固定的、不能被托管堆移动。但之前的代码并不能很好地确保这一点，因此添加了ref struct来确保。

基于不被托管堆管理这一点，我们可以总结出以下结论：

1、不能对ref struct装箱(因为装箱就变成引用类型了)——包括不能转换为object 、dynamic

2、禁止实现任何接口(因为接口是引用类型)

3、禁止在class 和struct中使用ref struct做成员或自动属性(因为禁止随意移动，因此不能放到托管堆中。而引用类型、struct成员和自动属性都可能是在托管内存中)

4、禁止在迭代器(   yield)中使用ref struct   (因为迭代器本质是状态机,状态机是一个引用类型)

5、在Lambda 或本地函数中使用(因为Lambda/本地函数都是闭包，而闭包会生成一个引用类型的类)

以前常有一个疑问，我们常常说值类型在栈中，引用类型在堆中，那放在引用类型中的值类型成员，内存在哪?(在堆中，但必须要拷到栈上使用)

加入了ref struct,就再也没这个问题了。

请简述ref return 的使用方法

这也是个类似的问题，C#一直以来就有值类型，我们常常类比C++的类型系统(只有值类型)   它天生有性能好处，但C#之前很容易产生没必要的复制——导致C#并没有很好地享受值类型这一优点。

因此C#7.0引入了ref return,然后又在C#7.3 引入了ref参数可被赋值。

使用示例：

Span<int>values =stackalloc int[10086];

values[42]= 10010;

int v1  =SearchValue(values,10010);

v1  =10086;

Console. WriteLine(values[42]);//10010

ref int v =ref SearchRefValue(values,10010);

v = 10086;

Console. WriteLine(values[42]);//10086;

ref int SearchRefValue(Span<int>span,int value)

{

for(int i=0;i < span. Length;++i)

{

if(span[i]==value)

return ref span[i];

}

return ref span[0];

〗

int SearchValue(Span<int>span,int value)

{

for(int i=0;i< span. Length;++i)

{

if(span[i]==value)

return span[i];

}

return span[0];

〕

注意事项：

1、参数可以用Span<T>或者ref T

2、返回的时候使用return ref val

3.注意返回值需要加ref

4、在赋值时,等号两边的变量,都需要加ref关键字(   ref int v1 =ref v2 )其实这个ref就是C/C++中的指针一样。

请利用foreach 和ref为一个数组中的每个元素加1

int[] arr  = { 1,2,3,4,5};

Console. WriteLine(string. Join(",",arr));//1,2,3,4,5

foreach(ref int v in arr. AsSpan())

{

v++;

}

Console. WriteLine(string. Join(",",arr));//2,3,4,5,6

注意foreach不能用var,也不能直接用int,需要ref int,注意arr要转换为Span<T>。

请简述ref 、out 和in 在用作函数参数修饰符时的区别

1、ref参数可同时用于输入或输出(变量使用前必须初始化)；

2、out 参数只用于输出(使用前无需初始化)；

3、in 参数只用于输入，它按引用传递，它能确保在使用过程中不被修改(变量使用前必须初始化)；

可以用一个表格来比较它们的区别：

修饰符／区别		ref/		out		in	无
是否复制－		×		×		×	✔
能修改		✔		✔		×	×
输入		✔		×		✔	✔
输出	✔		✔		×		×
需初始化	✔		×

其实in就相当于C++中的const T&，我多年前就希望C#加入这个功能了。

请简述非sealed 类的IDisposable实现方法

正常IDisposable实现只有一个方法即可:

void Dispose()

{

//free managed resources...

//free unmanaged resources...

}

但它的缺点是必须手动调用Dispose()或使用using方法，如果忘记调用了，系统的垃圾回收器不会清理，这样就会存在资源浪费，如果调用多次，可能会存在问题,因此需要Dispose模式。

Dispose模式需要关心C#的终结器函数(有人称为析构函数，但我不推荐叫这个名字，因为它并不和constructor构造函数对应)，其最终版应该如下所示：

class BaseClass:IDisposable

{

private bool disposed=false;

~BaseClass()

{

Dispose(disposing:false);

}

protected virtual void Dispose(bool disposing)

{

if (disposed)return;

if(disposing)

{

//free managed resources...

}

//free unmanaged resources...

disposed =true;

}

public void Dispose()

{

Dispose(disposing:true);

GC. SuppressFinalize(this);

}

它有如下要注意的点：

1. 引入disposed变量用于判断是否已经回收过，如果回收过则不再回收；

2、使用protected virtual来确保子类的正确回收,注意不是在Dispose方法上加；

3、使用disposing来判断是. NET的终结器回收还是手动调用Dispose回收,终结器回收不再需要关心释放托管内存；

4、使用GC. SuppressFinalize(this)来避免多次调用Dispose;

至于本题为什么要关心非sealed类，因为sealed类不用关心继承，因此protected virtual 可以不需要。

在子类继承于这类，且有更多不同的资源需要管理时，实现方法如下：

class DerivedClass:BaseClass

{

private bool disposed=false;

protected override void Dispose(bool disposing)

{

if(disposed)return;

if(disposing)

{

//free managed resources...

}

//free unmanaged resources...

base. Dispose(disposing);

}

}

注意：

1、继承类也需要定义一个新的、不同的disposed值，不能和老的disposed 共用；

2、其它判断、释放顺序和基类完全一样；

3、在继承类释放完后,调用base. Dispose(disposing)来释放父类。

delegate 和event 本质是什么?请简述他们的实现机制

delegate和event本质都是多播委托(MultipleDelegate),它用数组的形式包装了多个Delegate，Delegate类和C中函数指针有点像，但它们都会保留类型、都保留this，因此都是类型安全的。

delegate(委托)在定义时,会自动创建一个继承于MultipleDelegate的类型,其构造函数为ctor(object o,IntPtr f),第一个参数是this值,第二个参数是函数指针，也就是说在委托赋值时，自动创建了一个MultipleDelegate的子类。

委托在调用()时,编译器会翻译为. Invoke()。

注意:delegate本身创建的类,也是继承于MultipleDelegate而非Delegate,因此它也能和事件一样，可以指定多个响应：

string text="Hello World";

Action v=()=>Console. WriteLine(text);v+=()=>Console. WriteLine(text. Length);v();

//Hello World

//1 1

注意,+=运算符会被编译器会翻译为Delegate. Combine(),同样地-=运算符会翻译为Delegate. Remove()。

事件是一种由编译器生成的特殊多播委托，其编译器生成的默认(可自定义)代码,与委托生成的MultipleDelegate相比,事件确保了+=和-=运算符的线程安全，还确保了null的时候可以被赋值(而已)。