概要

我们在开发过程中，经常使用async的异步方法，但是有些时候，异步的方法中，可能包含一些同步的处理。本文主要介绍通过ValueTask这个struct，优化异步处理的方法性能。

代码及实现

有些时候我们会缓存一些数据在内存中，这些数据因为不经常改变，所以并不需要每次都要从后台数据库中获取。

例如下面的代码：

 private static List<Branch> _branches;
 public async Task<List<Branch>> getBranches(){
    if (_branches is null){
        using (var context = new BankContext()){
            _branches = await context.Branches.ToListAsync();
        }   
    }
    return _branches;
}

在一个银行App相关的系统中，我们将分行的基本信息缓存在内存中，方便其它方法调用。

上面的代码有一个问题，无论我们的缓存是否命中，都会以Task<List>的形式返回。也就是说Runtime需要为返回Task相关的内容分配内存空间；如果缓存命中，意味着该方法仅仅是执行同步操作，实际上只是一个同步操作。

如果以Task<List>作为返回值，对于同步操作而言，完全是在浪费系统资源。Task是一个类，这就意味着只要我们要使用该类，就必须创建对象，然后在通过GC收集。

对于一些高吞吐量，高并发的站点，如果可以对其进行适当优化，可以节约大量资源。

ValueTask 解决方法

在.Net Core .2.0中，引入一个结构体类型 ValueTask, 用于处理async方法中，同步和异步返回并存的情况。

因为其只是一个结构体，它并不需要像Task那样去创建对象，再被GC收集。但是它却可以包裹TResult或Task，作为async方法的返回值。

我们将上面的代码进行修改，将Task替换成ValueTask即可

private static List<Branch> _branches;
public async ValueTask<List<Branch>> getBranchesByTaskValue(){
    if (_branches is null){
        using (var context = new BankContext()){
            _branches = await context.Branches.ToListAsync();
            return _branches;
        }                 
    }
    return _branches;
}

我们用Benchmark测试上述两个方法的性能。
在这里插入图片描述

从测试结果上看，ValueTask作为返回值，消耗时间增加了约27%，但是内存消耗几乎可以忽略不计。

全部代码请参考附录

附录

Programs.cs

using System.Diagnostics;
using System.Globalization;
using System.Diagnostics.CodeAnalysis;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Net.Mail;
using System.ComponentModel.Design.Serialization;
using System;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;
using System.Linq;
using System.Collections.Generic;
using BenchmarkDotNet.Running;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Diagnosers;
namespace IQueryableIEnumerable
{
    [MemoryDiagnoser]
    public class Programs
    {
        [Benchmark]
        public async Task getBranches(){
            TaskValueTest task = new TaskValueTest();
            for(var i=0;i<5;++i){
                await task.getBranches();
            }
        }
        [Benchmark]
        public async Task getBranchesByValueTask(){
            TaskValueTest task = new TaskValueTest();
            for(var i=0;i<5;++i){
                await task.getBranchesByTaskValue();
            }
        }
        public static void Main(string[] args)
        {
             var summary = BenchmarkRunner.Run<Programs>();  
        }  
    }
}

TaskValueTest.cs

namespace IQueryableIEnumerable
{
    using System;
    using System.Threading;
    using System.Threading.Tasks;
    using Microsoft.EntityFrameworkCore;
    using System.Linq;
    using System.Collections.Generic;
    using BenchmarkDotNet.Running;
    using BenchmarkDotNet.Attributes;
    using BenchmarkDotNet.Diagnosers;

    public class TaskValueTest
    {
        private static List<Branch> _branches;
        private static List<Branch> _branches2;
        public async ValueTask<List<Branch>> getBranchesByTaskValue(){
            if (_branches is null){
                using (var context = new BankContext()){
                    _branches = await context.Branches.ToListAsync();
                }                 
            }
            return _branches;
        }
        public async Task<List<Branch>> getBranches(){
            if (_branches2 is null){
                using (var context = new BankContext()){
                    _branches2 = await context.Branches.ToListAsync();
                }   
            }
            return _branches2;
        }
        
    }
}