C#中的9个“黑魔法”

我们知道c#是非常先进的语言，因为是它很有远见的“语法糖”。这些“语法糖”有时过于好用，导致有人觉得它是c#编译器写死的东西，没有道理可讲的——有点像“黑魔法”。

那么我们可以看看c#这些高级语言功能，是编译器写死的东西（“黑魔法”），还是可以扩展（骚操作）的“鸭子类型”。

我先列一个目录，大家可以对着这个目录试着下判断，说说是“黑魔法”（编译器写死），还是“鸭子类型”（可以自定义“骚操作”）：

1. linq操作，与ienumerable<t>类型；
2. async/await，与task/valuetask类型；
3. 表达式树，与expression<t>类型；
4. 插值字符串，与formattablestring类型；
5. yield return，与ienumerable<t>类型；
6. foreach循环，与ienumerable<t>类型；
7. using关键字，与idisposable接口；
8. t?，与nullable<t>类型；
9. 任意类型的index/range泛型操作。

1. linq操作，与ienumerable<t>类型

不是“黑魔法”，是“鸭子类型”。

linq是c# 3.0发布的新功能，可以非常便利地操作数据。现在12年过去了，虽然有些功能有待增强，但相比其它语言还是方便许多。

如我上一篇博客提到，linq不一定要基于ienumerable<t>，只需定定义一个类型，实现所需要的linq表达式即可，linq的select关键字，会调用.select方法，可以用如下的“骚操作”，实现“移花接木”的效果：

void main()
{
 var query = 
  from i in new f()
  select 3;
  
 console.writeline(string.join(",", query)); // 0,1,2,3,4
}

class f
{
 public ienumerable<int> select<r>(func<int, r> t)
 {
  for (var i = 0; i < 5; ++i)
  {
   yield return i;
  }
 }
}

2. async/await，与task/valuetask类型

不是“黑魔法”，是“鸭子类型”。

async/await发布于c# 5.0，可以非常便利地做异步编程，其本质是状态机。

async/await的本质是会寻找类型下一个名字叫getawaiter()的接口，该接口必须返回一个继承于inotifycompletion或icriticalnotifycompletion的类，该类还需要实现getresult()方法和iscomplete属性。

• 先调用t.getawaiter()方法，取得等待器a；
• 调用a.iscompleted取得布尔类型b；
• 如果b=true，则立即执行a.getresult()，取得运行结果；
• 如果b=false，则看情况：
  

如果a没实现icriticalnotifycompletion，则执行(a as inotifycompletion).oncompleted(action)
如果a实现了icriticalnotifycompletion，则执行(a as icriticalnotifycompletion).oncompleted(action)
执行随后暂停，oncompleted完成后重新回到状态机；

有兴趣的可以访问github具体规范说明：

正常task.delay()是基于线程池计时器的，可以用如下“骚操作”，来实现一个单线程的taskex.delay()：

static action tick = null;

void main()
{
 start();
 while (true)
 {
  if (tick != null) tick();
  thread.sleep(1);
 }
}

async void start()
{
 console.writeline("执行开始");
 for (int i = 1; i <= 4; ++i)
 {
  console.writeline($"第{i}次，时间：{datetime.now.tostring("hh:mm:ss")} - 线程号：{thread.currentthread.managedthreadid}");
  await taskex.delay(1000);
 }
 console.writeline("执行完成");
}

class taskex
{
 public static mydelay delay(int ms) => new mydelay(ms);
}

class mydelay : inotifycompletion
{
 private readonly double _start;
 private readonly int _ms;
 
 public mydelay(int ms)
 {
  _start = util.elapsedtime.totalmilliseconds;
  _ms = ms;
 }
 
 internal mydelay getawaiter() => this;
 
 public void oncompleted(action continuation)
 {
  tick += check;
  
  void check()
  {
   if (util.elapsedtime.totalmilliseconds - _start > _ms)
   {
    continuation();
    tick -= check;
   }
  }
 }

 public void getresult() {}
 
 public bool iscompleted => false;
}

运行效果如下：

执行开始
第1次，时间：17:38:03 - 线程号：1
第2次，时间：17:38:04 - 线程号：1
第3次，时间：17:38:05 - 线程号：1
第4次，时间：17:38:06 - 线程号：1
执行完成

注意不需要非得使用taskcompletionsource<t>才能创建定定义的async/await。

3. 表达式树，与expression<t>类型

是“黑魔法”，没有“操作空间”，只有当类型是expression<t>时，才会创建为表达式树。

表达式树是c# 3.0随着linq一起发布，是有远见的“黑魔法”。

如以下代码：

expression<func<int>> g3 = () => 3;

会被编译器翻译为：

expression<func<int>> g3 = expression.lambda<func<int>>(
 expression.constant(3, typeof(int)), 
 array.empty<parameterexpression>());

4. 插值字符串，与formattablestring类型

是“黑魔法”，没有“操作空间”。

插值字符串发布于c# 6.0，在此之前许多语言都提供了类似的功能。

只有当类型是formattablestring，才会产生不一样的编译结果，如以下代码：

formattablestring x1 = $"hello {42}";
string x2 = $"hello {42}";

编译器生成结果如下：

formattablestring x1 = formattablestringfactory.create("hello {0}", 42);
string x2 = string.format("hello {0}", 42);

注意其本质是调用了formattablestringfactory.create来创建一个类型。

5. yield return，与ienumerable<t>类型；

是“黑魔法”，但有补充说明。

yield return除了用于ienumerable<t>以外，还可以用于ienumerable、ienumerator<t>、ienumerator。

因此，如果想用c#来模拟c++/java的generator<t>的行为，会比较简单：

var seq = getnumbers();
seq.movenext();
console.writeline(seq.current); // 0
seq.movenext();
console.writeline(seq.current); // 1
seq.movenext();
console.writeline(seq.current); // 2
seq.movenext();
console.writeline(seq.current); // 3
seq.movenext();
console.writeline(seq.current); // 4

ienumerator<int> getnumbers()
{
 for (var i = 0; i < 5; ++i)
  yield return i;
}

yield return——“迭代器”发布于c# 2.0。

6. foreach循环，与ienumerable<t>类型

是“鸭子类型”，有“操作空间”。

foreach不一定非要配合使用ienumerable<t>类型，只要对象存在getenumerator()方法即可：

void main()
{
 foreach (var i in new f())
 {
  console.write(i + ", "); // 1, 2, 3, 4, 5, 
 }
}

class f
{
 public ienumerator<int> getenumerator()
 {
  for (var i = 0; i < 5; ++i)
  {
   yield return i;
  }
 }
}

另外，如果对象实现了getasyncenumerator()，甚至也可以一样使用await foreach异步循环：

async task main()
{
 await foreach (var i in new f())
 {
  console.write(i + ", "); // 1, 2, 3, 4, 5, 
 }
}

class f
{
 public async iasyncenumerator<int> getasyncenumerator()
 {
  for (var i = 0; i < 5; ++i)
  {
   await task.delay(1);
   yield return i;
  }
 }
}

await foreach是c# 8.0随着异步流一起发布的，具体可见我之前写的《代码演示c#各版本新功能》。

7. using关键字，与idisposable接口

是，也不是。

引用类型和正常的值类型用using关键字，必须基于idisposable接口。

但ref struct和iasyncdisposable就是另一个故事了，由于ref struct不允许随便移动，而引用类型——托管堆，会允许内存移动，所以ref struct不允许和引用类型产生任何关系，这个关系就包含继承接口——因为接口也是引用类型。

但释放资源的需求依然存在，怎么办，“鸭子类型”来了，可以手写一个dispose()方法，不需要继承任何接口：

void s1demo()
{
 using s1 s1 = new s1();
}

ref struct s1
{
 public void dispose()
 {
  console.writeline("正常释放");
 }
}

同样的道理，如果用iasyncdisposable接口：

async task s2demo()
{
 await using s2 s2 = new s2();
}

struct s2 : iasyncdisposable
{
 public async valuetask disposeasync()
 {
  await task.delay(1);
  console.writeline("async释放");
 }
}

8. t?，与nullable<t>类型

是“黑魔法”，只有nullable<t>才能接受t?，nullable<t>作为一个值类型，它还能直接接受null值（正常值类型不允许接受null值）。

示例代码如下：

int? t1 = null;
nullable<int> t2 = null;
int t3 = null; // error cs0037: cannot convert null to 'int' because it is a non-nullable value type

生成代码如下（int?与nullable<int>完全一样，跳过了编译失败的代码）：

il_0000: nop
il_0001: ldloca.s 0
il_0003: initobj valuetype [system.runtime]system.nullable`1<int32>
il_0009: ldloca.s 1
il_000b: initobj valuetype [system.runtime]system.nullable`1<int32>
il_0011: ret

9. 任意类型的index/range泛型操作

有“黑魔法”，也有“鸭子类型”——存在操作空间。

index/range发布于c# 8.0，可以像python那样方便地操作索引位置、取出对应值。以前需要调用substring等复杂操作的，现在非常简单。

string url = "https://www.super-cool.com/product/7705a33a-4d2c-455d-a42c-c95e6ac8ee99/summary";
string productid = url[35..url.lastindexof("/")];
console.writeline(productid);

生成代码如下：

string url = "https://www.super-cool.com/product/7705a33a-4d2c-455d-a42c-c95e6ac8ee99/amd-r7-3800x";
int num = 35;
int length = url.lastindexof("/") - num;
string productid = url.substring(num, length);
console.writeline(productid); // 7705a33a-4d2c-455d-a42c-c95e6ac8ee99

可见，c#编译器忽略了index/range，直接翻译为调用substring了。

但数组又不同：

var range = new[] { 1, 2, 3, 4, 5 }[1..3];
console.writeline(string.join(", ", range)); // 2, 3

生成代码如下：

int[] range = runtimehelpers.getsubarray<int>(new int[5]
{
 1,
 2,
 3,
 4,
 5
}, new range(1, 3));
console.writeline(string.join<int>(", ", range));

可见它确实创建了range类型，然后调用了runtimehelpers.getsubarray<int>，完全属于“黑魔法”。

但它同时也是“鸭子”类型，只要代码中实现了length属性和slice(int, int)方法，即可调用index/range：

var range2 = new f()[2..];
console.writeline(range2); // 2 -> -2

class f
{
 public int length { get; set; }
 public ienumerable<int> slice(int start, int end)
 {
  yield return start;
  yield return end;
 }
}

生成代码如下：

f f = new f();
int length2 = f.length;
length = 2;
num = length2 - length;
string range2 = f.slice(length, num);
console.writeline(range2);

总结

如上所见，c#的“黑魔法”确实挺多，但“鸭子类型”也有很多，“骚操作”的“操作空间”很大。

据传c# 9.0将添加“鸭子类型”的元祖——type classes，到时候“操作空间”肯定比现在更大，非常期待！

到此这篇关于c#中的9个“黑魔法”的文章就介绍到这了,更多相关c# 黑魔法内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！