欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

解答“60k”大佬的19道C#面试题(下)

程序员文章站 2022-06-25 08:02:23
在上篇中,我解析了前 10 道题目,本篇我将尝试解析后面剩下的所有题目。姐妹篇:解析“60k”大佬的19道c#面试题(上)这些题目确实不怎么经常使用,因此在后文中,我会提一组我的私房经典“6k面试题”...

在上篇中,我解析了前 10 道题目,本篇我将尝试解析后面剩下的所有题目。

姐妹篇:解析“60k”大佬的19道c#面试题(上)

这些题目确实不怎么经常使用,因此在后文中,我会提一组我的私房经典“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类型需占用多少字节(需计算过程)

以上就是解答“60k”大佬的19道c#面试题(下)的详细内容,更多关于c#面试题的资料请关注其它相关文章!

相关标签: c# 面试题