解析“60k”大佬的19道C#面试题(下)
2020-03-29 23:42
701 查看
# 解析“60k”大佬的19道C#面试题(下)
在上篇中,我解析了前 `10` 道题目,本篇我将尝试解析后面剩下的所有题目。
> 姐妹篇:[解析“60k”大佬的19道C#面试题(上)](https://www.cnblogs.com/sdflysha/p/20200325-19-csharp-interview-question-from-60k-boss-1.html)
这些题目确实不怎么经常使用,因此在后文中,我会提一组我的私房经典“`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` 接口,它本身不一定保存数据,**只有在求值时**,它返回一个迭代器—— `IEnumerator` ,它才会根据 `MoveNext()` / `Value` 来求值。
这两种机制可以确保 `LINQ` 是可以延迟计算的。
## 12. 利用 `SelectMany` 实现两个数组中元素做笛卡尔集,然后一一相加
``` csharp
// 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` 表示:
``` csharp
from v1 in a1
from v2 in a2
select $"{v1}+{v2}={v1 + v2}"
```
执行效果完全一样。
## 13. 请为三元函数实现柯里化
解析:柯里化是指将 `f(x, y)` 转换为 `f(x)(y)` 的过程,三元和二元同理:
``` csharp
Func op3 = (a, b, c) => (a - b) * c;
Func op11 = a => b => c => (a - b) * c;
op3(4, 2, 3).Dump(); // 6
op11(4)(2)(3).Dump(); // 6
```
通过实现一个泛型方法,实现**通用的**三元函数柯里化:
``` csharp
Func Currylize3(Func 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` ,防止 `Span` 被误用。
为什么会被误用呢?因为 `Span` 表示一段连续、固定的内存,可供托管代码和非托管代码访问(不需要额外的 `fixed` )这些内存可以从 `stackalloc` 中来,也能从 `fixed` 中获取托管的位置,也能通过 `Marshal.AllocHGlobal()` 等方式直接分配。这些内存**应该**是固定的、不能被托管堆移动。但之前的代码并不能很好地确保这一点,因此添加了 `ref struct` 来确保。
基于**不被托管堆管理**这一点,我们可以总结出以下结论:
01. 不能对 `ref struct` 装箱(因为装箱就变成引用类型了)——包括不能转换为 `object` 、 `dynamic`
02. 禁止实现任何接口(因为接口是引用类型)
03. 禁止在 `class` 和 `struct` 中使用 `ref struct` 做成员或自动属性(因为禁止随意移动,因此不能放到托管堆中。而引用类型、 `struct` 成员和自动属性都可能是在托管内存中)
04. 禁止在迭代器( `yield` )中使用 `ref struct` (因为迭代器本质是状态机,状态机是一个引用类型)
05. 在 `Lambda` 或 `本地函数` 中使用(因为 `Lambda` / `本地函数` 都是闭包,而闭包会生成一个引用类型的类)
> 以前常有一个疑问,我们常常说值类型在栈中,引用类型在堆中,那**放在引用类型中的值类型成员,内存在哪?(在堆中,但必须要拷到栈上使用)**
>
> 加入了 `ref struct` ,就再也没这个问题了。
## 15. 请简述 `ref return` 的使用方法
这也是个类似的问题, `C#` 一直以来就有 `值类型` ,我们常常类比 `C++` 的类型系统(只有值类型),它天生有性能好处,但 `C#` 之前**很容易产生没必要的复制**——导致 `C#` 并没有很好地享受 `值类型` 这一优点。
因此 `C# 7.0` 引入了 `ref return` ,然后又在 `C# 7.3` 引入了 `ref` 参数可被赋值。
使用示例:
``` csharp
Span 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 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 span, int value)
{
for (int i = 0; i < span.Length; ++i)
{
if (span[i] == value)
return span[i];
}
return span[0];
}
```
注意事项:
01. 参数可以用 `Span` 或者 `ref T`
02. 返回的时候使用 `return ref val`
03. 注意返回值需要加 `ref`
04. 在赋值时,等号两边的变量,**都**需要加 `ref` 关键字( `ref int v1 = ref v2` )
> 其实这个 `ref` 就是 `C/C++` 中的指针一样。
## 16. 请利用 `foreach` 和 `ref` 为一个数组中的每个元素加 `1`
``` csharp
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` 。
## 17. 请简述 `ref` 、 `out` 和 `in` 在用作函数参数修饰符时的区别
* `ref` 参数可同时用于输入或输出(变量使用前必须初始化);
* `out` 参数只用于输出(使用前无需初始化);
* `in` 参数只用于输入,它按引用传递,它能确保在使用过程中不被修改(变量使用前必须初始化);
可以用一个表格来比较它们的区别:
| 修饰符/区别 | `ref` | `out` | `in` | 无 |
| ----------- | ----- | ----- | ---- | --- |
| 是否复制 | ❌ | ❌ | ❌ | ✔ |
| 能修改 | ✔ | ✔ | ❌ | ❌ |
| 输入 | ✔ | ❌ | ✔ | ✔ |
| 输出 | ✔ | ✔ | ❌ | ❌ |
| 需初始化 | ✔ | ❌ | ✔ | ✔ |
> 其实`in`就相当于`C++`中的`const T&`,我多年前就希望`C#`加入这个功能了。
## 18. 请简述非 `sealed` 类的 `IDisposable` 实现方法
正常`IDisposable`实现只有一个方法即可:
```csharp
void Dispose()
{
// free managed resources...
// free unmanaged resources...
}
```
但它的缺点是必须手动调用`Dispose()`或使用`using`方法,如果忘记调用了,系统的垃圾回收器不会清理,这样就会存在资源浪费,如果调用多次,可能会存在问题,因此需要`Dispose`模式。
`Dispose`模式需要关心`C#`的终结器函数(有人称为析构函数,但我不推荐叫这个名字,因为它并不和`constructor`构造函数对应),其最终版应该如下所示:
```csharp
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`可以不需要。
在子类继承于这类、且有更多不同的资源需要管理时,实现方法如下:
```csharp
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`,因此它也能和`事件`一样,可以指定多个响应:
```csharp
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`内部是什么数据结构?
4. `Dictionary`内部是什么数据结构?
5. `internal`与`protected`有啥区别?
6. `string`/`StringBuilder`有啥区别?
7. 说出常用的`Http`状态码和使用场景;
8. 使用`Entity Framework`有哪些提高性能的技巧?
9. `jwt`(json web token)是什么,由哪些部分组成?
10. 计算`DateTime`类型需占用多少字节(需计算过程)
喜欢的朋友请关注我的微信公众号:【DotNet骚操作】
![DotNet骚操作](https://img2018.cnblogs.com/blog/233608/201908/233608-20190825165420518-990227633.jpg)
相关文章推荐
- C# 面试题解析-请遍历页面上所有的TextBox控件并给它赋值为string.Empty
- 解析关于实例化顺序的C#面试题
- C# 面试题解析-请遍历页面上所有的TextBox控件并给它赋值为string.Empty
- C# 面试题解析-请遍历页面上所有的TextBox控件并给它赋值为string.Empty
- 解析关于实例化顺序的C#面试题
- C# 面试题解析-请遍历页面上所有的TextBox控件并给它赋值为string.Empty
- C#事件解析(转)
- 一道关于实例化顺序的C#面试题
- 全面解析C#中参数传递
- C# 解析json Newtonsoft.Json
- java面试题及答案(基础题122道,代码题19道)
- [C#]Bencode编码算法/torrent文件解析
- 软帝出品2019阿里面试题大全(含答案解析)
- C#使用SOAP获取webservice实例解析
- C#实现WebSocket协议客户端和服务器websocket sharp组件实例解析
- [C#基础知识系列]全面解析C#中静态与非静态
- C# 解析JSON格式数据
- C++, Java和C#的编译过程解析
- C#面试题集锦(你值得拥有!)
- 谷歌面试题f(n)=n解析