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便利性的產品。