C#中ValueTask

在C#中，ValueTask 是一个用于优化异步操作性能的结构体，特别适用于那些可能同步完成的操作。下面我会详细解释它的设计目的、用法和最佳实践。

什么是ValueTask？

ValueTask 是 Task 类型的轻量级替代品，主要目的是减少异步操作中的内存分配。

1public readonly struct ValueTask : IEquatable<ValueTask>
2{
3    // 结构体实现
4}
5
6public readonly struct ValueTask<TResult> : IEquatable<ValueTask<TResult>>
7{
8    // 泛型版本实现
9}
10

设计动机和解决的问题

Task的内存分配问题

1// 传统Task - 即使同步完成也会分配内存
2public async Task<int> GetDataAsync()
3{
4    if (_cache.TryGetValue(key, out var data))
5    {
6        return data; // 同步完成，但仍然会分配Task
7    }
8    return await FetchFromNetworkAsync();
9}
10

ValueTask的解决方案

1// ValueTask - 同步完成时避免内存分配
2public ValueTask<int> GetDataAsync()
3{
4    if (_cache.TryGetValue(key, out var data))
5    {
6        return new ValueTask<int>(data); // 同步结果，无内存分配
7    }
8    return new ValueTask<int>(FetchFromNetworkAsync()); // 异步操作
9}
10

基本用法

1. 创建ValueTask

1// 同步完成的值
2ValueTask<int> syncTask = new ValueTask<int>(42);
3
4// 从Task转换
5ValueTask<int> fromTask = new ValueTask<int>(Task.FromResult(42));
6
7// 异步操作
8ValueTask<int> asyncTask = new ValueTask<int>(SomeAsyncMethod());
9

2. 使用async/await

1public async ValueTask<int> CalculateAsync(int input)
2{
3    // 检查是否可以同步完成
4    if (input < 0)
5    {
6        return 0; // 同步返回
7    }
8    
9    // 需要异步操作
10    await Task.Delay(100);
11    return input * 2;
12}
13
14// 消费ValueTask
15public async Task ConsumeValueTaskAsync()
16{
17    ValueTask<int> valueTask = CalculateAsync(10);
18    int result = await valueTask;
19    Console.WriteLine(result); // 输出: 20
20}
21

实际应用场景

1. 缓存场景优化

1public class DataService
2{
3    private readonly ConcurrentDictionary<string, string> _cache = new();
4    
5    public ValueTask<string> GetDataAsync(string key)
6    {
7        // 同步检查缓存
8        if (_cache.TryGetValue(key, out var data))
9        {
10            return new ValueTask<string>(data);
11        }
12        
13        // 异步获取数据
14        return new ValueTask<string>(FetchAndCacheDataAsync(key));
15    }
16    
17    private async Task<string> FetchAndCacheDataAsync(string key)
18    {
19        var data = await FetchFromExternalServiceAsync(key);
20        _cache[key] = data;
21        return data;
22    }
23}
24

2. I/O操作优化

1public class StreamReaderOptimized
2{
3    private readonly Stream _stream;
4    private byte[] _buffer;
5    
6    public ValueTask<int> ReadAsync(byte[] buffer, int offset, int count)
7    {
8        // 如果数据已经在缓冲区，同步返回
9        if (_buffer != null && _buffer.Length >= count)
10        {
11            Array.Copy(_buffer, 0, buffer, offset, count);
12            return new ValueTask<int>(count);
13        }
14        
15        // 否则进行异步读取
16        return new ValueTask<int>(_stream.ReadAsync(buffer, offset, count));
17    }
18}
19

3. 池化资源管理

1public class ConnectionPool
2{
3    private readonly ConcurrentQueue<Connection> _pool = new();
4    
5    public ValueTask<Connection> GetConnectionAsync()
6    {
7        // 尝试从池中同步获取
8        if (_pool.TryDequeue(out var connection))
9        {
10            return new ValueTask<Connection>(connection);
11        }
12        
13        // 池为空，异步创建新连接
14        return new ValueTask<Connection>(CreateConnectionAsync());
15    }
16    
17    private async Task<Connection> CreateConnectionAsync()
18    {
19        await Task.Delay(100); // 模拟连接建立
20        return new Connection();
21    }
22}
23

高级用法和模式

1. 手动实现ValueTask源

1public class ValueTaskCompletionSource<T>
2{
3    private ManualResetValueTaskSourceCore<T> _core;
4    
5    public ValueTask<T> Task => new ValueTask<T>(this, _core.Version);
6    
7    public void SetResult(T result)
8    {
9        _core.SetResult(result);
10    }
11    
12    public void SetException(Exception exception)
13    {
14        _core.SetException(exception);
15    }
16    
17    // 实现必要的接口方法
18    public short Version => _core.Version;
19    public void SetCompleted() => _core.SetCompleted();
20    public T GetResult(short token) => _core.GetResult(token);
21    public ValueTaskSourceStatus GetStatus(short token) => _core.GetStatus(token);
22    public void OnCompleted(Action<object?> continuation, object? state, short token, ValueTaskSourceOnCompletedFlags flags)
23        => _core.OnCompleted(continuation, state, token, flags);
24}
25

2. 使用IValueTaskSource

1public class CustomAsyncOperation<T> : IValueTaskSource<T>
2{
3    private ManualResetValueTaskSourceCore<T> _core;
4    
5    public ValueTask<T> RunAsync()
6    {
7        // 启动异步操作
8        StartOperation();
9        return new ValueTask<T>(this, _core.Version);
10    }
11    
12    private async void StartOperation()
13    {
14        try
15        {
16            T result = await PerformWorkAsync();
17            _core.SetResult(result);
18        }
19        catch (Exception ex)
20        {
21            _core.SetException(ex);
22        }
23    }
24    
25    // 实现IValueTaskSource接口
26    public T GetResult(short token) => _core.GetResult(token);
27    public ValueTaskSourceStatus GetStatus(short token) => _core.GetStatus(token);
28    public void OnCompleted(Action<object?> continuation, object? state, short token, ValueTaskSourceOnCompletedFlags flags)
29        => _core.OnCompleted(continuation, state, token, flags);
30}
31

性能对比

基准测试示例

1[MemoryDiagnoser]
2public class TaskVsValueTaskBenchmark
3{
4    private readonly Random _random = new Random();
5    
6    [Benchmark]
7    public async Task<int> TraditionalTask()
8    {
9        return await GetDataTaskAsync();
10    }
11    
12    [Benchmark]
13    public async Task<int> ValueTaskOptimized()
14    {
15        return await GetDataValueTaskAsync();
16    }
17    
18    private async Task<int> GetDataTaskAsync()
19    {
20        if (_random.Next(2) == 0)
21            return 42; // 50%几率同步完成
22            
23        await Task.Delay(1);
24        return 100;
25    }
26    
27    private ValueTask<int> GetDataValueTaskAsync()
28    {
29        if (_random.Next(2) == 0)
30            return new ValueTask<int>(42); // 无内存分配
31            
32        return new ValueTask<int>(GetAsyncData());
33        
34        async Task<int> GetAsyncData()
35        {
36            await Task.Delay(1);
37            return 100;
38        }
39    }
40}
41

使用准则和最佳实践

应该使用ValueTask的情况

高频调用的异步方法
可能同步完成的操作
性能敏感的热路径
内存受限的环境

应该避免使用ValueTask的情况

长期存在的异步操作
需要多次await的操作
在UI线程中可能阻塞的操作

重要注意事项

1// ❌ 错误：多次await ValueTask
2ValueTask<int> task = GetDataAsync();
3int result1 = await task;
4// int result2 = await task; // 错误！ValueTask只能await一次
5
6// ✅ 正确：转换为Task如果需要多次使用
7Task<int> task = GetDataAsync().AsTask();
8int result1 = await task;
9int result2 = await task; // 可以，但通常不是好设计
10
11// ✅ 正确：使用ConfigureAwait
12int result = await GetDataAsync().ConfigureAwait(false);
13

与Task的互操作

1// ValueTask 转 Task
2ValueTask<int> valueTask = GetDataAsync();
3Task<int> task = valueTask.AsTask();
4
5// Task 转 ValueTask
6Task<int> originalTask = Task.FromResult(42);
7ValueTask<int> valueTask = new ValueTask<int>(originalTask);
8
9// 在接口中使用
10public interface IDataProvider
11{
12    ValueTask<Data> GetDataAsync();
13}
14
15public class DataService : IDataProvider
16{
17    public async ValueTask<Data> GetDataAsync()
18    {
19        // 实现
20    }
21}
22

总结

ValueTask 是C#中重要的性能优化工具，它：

减少内存分配：特别适合可能同步完成的异步操作
提高性能：在高频调用场景下显著提升性能
保持兼容性：可以与Task无缝互操作
需要谨慎使用：遵循一次await的原则

正确使用 ValueTask 可以在不改变代码逻辑的前提下，为应用程序带来显著的性能提升。

《C#中ValueTask》是转载文章，点击查看原文。