解析“60k”大佬的19道C#面试题（下）
<h1 id="解析60k大佬的19道c面试题下">解析“60k”大佬的19道C#面试题（下）</h1><p>在上篇中，我解析了前 <code>10</code> 道题目，本篇我将尝试解析后面剩下的所有题目。</p>
<blockquote>
<p>姐妹篇：解析“60k”大佬的19道C#面试题（上）</p>
</blockquote>
<p>这些题目确实不怎么经常使用，因此在后文中，我会提一组我的私房经典“<code>6k</code>面试题”，供大家轻松一刻。</p>
<h2 id="先略看题目">先略看题目：</h2>
<ol start="11">
<li>简述 <code>LINQ</code> 的 <code>lazy computation</code> 机制</li>
<li>利用 <code>SelectMany</code> 实现两个数组中元素做笛卡尔集，然后一一相加</li>
<li>请为三元函数实现柯里化</li>
<li>请简述 <code>ref struct</code> 的作用</li>
<li>请简述 <code>ref return</code> 的使用方法</li>
<li>请利用 <code>foreach</code> 和 <code>ref</code> 为一个数组中的每个元素加 <code>1</code></li>
<li>请简述 <code>ref</code> 、 <code>out</code> 和 <code>in</code> 在用作函数参数修饰符时的区别</li>
<li>请简述非 <code>sealed</code> 类的 <code>IDisposable</code> 实现方法</li>
<li><code>delegate</code> 和 <code>event</code> 本质是什么？请简述他们的实现机制</li>
</ol>
<h1 id="解析">解析：</h1>
<h2 id="11-简述-linq-的-lazy-computation-机制">11. 简述 <code>LINQ</code> 的 <code>lazy computation</code> 机制</h2>
<p><code>Lazy computation</code> 是指延迟计算，它可能体现在<strong>解析阶段</strong>的<strong>表达式树</strong>和<strong>求值阶段</strong>的<strong>状态机</strong>两方面。</p>
<p>首先是<strong>解析阶段</strong>的<strong>表达式树</strong>， <code>C#</code> 编译器在编译时，它会将这些语句以表达式树的形式保存起来，在求值时， <code>C#</code> 编译器会将所有的 <code>表达式树</code> 翻译成求值方法（如在数据库中执行 <code>SQL</code> 语句）。</p>
<p>其次是<strong>求值阶段</strong>的<strong>状态机</strong>， <code>LINQ to Objects</code> 可以使用像 <code>IEnumemrable<T></code> 接口，它本身不一定保存数据，<strong>只有在求值时</strong>，它返回一个迭代器—— <code>IEnumerator<T></code> ，它才会根据 <code>MoveNext()</code> / <code>Value</code> 来求值。</p>
<p>这两种机制可以确保 <code>LINQ</code> 是可以延迟计算的。</p>
<h2 id="12-利用-selectmany-实现两个数组中元素做笛卡尔集然后一一相加">12. 利用 <code>SelectMany</code> 实现两个数组中元素做笛卡尔集，然后一一相加</h2>
<pre><code class="language-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();
</code></pre>
<p>解析与说明：大多数人可能只了解 <code>SelectMany</code> 做一转多的场景（两参数重载，类似于 <code>flatMap</code> ），但它还提供了这个三参数的重载，可以允许你做多对多——笛卡尔集。因此这些代码实际上可以用如下 <code>LINQ</code> 表示：</p>
<pre><code class="language-csharp">from v1 in a1
from v2 in a2
select $"{v1}+{v2}={v1 + v2}"
</code></pre>
<p>执行效果完全一样。</p>
<h2 id="13-请为三元函数实现柯里化">13. 请为三元函数实现柯里化</h2>
<p>解析：柯里化是指将 <code>f(x, y)</code> 转换为 <code>f(x)(y)</code> 的过程，三元和二元同理：</p>
<pre><code class="language-csharp">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
</code></pre>
<p>通过实现一个泛型方法，实现<strong>通用的</strong>三元函数柯里化：</p>
<pre><code class="language-csharp">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
</code></pre>
<blockquote>
<p>现在了解为啥 <code>F#</code> 签名也能不用写参数了吧，因为参数确实太长了😂</p>
</blockquote>
<h2 id="14-请简述-ref-struct-的作用">14. 请简述 <code>ref struct</code> 的作用</h2>
<p><code>ref struct</code> 是 <code>C# 7.2</code> 发布的新功能，主要是为了配合 <code>Span<T></code> ，防止 <code>Span<T></code> 被误用。</p>
<p>为什么会被误用呢？因为 <code>Span<T></code> 表示一段连续、固定的内存，可供托管代码和非托管代码访问（不需要额外的 <code>fixed</code> ）这些内存可以从 <code>stackalloc</code> 中来，也能从 <code>fixed</code> 中获取托管的位置，也能通过 <code>Marshal.AllocHGlobal()</code> 等方式直接分配。这些内存<strong>应该</strong>是固定的、不能被托管堆移动。但之前的代码并不能很好地确保这一点，因此添加了 <code>ref struct</code> 来确保。</p>
<p>基于<strong>不被托管堆管理</strong>这一点，我们可以总结出以下结论：</p>
<ol>
<li>不能对 <code>ref struct</code> 装箱（因为装箱就变成引用类型了）——包括不能转换为 <code>object</code> 、 <code>dynamic</code></li>
<li>禁止实现任何接口（因为接口是引用类型）</li>
<li>禁止在 <code>class</code> 和 <code>struct</code> 中使用 <code>ref struct</code> 做成员或自动属性（因为禁止随意移动，因此不能放到托管堆中。而引用类型、 <code>struct</code> 成员和自动属性都可能是在托管内存中）</li>
<li>禁止在迭代器（ <code>yield</code> ）中使用 <code>ref struct</code> （因为迭代器本质是状态机，状态机是一个引用类型）</li>
<li>在 <code>Lambda</code> 或 <code>本地函数</code> 中使用（因为 <code>Lambda</code> / <code>本地函数</code> 都是闭包，而闭包会生成一个引用类型的类）</li>
</ol>
<blockquote>
<p>以前常有一个疑问，我们常常说值类型在栈中，引用类型在堆中，那<strong>放在引用类型中的值类型成员，内存在哪？（在堆中，但必须要拷到栈上使用）</strong></p>
<p>加入了 <code>ref struct</code> ，就再也没这个问题了。</p>
</blockquote>
<h2 id="15-请简述-ref-return-的使用方法">15. 请简述 <code>ref return</code> 的使用方法</h2>
<p>这也是个类似的问题， <code>C#</code> 一直以来就有 <code>值类型</code> ，我们常常类比 <code>C++</code> 的类型系统（只有值类型），它天生有性能好处，但 <code>C#</code> 之前<strong>很容易产生没必要的复制</strong>——导致 <code>C#</code> 并没有很好地享受 <code>值类型</code> 这一优点。</p>
<p>因此 <code>C# 7.0</code> 引入了 <code>ref return</code> ，然后又在 <code>C# 7.3</code> 引入了 <code>ref</code> 参数可被赋值。</p>
<p>使用示例：</p>
<pre><code class="language-csharp">Span<int> values = stackalloc int;
values = 10010;
int v1 = SearchValue(values, 10010);
v1 = 10086;
Console.WriteLine(values); // 10010
ref int v = ref SearchRefValue(values, 10010);
v = 10086;
Console.WriteLine(values); // 10086;
ref int SearchRefValue(Span<int> span, int value)
{
for (int i = 0; i < span.Length; ++i)
{
if (span == value)
return ref span;
}
return ref span;
}
int SearchValue(Span<int> span, int value)
{
for (int i = 0; i < span.Length; ++i)
{
if (span == value)
return span;
}
return span;
}
</code></pre>
<p>注意事项：</p>
<ol>
<li>参数可以用 <code>Span<T></code> 或者 <code>ref T</code></li>
<li>返回的时候使用 <code>return ref val</code></li>
<li>注意返回值需要加 <code>ref</code></li>
<li>在赋值时，等号两边的变量，<strong>都</strong>需要加 <code>ref</code> 关键字（ <code>ref int v1 = ref v2</code> ）</li>
</ol>
<blockquote>
<p>其实这个 <code>ref</code> 就是 <code>C/C++</code> 中的指针一样。</p>
</blockquote>
<h2 id="16-请利用-foreach-和-ref-为一个数组中的每个元素加-1">16. 请利用 <code>foreach</code> 和 <code>ref</code> 为一个数组中的每个元素加 <code>1</code></h2>
<pre><code class="language-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
</code></pre>
<p>注意 <code>foreach</code> 不能用 <code>var</code> ，也不能直接用 <code>int</code> ，需要 <code>ref int</code> ，注意 <code>arr</code> 要转换为 <code>Span<T></code> 。</p>
<h2 id="17-请简述-ref--out-和-in-在用作函数参数修饰符时的区别">17. 请简述 <code>ref</code> 、 <code>out</code> 和 <code>in</code> 在用作函数参数修饰符时的区别</h2>
<ul>
<li><code>ref</code> 参数可同时用于输入或输出（变量使用前必须初始化）；</li>
<li><code>out</code> 参数只用于输出（使用前无需初始化）；</li>
<li><code>in</code> 参数只用于输入，它按引用传递，它能确保在使用过程中不被修改（变量使用前必须初始化）；</li>
</ul>
<p>可以用一个表格来比较它们的区别：</p>
<table>
<thead>
<tr>
<th>修饰符/区别</th>
<th><code>ref</code></th>
<th><code>out</code></th>
<th><code>in</code></th>
<th>无</th>
</tr>
</thead>
<tbody>
<tr>
<td>是否复制</td>
<td>❌</td>
<td>❌</td>
<td>❌</td>
<td>✔</td>
</tr>
<tr>
<td>能修改</td>
<td>✔</td>
<td>✔</td>
<td>❌</td>
<td>❌</td>
</tr>
<tr>
<td>输入</td>
<td>✔</td>
<td>❌</td>
<td>✔</td>
<td>✔</td>
</tr>
<tr>
<td>输出</td>
<td>✔</td>
<td>✔</td>
<td>❌</td>
<td>❌</td>
</tr>
<tr>
<td>需初始化</td>
<td>✔</td>
<td>❌</td>
<td>✔</td>
<td>✔</td>
</tr>
</tbody>
</table>
<blockquote>
<p>其实<code>in</code>就相当于<code>C++</code>中的<code>const T&</code>，我多年前就希望<code>C#</code>加入这个功能了。</p>
</blockquote>
<h2 id="18-请简述非-sealed-类的-idisposable-实现方法">18. 请简述非 <code>sealed</code> 类的 <code>IDisposable</code> 实现方法</h2>
<p>正常<code>IDisposable</code>实现只有一个方法即可：</p>
<pre><code class="language-csharp">void Dispose()
{
// free managed resources...
// free unmanaged resources...
}
</code></pre>
<p>但它的缺点是必须手动调用<code>Dispose()</code>或使用<code>using</code>方法，如果忘记调用了，系统的垃圾回收器不会清理，这样就会存在资源浪费，如果调用多次，可能会存在问题，因此需要<code>Dispose</code>模式。</p>
<p><code>Dispose</code>模式需要关心<code>C#</code>的终结器函数（有人称为析构函数，但我不推荐叫这个名字，因为它并不和<code>constructor</code>构造函数对应），其最终版应该如下所示：</p>
<pre><code class="language-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);
}
}
</code></pre>
<p>它有如下要注意的点：</p>
<ol>
<li>引入<code>disposed</code>变量用于判断是否已经回收过，如果回收过则不再回收；</li>
<li>使用<code>protected virtual</code>来确保子类的正确回收，注意不是在<code>Dispose</code>方法上加；</li>
<li>使用<code>disposing</code>来判断是<code>.NET</code>的终结器回收还是手动调用<code>Dispose</code>回收，终结器回收不再需要关心释放托管内存；</li>
<li>使用<code>GC.SuppressFinalize(this)</code>来避免多次调用<code>Dispose</code>；</li>
</ol>
<p>至于本题为什么要关心非<code>sealed</code>类，因为<code>sealed</code>类不用关心继承，因此<code>protected virtual</code>可以不需要。</p>
<p>在子类继承于这类、且有更多不同的资源需要管理时，实现方法如下：</p>
<pre><code class="language-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);
}
}
</code></pre>
<p>注意：</p>
<ol>
<li>继承类也需要定义一个新的、不同的<code>disposed</code>值，不能和老的<code>disposed</code>共用；</li>
<li>其它判断、释放顺序和基类完全一样；</li>
<li>在<code>继承类</code>释放完后，调用<code>base.Dispose(disposing)</code>来释放<code>父类</code>。</li>
</ol>
<h2 id="19-delegate-和-event-本质是什么请简述他们的实现机制">19. <code>delegate</code> 和 <code>event</code> 本质是什么？请简述他们的实现机制</h2>
<p><code>delegate</code>和<code>event</code>本质<strong>都</strong>是多播委托（<code>MultipleDelegate</code>），它用<strong>数组</strong>的形式包装了多个<code>Delegate</code>，<code>Delegate</code>类和<code>C</code>中函数指针有点像，但它们都会保留类型、都保留<code>this</code>，因此都是类型安全的。</p>
<p><code>delegate</code>（委托）在定义时，会自动创建一个继承于<code>MultipleDelegate</code>的类型，其构造函数为<code>ctor(object o, IntPtr f)</code>，第一个参数是<code>this</code>值，第二个参数是函数指针，也就是说在委托赋值时，自动创建了一个<code>MultipleDelegate</code>的子类。</p>
<p>委托在调用<code>()</code>时，编译器会翻译为<code>.Invoke()</code>。</p>
<p>注意：<code>delegate</code>本身创建的类，<strong>也</strong>是继承于<code>MultipleDelegate</code>而非<code>Delegate</code>，因此它也能和<code>事件</code>一样，可以指定多个响应：</p>
<pre><code class="language-csharp">string text = "Hello World";
Action v = () => Console.WriteLine(text);
v += () => Console.WriteLine(text.Length);
v();
// Hello World
// 11
</code></pre>
<p>注意，<code>+=</code>运算符会被编译器会翻译为<code>Delegate.Combine()</code>，同样地<code>-=</code>运算符会翻译为<code>Delegate.Remove()</code>。</p>
<p><code>事件</code>是一种由编译器生成的特殊多播委托，其编译器生成的默认（可自定义）代码，与委托生成的<code>MultipleDelegate</code>相比，<code>事件</code>确保了<code>+=</code>和<code>-=</code>运算符的线程安全，还确保了<code>null</code>的时候可以被赋值（<strong>而已</strong>）。</p>
<h1 id="总结">总结</h1>
<p>这些技术平时可能比较冷门，全部能回答正确也并不意味着会有多有用，可能很难有机会用上。</p>
<p>但如果是在开发像 <code>ASP.NET Core</code> 那样的超高性能网络服务器、中间件，或者 <code>Unity 3D</code> 那样的高性能游戏引擎、或者做一些高性能实时 <code>ETL</code> 之类的，就能依靠这些知识，做出比肩甚至超过 <code>C</code> / <code>C++</code> 的性能，同时还能享受 <code>C#</code> / <code>.NET</code> 便利性的产品。</p>
<blockquote>
<p>群里有人戏称面试时出这些题的公司，要么是心太大，要么至少得开 <code>60k</code> ，因此本文取名为 <code>60k大佬</code> 。</p>
</blockquote>
<h2 id="轻松一刻我的私房net后端6k面试题">轻松一刻——我的私房.NET后端<code>6k</code>面试题：</h2>
<ol>
<li><code>.NET</code>的<code>int</code>占几字节？</li>
<li><code>.NET</code>的<code>值类型</code>和<code>引用类型</code>有什么区别？性能方面有何差异？</li>
<li><code>List<T></code>内部是什么数据结构？</li>
<li><code>Dictionary<K, V></code>内部是什么数据结构？</li>
<li><code>internal</code>与<code>protected</code>有啥区别？</li>
<li><code>string</code>/<code>StringBuilder</code>有啥区别？</li>
<li>说出常用的<code>Http</code>状态码和使用场景；</li>
<li>使用<code>Entity Framework</code>有哪些提高性能的技巧？</li>
<li><code>jwt</code>（json web token）是什么，由哪些部分组成？</li>
<li>计算<code>DateTime</code>类型需占用多少字节（需计算过程）</li>
</ol>
<p>喜欢的朋友请关注我的微信公众号：【DotNet骚操作】</p>
<p><img src="https://img2018.cnblogs.com/blog/233608/201908/233608-20190825165420518-990227633.jpg" alt="DotNet骚操作" loading="lazy"></p><br><br>
来源：https://www.cnblogs.com/sdcb/p/20200329-19-csharp-interview-question-from-60k-boss-2.html
頁:
[1]