你所不知道的 C# 中的细节

前言

有一个东西叫做鸭子类型,所谓鸭子类型就是,只要一个东西表现得像鸭子那么就能推出这玩意就是鸭子。

C# 里面其实也暗藏了很多类似鸭子类型的东西,但是很多开发者并不知道,因此也就没法好好利用这些东西,那么今天我细数一下这些藏在编译器中的细节。

不是只有 TaskValueTask 才能 await

在 C# 中编写异步代码的时候,我们经常会选择将异步代码包含在一个 Task 或者 ValueTask 中,这样调用者就能用 await 的方式实现异步调用。

西卡西,并不是只有 TaskValueTask 才能 awaitTaskValueTask 背后明明是由线程池参与调度的,可是为什么 C# 的 async/await 却被说成是 coroutine 呢?

因为你所 await 的东西不一定是 Task/ValueTask,在 C# 中只要你的类中包含 GetAwaiter() 方法和 bool IsCompleted 属性,并且 GetAwaiter() 返回的东西包含一个 GetResult() 方法、一个 bool IsCompleted 属性和实现了 INotifyCompletion,那么这个类的对象就是可以 await 的 。

因此在封装 I/O 操作的时候,我们可以自行实现一个 Awaiter,它基于底层的 epoll/IOCP 实现,这样当 await 的时候就不会创建出任何的线程,也不会出现任何的线程调度,而是直接让出控制权。而 OS 在完成 I/O 调用后通过 CompletionPort (Windows) 等通知用户态完成异步调用,此时恢复上下文继续执行剩余逻辑,这其实就是一个真正的 stackless coroutine

public class MyTask<T>
{
    public MyAwaiter<T> GetAwaiter()
    {
        return new MyAwaiter<T>();
    }
}

public class MyAwaiter<T> : INotifyCompletion
{
    public bool IsCompleted { get; private set; }
    public T GetResult()
    {
        throw new NotImplementedException();
    }
    public void OnCompleted(Action continuation)
    {
        throw new NotImplementedException();
    }
}

public class Program
{
    static async Task Main(string[] args)
    {
        var obj = new MyTask<int>();
        await obj;
    }
}

事实上,.NET Core 中的 I/O 相关的异步 API 也的确是这么做的,I/O 操作过程中是不会有任何线程分配等待结果的,都是 coroutine 操作:I/O 操作开始后直接让出控制权,直到 I/O 操作完毕。而之所以有的时候你发现 await 前后线程变了,那只是因为 Task 本身被调度了。

UWP 开发中所用的 IAsyncAction/IAsyncOperation<T> 则是来自底层的封装,和 Task 没有任何关系但是是可以 await 的,并且如果用 C++/WinRT 开发 UWP 的话,返回这些接口的方法也都是可以 co_await 的。

不是只有 IEnumerableIEnumerator 才能被 foreach

经常我们会写如下的代码:

foreach (var i in list)
{
    // ......
}

然后一问为什么可以 foreach,大多都会回复因为这个 list 实现了 IEnumerable 或者 IEnumerator

但是实际上,如果想要一个对象可被 foreach,只需要提供一个 GetEnumerator() 方法,并且 GetEnumerator() 返回的对象包含一个 bool MoveNext() 方法加一个 Current 属性即可。

class MyEnumerator<T>
{
    public T Current { get; private set; }
    public bool MoveNext()
    {
        throw new NotImplementedException();
    }
}
    
class MyEnumerable<T>
{
    public MyEnumerator<T> GetEnumerator()
    {
        throw new NotImplementedException();
    }
}

class Program
{
    public static void Main()
    {
        var x = new MyEnumerable<int>();
        foreach (var i in x)
        {
            // ......
        }
    }
}

不是只有 IAsyncEnumerableIAsyncEnumerator 才能被 await foreach

同上,但是这一次要求变了,GetEnumerator()MoveNext() 变为 GetAsyncEnumerator()MoveNextAsync()

其中 MoveNextAsync() 返回的东西应该是一个 Awaitable<bool>,至于这个 Awaitable 到底是什么,它可以是 Task/ValueTask,也可以是其他的或者你自己实现的。

class MyAsyncEnumerator<T>
{
    public T Current { get; private set; }
    public MyTask<bool> MoveNextAsync()
    {
        throw new NotImplementedException();
    }
}
    
class MyAsyncEnumerable<T>
{
    public MyAsyncEnumerator<T> GetAsyncEnumerator()
    {
        throw new NotImplementedException();
    }
}

class Program
{
    public static async Task Main()
    {
        var x = new MyAsyncEnumerable<int>();
        await foreach (var i in x)
        {
            // ......
        }
    }
}

ref struct 要怎么实现 IDisposable

众所周知 ref struct 因为必须在栈上且不能被装箱,所以不能实现接口,但是如果你的 ref struct 中有一个 void Dispose() 那么就可以用 using 语法实现对象的自动销毁。

ref struct MyDisposable
{
    public void Dispose() => throw new NotImplementedException();
}

class Program
{
    public static void Main()
    {
        using var y = new MyDisposable();
        // ......
    }
}

不是只有 Range 才能使用切片

C# 8 引入了 Ranges,允许切片操作,但是其实并不是必须提供一个接收 Range 类型参数的 indexer 才能使用该特性。

只要你的类可以被计数(拥有 LengthCount 属性),并且可以被切片(拥有一个 Slice(int,int) 方法),那么就可以用该特性。

class MyRange
{
    public int Count { get; private set; }
    public object Slice(int x,int y) => throw new NotImplementedException();
}

class Program
{
    public static void Main()
    {
        var x = new MyRange();
        var y = x[1..];
    }
}

不是只有 Index 才能使用索引

C# 8 引入了 Indexes 用于索引,例如使用 ^1 索引倒数第一个元素,但是其实并不是必须提供一个接收 Index 类型参数的 indexer 才能使用该特性。

只要你的类可以被计数(拥有 LengthCount 属性),并且可以被索引(拥有一个接收 int 参数的索引器),那么就可以用该特性。

class MyIndex
{
    public int Count { get; private set; }
    public object this[int index]
    {
        get => throw new NotImplementedException();
    }
}

class Program
{
    public static void Main()
    {
        var x = new MyIndex();
        var y = x[^1];
    }
}

给类型实现解构

如何给一个类型实现解构呢?其实只需要写一个名字为 Deconstruct() 的方法,并且参数都是 out 的即可。

class MyDeconstruct
{
    private int A => 1;
    private int B => 2;
    public void Deconstruct(out int a,out int b)
    {
        a = A;
        b = B;
    }
}

class Program
{
    public static void Main()
    {
        var x = new MyDeconstruct();
        var (o,u) = x;
    }
}

不是只有实现了 IEnumerable 才能用 LINQ

LINQ 是 C# 中常用的一种集成查询语言,允许你这样写代码:

from c in list where c.Id > 5 select c;

但是上述代码中的 list 的类型不一定非得实现 IEnumerable,事实上,只要有对应名字的扩展方法就可以了,比如有了叫做 Select 的方法就能用 select,有了叫做 Where 的方法就能用 where

class Just<T> : Maybe<T>
{
    private readonly T value;
    public Just(T value) { this.value = value; }

    public override Maybe<U> Select<U>(Func<T,Maybe<U>> f) => f(value);
    public override string ToString() => $"Just {value}";
}

class Nothing<T> : Maybe<T>
{
    public override Maybe<U> Select<U>(Func<T,Maybe<U>> _) => new Nothing<U>();
    public override string ToString() => "Nothing";
}

abstract class Maybe<T>
{
    public abstract Maybe<U> Select<U>(Func<T,Maybe<U>> f);

    public Maybe<V> SelectMany<U,V>(Func<T,Maybe<U>> k,Func<T,U,V> s)
        => Select(x => k(x).Select(y => new Just<V>(s(x,y))));

    public Maybe<U> Where(Func<Maybe<T>,bool> f) => f(this) ? this : new Nothing<T>();
}

class Program
{
    public static void Main()
    {
        var x = new Just<int>(3);
        var y = new Just<int>(7);
        var z = new Nothing<int>();

        var u = from x0 in x from y0 in y select x0 + y0;
        var v = from x0 in x from z0 in z select x0 + z0;
        var just = from c in x where true select c;
        var nothing = from c in x where false select c;
    }
}

原文地址:https://www.cnblogs.com/hez2010

版权声明:本文内容由互联网用户自发贡献,该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 dio@foxmail.com 举报,一经查实,本站将立刻删除。

相关推荐


本文将从上往下,循序渐进的介绍一系列相关.NET的概念,先从类型系统开始讲起,我将通过跨语言操作这个例子来逐渐引入一系列.NET的相关概念,这主要包括:CLS、...
基于 .NET 的一个全新的、好用的 PHP SDK + Runtime: PeachPie 来啦!
.NET 异步工作原理介绍。
引子 .NET 6 开始初步引入 PGO。PGO 即 Profile Guided Optimization,通过收集运行时信息来指导 JIT 如何优化代码,相比以前没有 PGO 时可以做更多以前难以
前言 2021/4/8 .NET 6 Preview 3 发布,这个版本的改进大多来自于底层,一起来看看都有什么新特性和改进吧。 库改进 新增值类型作为字典值时更快的处理方法 .NET 6 Previ
前言 开头防杠:.NET 的基础库、语言、运行时团队从来都是相互独立各自更新的,.NET 6 在基础库、运行时上同样做了非常多的改进,不过本文仅仅介绍语言部分。 距离上次介绍 C# 10 的特性已经有
直接使用 CIL - .NET 上的汇编语言编写 .NET Standard 类库
前言 不知不觉中,.NET Framework 已经更新到 4.8,.NET Core 也更新到了 3.0 版本。那么 .NET 的未来怎么样呢? 计划 2019 年 Build 大会上,微软宣布下一
本文带你穿越到未来一起看看未来的 C# 到底长什么样子。
前言 TypedocConverter 是我先前因帮助维护 monaco-editor-uwp 但苦于 monaco editor 的 API 实在太多,手写 C# 的类型绑定十分不划算而发起的一个项
前言 在 2021 年 3 月 11 日, .NET 6 Preview 2 发布,这次的改进主要涉及到 MAUI、新的基础库和运行时、JIT 改进。 .NET 6 正式版将会在 2021 年 11
前言 命名空间已经在 .NET 中使用了多年,一直追溯到 .NET Framework 1.1。它在 .NET 实施本身的数百个位置中使用,并且直接被成千上万个应用程序使用。在所有这些方面,它也是 C
.NET 上的统一跨平台 UI 框架来啦
使用 F# 手写一个 Typedoc 转 C# 代码生成器,方便一切 C# 项目对 TypeScript 项目的封装。
LINQ + SelectMany = Monad!
C# 10 主要特性一览
C# 的编译期反射终于来啦!
前言 2021 年 2 月 17 日微软发布了 .NET 6 的 Preview 1 版本,那么来看看都有什么新特性和改进吧,由于内容太多了因此只介绍一些较为重点的项目。ASP.NET Core 6
前言 有一个东西叫做鸭子类型,所谓鸭子类型就是,只要一个东西表现得像鸭子那么就能推出这玩意就是鸭子。 C 里面其实也暗藏了很多类似鸭子类型的东西,但是很多开发者并不知道,因此也就没法好好利用这些东西,
经过五年半的持续维护,Senparc.Weixin SDK 逐步丰满和完善,在升级的过程中,我们为基础库(Senparc.Weixin.dll)加入了许多通用的功能,例如加密/解密算法、通用缓存方法等