服务器之家：专注于VPS、云服务器配置技术及软件下载分享
分类导航

PHP教程|ASP.NET教程|Java教程|ASP教程|编程技术|正则表达式|C/C++|IOS|C#|Swift|Android|VB|R语言|JavaScript|易语言|vb.net|

服务器之家 - 编程语言 - C# - C#中的9个“黑魔法”

C#中的9个“黑魔法”

2022-08-30 11:56.NET骚操作 C#

这篇文章主要介绍了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方法，可以用如下的“骚操作”，实现“移花接木”的效果：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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具体规范说明：https://github.com/dotnet/csharplang/blob/master/spec/expressions.md

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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
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一起发布，是有远见的“黑魔法”。

如以下代码：

?
1
Expression<Func<int>> g3 = () => 3;

会被编译器翻译为：

?
1
2
3
Expression<Func<int>> g3 = Expression.Lambda<Func<int>>(
 Expression.Constant(3, typeof(int)),
 Array.Empty<ParameterExpression>());

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

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

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

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

?
1
2
FormattableString x1 = $"Hello {42}";
string x2 = $"Hello {42}";

编译器生成结果如下：

?
1
2
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>的行为，会比较简单：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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()方法即可：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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异步循环：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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()方法，不需要继承任何接口：

?
1
2
3
4
5
6
7
8
9
10
11
12
void S1Demo()
{
 using S1 s1 = new S1();
}
 
ref struct S1
{
 public void Dispose()
 {
  Console.WriteLine("正常释放");
 }
}

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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
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值）。

示例代码如下：

?
1
2
3
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>完全一样，跳过了编译失败的代码）：

?
1
2
3
4
5
6
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等复杂操作的，现在非常简单。

?
1
2
3
string url = "https://www.super-cool.com/product/7705a33a-4d2c-455d-a42c-c95e6ac8ee99/summary";
string productId = url[35..url.LastIndexOf("/")];
Console.WriteLine(productId);

生成代码如下：

?
1
2
3
4
5
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了。

但数组又不同：

?
1
2
var range = new[] { 1, 2, 3, 4, 5 }[1..3];
Console.WriteLine(string.Join(", ", range)); // 2, 3

生成代码如下：

?
1
2
3
4
5
6
7
8
9
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：

?
1
2
3
4
5
6
7
8
9
10
11
12
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;
 }
}

生成代码如下：

?
1
2
3
4
5
6
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# 黑魔法内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！

原文链接：https://www.cnblogs.com/sdflysha/p/20200331-black-magic-in-csharp.html

  • C#
  • 黑魔法

    • 延伸 · 阅读

    精彩推荐
    • C#C# 利用IRawPixels接口遍历栅格数据

      C# 利用IRawPixels接口遍历栅格数据

      本文主要介绍了利用IRawPixels接口遍历栅格数据。具有很好的参考价值，下面跟着小编一起来看下吧...

      杰桀9062021-12-23
    • C#C#中RSA加密与解密的实例详解

      C#中RSA加密与解密的实例详解

      这篇文章主要介绍了C#中RSA加密与解密的实例代码，代码简单易懂，非常不错，具有一定的参考借鉴价值,需要的朋友可以参考下...

      在代码的世界里游走6562022-08-03
    • C#C#中结构体定义并转换字节数组详解

      C#中结构体定义并转换字节数组详解

      在写C#TCP通信程序时,发送数据时,只能发送byte数组,处理起来比较麻烦不说,如果是和VC6.0等写的程序通信的话,很多的都是传送结构体,在VC6.0中可以很方便的把...

      dafanjoy4502022-02-10
    • C#C#调用Win32的API函数--User32.dll

      C#调用Win32的API函数--User32.dll

      这篇文章主要介绍了C#调用Win32_的API函数--User32.dll，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下...

      Kevin Gao9342022-08-16
    • C#c#禁止通过拖动,双击标题栏改变窗体大小的方法

      c#禁止通过拖动,双击标题栏改变窗体大小的方法

      今天小编就为大家分享一篇c#禁止通过拖动,双击标题栏改变窗体大小的方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧...

      奔跑的QQEE3432022-03-06
    • C#C#交错数组知识点分析

      C#交错数组知识点分析

      在本篇文章里小编给大家整理的是关于C#交错数组知识点分析，需要的朋友们参考下。...

      ONEYF8362022-08-10
    • C#C#排序算法之归并排序

      C#排序算法之归并排序

      这篇文章主要为大家详细介绍了C#排序算法之归并排序，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下...

      mlovelcottage8372022-08-20
    • C#C#利用原图和水印图的重叠简单实现水印的方法

      C#利用原图和水印图的重叠简单实现水印的方法

      这篇文章主要介绍了C#利用原图和水印图的重叠简单实现水印的方法,实例演示了完整的水印操作类实现方法,需要的朋友可以参考下...

      且行且思6152021-11-18
    最近更新
    编辑推荐
    阅读排行
    热门标签
    TensorFlow.NET 　 osg 　 刷新桌面 　 nancy 　 TaskManager 　 网站授权 　 下拉式 　 DirectoryEntry 　 C#编程 　 网站功能 　 通知窗口 　 相互关系 　 语句顺序 　 编程错误 　 悬浮框 　 Dispose 　 滚动新闻 　 HttpPost 　 静态构造函数 　 焦点 　 类型派生 　 深度拷贝 　 小写转大写金额 　 任务并行库 　 众数 　 更新数据库 　 统计字数 　 二乘法 　 IComparer 　 DataBinding 　
    © 2019-2022 服务器之家(www.tuohang.net) 版权所有关于我们联系我们版权申明网站地图