C#常見大廠面試題和答案

這期內容當中小編將會給大家帶來有關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本質是什么？請簡述他們的實現機制

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，用表格總結如下：

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，它會創建一個閉包和狀態機，需要編譯器生成代碼來指定繼續執行邏輯。

總結如下：

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) &#63; 
 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 &#63; $"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來表示。（關于這一點，其實特別重要，我稍后有空會深入聊聊這一點。）

總結

這些技術平時可能比較冷門，全部能回答正確也并不意味著會有多有用，可能很難有機會用上。

但如果是在開發像ASP.NET Core那樣的超高性能網絡服務器、中間件，或者Unity 3D那樣的高性能游戲引擎、或者做一些高性能實時ETL之類的，就能依靠這些知識，做出比肩甚至超過C/C++的性能，同時還能享受C#/.NET便利性的產品。

上述就是小編為大家分享的C#常見大廠面試題和答案了，如果剛好有類似的疑惑，不妨參照上述分析進行理解。如果想知道更多相關知識，歡迎關注億速云行業資訊頻道。