解析“60k”大佬的19道C#面试题(下)
解析“60k”大佬的19道C#面试题(下)
在上篇中,我解析了前 10
道题目,本篇我将尝试解析后面剩下的所有题目。
这些题目确实不怎么经常使用,因此在后文中,我会提一组我的私房经典“6k
面试题”,供大家轻松一刻。
先略看题目:
- 简述
LINQ
的lazy computation
机制 - 利用
SelectMany
实现两个数组中元素做笛卡尔集,然后一一相加 - 请为三元函数实现柯里化
- 请简述
ref struct
的作用 - 请简述
ref return
的使用方法 - 请利用
foreach
和ref
为一个数组中的每个元素加1
- 请简述
ref
、out
和in
在用作函数参数修饰符时的区别 - 请简述非
sealed
类的IDisposable
实现方法 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
来确保。
基于不被托管堆管理这一点,我们可以总结出以下结论:
- 不能对
ref struct
装箱(因为装箱就变成引用类型了)——包括不能转换为object
、dynamic
- 禁止实现任何接口(因为接口是引用类型)
- 禁止在
class
和struct
中使用ref struct
做成员或自动属性(因为禁止随意移动,因此不能放到托管堆中。而引用类型、struct
成员和自动属性都可能是在托管内存中) - 禁止在迭代器(
yield
)中使用ref struct
(因为迭代器本质是状态机,状态机是一个引用类型) - 在
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];
}
注意事项:
- 参数可以用
Span<T>
或者ref T
- 返回的时候使用
return ref val
- 注意返回值需要加
ref
- 在赋值时,等号两边的变量,都需要加
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);
}
}
它有如下要注意的点:
- 引入
disposed
变量用于判断是否已经回收过,如果回收过则不再回收; - 使用
protected virtual
来确保子类的正确回收,注意不是在Dispose
方法上加; - 使用
disposing
来判断是.NET
的终结器回收还是手动调用Dispose
回收,终结器回收不再需要关心释放托管内存; - 使用
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);
}
}
注意:
- 继承类也需要定义一个新的、不同的
disposed
值,不能和老的disposed
共用; - 其它判断、释放顺序和基类完全一样;
- 在
继承类
释放完后,调用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
面试题:
.NET
的int
占几字节?.NET
的值类型
和引用类型
有什么区别?性能方面有何差异?List<T>
内部是什么数据结构?Dictionary<K, V>
内部是什么数据结构?internal
与protected
有啥区别?string
/StringBuilder
有啥区别?- 说出常用的
Http
状态码和使用场景; - 使用
Entity Framework
有哪些提高性能的技巧? jwt
(json web token)是什么,由哪些部分组成?- 计算
DateTime
类型需占用多少字节(需计算过程)
喜欢的朋友请关注我的微信公众号:【DotNet骚操作】