19道C#面试题

19道C#面试题

先略看题目：

1. 请简述async函数的编译方式
2. 请简述Task状态机的实现和工作机制
3. 请简述await的作用和原理，并说明和GetResult()有什么区别
4. Task和Thread有区别吗？如果有请简述区别
5. 简述yield的作用
6. 利用IEnumerable<T>实现斐波那契数列生成
7. 简述stackless coroutine和stackful coroutine的区别，并指出C#的coroutine是哪一种
8. 请简述SelectMany的作用
9. 请实现一个函数Compose用于将多个函数复合
10. 实现Maybe<T> monad，并利用LINQ实现对Nothing（空值）和Just（有值）的求和
11. 简述LINQ的lazy computation机制
12. 利用SelectMany实现两个数组中元素的两两相加
13. 请为三元函数实现柯里化
14. 请简述ref struct的作用
15. 请简述ref return的使用方法
16. 请利用foreach和ref为一个数组中的每个元素加1
17. 请简述ref、out和in在用作函数参数修饰符时的区别
18. 请简述非sealed类的IDisposable实现方法
19. delegate和event本质是什么？请简述他们的实现机制

没错，这是一位来自【广州.NET技术俱乐部】微信群的偏Programming Languages（编程语言开发科学）的大佬，本文我将斗胆回答一下这些题目😂。

由于这些题目（对我来说）比较难，因此我这次只斗胆回答前10道题，发作上篇，另外一半的题目再等我慢慢查阅资料，另行回答😂。

解析：

1. 请简述async函数的编译方式

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

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

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

1. 将所有引用的局部变量做成闭包，放到一个隐藏的状态机的类中；
2. 将所有的await展开成一个状态号，有几个await就有几个状态号；
3. 每次执行完一个状态，都重复回调状态机的MoveNext方法，同时指定下一个状态号；
4. MoveNext方法还需处理线程和异常等问题。

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

从状态机的角度出发，await的本质是调用Task.GetAwaiter()的UnsafeOnCompleted(Action)回调，并指定下一个状态号。

从多线程的角度出发，如果await的Task需要在新的线程上执行，该状态机的MoveNext()方法会立即返回，此时，主线程被释放出来了，然后在UnsafeOnCompleted回调的action指定的线程上下文中继续MoveNext()和下一个状态的代码。

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

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

4. 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就对了。

5. 简述yield的作用

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

如果不使用yield，需实现IEnumerable<T>，它只暴露了GetEnumerator<T>，这样确保yield是可重入的，比较符合人的习惯。

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

6. 利用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);
	}
}

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

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

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

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

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

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

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

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

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

总结如下：

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

8. 请简述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题作演示。

9. 请实现一个函数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

10. 实现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>();

		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>()
	{
		return new Maybe<T>();
	}
}

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

其次，不是所有的LINQ都要走IEnumerable<T>，可以用手撸的LINQ表达式——SelectMany来表示。（关于这一点，其实特别重要，我稍后有空会深入聊聊这一点。）

这些题目确实不怎么经常使用，因此在后文中，我会提一组我的私房经典“6k面试题”，供大家轻松一刻。

先略看题目：

11. 简述 LINQ 的 lazy computation 机制
12. 利用 SelectMany 实现两个数组中元素做笛卡尔集，然后一一相加
13. 请为三元函数实现柯里化
14. 请简述 ref struct 的作用
15. 请简述 ref return 的使用方法
16. 请利用 foreach 和 ref 为一个数组中的每个元素加 1
17. 请简述 ref 、 out 和 in 在用作函数参数修饰符时的区别
18. 请简述非 sealed 类的 IDisposable 实现方法
19. delegate 和 event 本质是什么？请简述他们的实现机制

解析：

11. 简述 LINQ 的 lazy computation 机制

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

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

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

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

12. 利用 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}"

执行效果完全一样。

13. 请为三元函数实现柯里化

解析：柯里化是指将 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# 签名也能不用写参数了吧，因为参数确实太长了😂

14. 请简述 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 ，就再也没这个问题了。

15. 请简述 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++ 中的指针一样。

16. 请利用 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> 。

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

• ref 参数可同时用于输入或输出（变量使用前必须初始化）；
• out 参数只用于输出（使用前无需初始化）；
• in 参数只用于输入，它按引用传递，它能确保在使用过程中不被修改（变量使用前必须初始化）；

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

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

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

18. 请简述非 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)来释放父类。

19. 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
// 11

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

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

总结

这些技术平时可能比较冷门，全部能回答正确也并不意味着会有多有用，可能很难有机会用上。

但如果是在开发像 ASP.NET Core 那样的超高性能网络服务器、中间件，或者 Unity 3D 那样的高性能游戏引擎、或者做一些高性能实时 ETL 之类的，就能依靠这些知识，做出比肩甚至超过 C / C++ 的性能，同时还能享受 C# / .NET 便利性的产品。

群里有人戏称面试时出这些题的公司，要么是心太大，要么至少得开 60k ，因此本文取名为 60k大佬 。

轻松一刻——我的私房.NET后端6k面试题：

1. .NET的int占几字节？
2. .NET的值类型和引用类型有什么区别？性能方面有何差异？
3. List<T>内部是什么数据结构？
4. Dictionary<K, V>内部是什么数据结构？
5. internal与protected有啥区别？
6. string/StringBuilder有啥区别？
7. 说出常用的Http状态码和使用场景；
8. 使用Entity Framework有哪些提高性能的技巧？
9. jwt（json web token）是什么，由哪些部分组成？
10. 计算DateTime类型需占用多少字节（需计算过程）

总结

这些技术平时可能比较冷门，全部能回答正确也并不意味着会有多有用，可能很难有机会用上。

但如果是在开发像ASP.NET Core那样的超高性能网络服务器、中间件，或者Unity 3D那样的高性能游戏引擎、或者做一些高性能实时ETL之类的，就能依靠这些知识，做出比肩甚至超过C/C++的性能，同时还能享受C#/.NET便利性的产品。