C# 结合 using 语句块的三种实用方法

一、简介

阅读 abp 源码的过程中，自己也学习到了一些之前没有接触过的知识。在这里，我在这儿针对研究学习 abp 框架中，遇到的一些值得分享的知识写几篇文章。如果有什么疑问或者问题，欢迎大家评论指正。

在本篇主要是 scoped 范围与 using 语句块的使用。using 语句块大家一定都不陌生，都是与非托管对象一起存在的，它有一个特性就是在 using 语句块结束的时候会调用对象的 idispose.dispose() 方法。一般我们会在非托管类型的 dispose() 方法内部进行资源的释放，类似于 c 语言的 free() 操作。

例如下面的代码：

public void testmethod()
{
    using(var waitdisposeobj = new testclass())
    {
        // 执行其他操作 xxx
    }
    
    // 出了语句块之后就，自动调用 waitdisposeobj 的 dispose() 方法。
}

可以看到上面的例子，using 语句块包裹的就是一个范围 (scoped)。其实这里可以延伸到依赖注入的概念，在依赖注入的生命周期当中有一个 scoped 的生命周期。(ps: 需要了解的可以去阅读我的 )

一个 scoped 其实就可以看作是一个 using 语句块包裹的范围，所有解析出来的对象在离开 using 语句块的时候都应该被释放。

例如下面的代码：

public void testmethod()
{
    using(var scopedresolver = new scopedresolver())
    {
        var a = scopedresolver.resolve<a>();
        var b = scopedresolver.reslove<b>();
    }
    
    // 出了语句块之后 a b 对象自动释放
}

其实这里也是利用了 using 语句块的特性，在 scopedresolver 类型的定义当中，也实现了 idisopse 接口。所以在 using 语句块结束的时候，会自动调用 scopedresovler 的 dispose() 方法，在这个方法内部则对已经解析出来的对象调用其 dispose() 进行释放。

二、分析

2.0 释放委托

也是不知道叫什么标题了，这玩意儿是 abp 封装的一个类型，它的作用就是在 using 语句块结束的时候，执行你传入的委托。

使用方法如下：

var completedtask = new disposeaction(()=>console.writeline("using 语句块结束了。"));
using(completedtask)
{
    // 其他操作
}
// 执行完成之后会调用 completedtask 传入的委托。

根据上述用法，你也应该猜出来这个 disposeaction 类型的定义了。该类型继承了 idispose 接口，并且在内部有一个 action 字段，用于存储构造函数传入的委托。在执行 dispose() 方法的时候，执行传入的委托。

public class disposeaction : idisposable
{
    public static readonly disposeaction empty = new disposeaction(null);

    private action _action;

    public disposeaction([canbenull] action action)
    {
        _action = action;
    }

    public void dispose()
    {
        // 防止在多线程环境下，多次调用 action
        var action = interlocked.exchange(ref _action, null);
        action?.invoke();
    }
}

2.1 统一对象释放

统一对象释放是 abp 当中的另一种用法，其实按照 abp 框架的定义，叫做 scopedresolver(范围解析器)。顾名思义，通过 scopedresolver 解析出来的对象，都会在 using 语句块结束之后统一进行销毁。

iscopediocresolver 接口继承自 iiocresolver 和 idisposable 接口，它的本质就是作为 ioc 解析器的一种特殊实现，所以它拥有所有 ioc 解析器的方法，这里就不再赘述。

它的实现也比较简单，在其内部有一个集合维护每一次通过 iiocresolver 解析出来的对象。在 dispose() 方法执行的时候，遍历这个集合，调用 ioc 解析器的 release() 方法释放对象并从集合中删除对象。下面就是实现的简化版：

public class scopediocresolver : iscopediocresolver
{
    private readonly iiocresolver _iocresolver;
    private readonly list<object> _resolvedobjects;

    public scopediocresolver(iiocresolver iocresolver)
    {
        _iocresolver = iocresolver;
        _resolvedobjects = new list<object>();
    }
    
    // 解析对象
    public object resolve(type type)
    {
        var resolvedobject = _iocresolver.resolve(type);

        // 添加到集合，方便后续释放
        _resolvedobjects.add(resolvedobject);
        return resolvedobject;
    }
    
    public void release(object obj)
    {
        // 从集合当中移除
        _resolvedobjects.remove(obj);
        // 通过 ioc 管理器释放对象
        _iocresolver.release(obj);
    }
    
    public void dispose()
    {
        // 遍历集合，释放对象
        _resolvedobjects.foreach(_iocresolver.release);
    }
}

通过 iscopedresolver 解析出来的对象，在 using 语句块结束的时候都会被释放，免去了我们每次手动释放的操作。

2.2 临时值变更

暂时想不到一个好一点的标题，暂时用这个标题代替吧。这里以 abp 的一段实例代码为例，在有的时候我们可能当前的用户没有登录，所以在 iabpsession 里面的 userid 等属性肯定是为 null 的。而 iabpsession 在设计的时候，这些属性是不允许更改的。

那么我们有时候可能会临时更改 iabpsession 里面关于 userid 的值怎么办呢？

这个时候可以通过 iabpsession 提供的一个 idisposable use(int tenantid, long? userid, string usercode) 进行临时更改。他拥有一个 use() 方法，并且返回一个实现了 idispose 接口的对象，用法一般是这样：

public void testmethod()
{
    using(abpsession.use(1,2,"3"))
    {
       // 内部临时更改了 abpsession 的值 
    }
    
    // using 语句块结束的时候，调用 use 返回对象的 dispose 方法。
}

转到其抽象类 abpsessionbase 实现，可以看到他的实现是这个样子的：

protected iambientscopeprovider<sessionoverride> sessionoverridescopeprovider { get; }

public idisposable use(int tenantid, long? userid, string usercode)
{
    return sessionoverridescopeprovider.beginscope(sessionoverridecontextkey, new sessionoverride(null, tenantid, userid, usercode));
}

所以在这里，它是通过 sessionoverridescopeprovider 的 begionscope() 方法创建了可以被 dispose() 的对象。

接着继续跳转，来到 iambientscopeprovider 接口定义，这个接口接受一个泛型参数，可以看到之前在 abpsessionbase 传入了一个 sessionoverride。这个 sessionoverride 就是封装了 userid 等信息的存储类，也就是说 sessionoverride 就是允许进行临时值更改的类型定义。

在开始执行 begionscope() 方法的时候，就针对传入的 value 进行存储，获取 session 值的时候优先读取存储的值，不存在才执行真正的读取，调用 dispose() 方法的时候就进行释放。

所以接口提供了两个方法，第一个我们先看 begionscope() 方法，接收一个 contextkey 用来区分不同的临时值，第二个参数则是要存储的临时值。

第二个方法为 getvalue，从一个上下文(后面讲)当中根据 contextkey 获得存储的临时值。

public interface iambientscopeprovider<t>
{
    t getvalue(string contextkey);

    idisposable beginscope(string contextkey, t value);
}

针对于该接口，其默认实现是 datacontextambientscopeprovider ，它的内部可能略微复杂，牵扯到了另一个接口 iambientdatacontext 和 scopeitem 类型。

这两个类型一个是上下文，一个是包裹具体临时值对象的类型。我们先从 beginscope() 方法开始看：

// scopeitem 的 id 与其值关联的字典，其键为 guid，值为具体的 scopeitem 对象，这里并未与 contextkey 进行关联。
private static readonly concurrentdictionary<string, scopeitem> scopedictionary = new concurrentdictionary<string, scopeitem>();

// 数据的上下文对象，管理 contextkey 与其 id。
private readonly iambientdatacontext _datacontext;

public idisposable beginscope(string contextkey, t value)
{
    // 将需要临时存储的对象，用 scopeitem 包装起来，它的外部对象是当前对象 (如果存在的话)。
    var item = new scopeitem(value, getcurrentitem(contextkey));

    // 将包装好的对象以 id-对象，的形式存储在字典当中。
    if (!scopedictionary.tryadd(item.id, item))
    {
        throw new abpexception("can not add item! scopedictionary.tryadd returns false!");
    }

    // 在上下文当中设置当前的 contextkey 关联的 id。
    _datacontext.setdata(contextkey, item.id);

    // 集合释放委托，using 语句块结束时，做释放操作。
    return new disposeaction(() =>
    {
        // 从字典中移除指定 id 的对象。
        scopedictionary.tryremove(item.id, out item);

        // 如果包装对象没有外部对象，直接设置上下文关联的 id 为 null。
        if (item.outer == null)
        {
            _datacontext.setdata(contextkey, null);
            return;
        }

        // 如果还有外部对象，则设置上下文关联的 id 为外部对象的 i的。
        _datacontext.setdata(contextkey, item.outer.id);
    });
}

从上面的逻辑可以看出来，每次我们加入的临时值都是通过 scopeitem 包裹起来的。而这个 scopeitem 与我们的工作单元相似，它会有一个外部连接的对象。这个外部连接对象的作用就是解决 using 语句嵌套问题的，例如我们有以下代码：

public void testmethod()
{
    using(abpsession.use(1,2,"3"))
    {
       // 一些业务逻辑
       // scopeitem.outer = null;
       using(abpsession.use(4,5,"6"))
       {
           // 一些业务逻辑
           // scopeitem.outer = 外部对象;
       }
    }
}

那么我们在这里会有同一个 contextkey，都是提供给 abpsession 使用的。第一次我在 use() 内部通过 beginscope() 方法创建了一个 scopeitem 对象，包装了临时值，这个 scopeitem 的外部对象为 null。第二次我又在内部创建了一个 scopeitem 对象，包装了第二个临时值，这个时候 scopeitem 的外部对象就是第一次包装的对象了。

执行释放操作的时候，首先判断外部对象是否为空。如果为空则直接在上下文当中将绑定的 scopeitem 的 id 值设为 null，如果不为空，则设置为它的外部对象的 id。

还是以上面的代码为例，在 dispose() 被执行之后，由内而外，到最外层的时候在上下文与 contextkey 关联的 id 已经被置为 null 了。

private scopeitem getcurrentitem(string contextkey)
{
    // 从数据上下文获取指定 contextkey 当前关联的 id 值。
    var objkey = _datacontext.getdata(contextkey) as string;
    // 不存在则返回 null，存在则尝试以 id 从字典中拿取对象外部，并返回。
    return objkey != null ? scopedictionary.getordefault(objkey) : null;
}

分析了一下 iambientdatacontext 的实现，感觉与 icurrentunitofworkprovider 类似，内部都是通过 asynclocal 来进行处理的。

public class asynclocalambientdatacontext : iambientdatacontext, isingletondependency
{
    // 这里的字典是以 contextkey 与 scopeitem 的 id 构成的。
    private static readonly concurrentdictionary<string, asynclocal<object>> asynclocaldictionary = new concurrentdictionary<string, asynclocal<object>>();

    public void setdata(string key, object value)
    {
        // 设置指定 contextkey 对应的 id 值。
        var asynclocal = asynclocaldictionary.getoradd(key, (k) => new asynclocal<object>());
        asynclocal.value = value;
    }

    public object getdata(string key)
    {
        // 获取指定 contextkey 对应的 id 值。
        var asynclocal = asynclocaldictionary.getoradd(key, (k) => new asynclocal<object>());
        return asynclocal.value;
    }
}

从开始到这里使用并行字典的情况来看，这里这么做的原因很简单，是为了处理异步上下文切换的情况，确保 contextkey 对应的 id 是一致的，防止在 get/set data 的时候出现 。

最后呢在具体的 session 实现类 claimsabpsession 当中要获取 userid 会经过下面的步骤：

public override long? userid
{
    get
    {
        // 尝试从临时对象中获取数据。
        if (overridedvalue != null)
        {
            return overridedvalue.userid;
        }

        // 从 jwt token 当中获取 userid 信息。

        return userid;
    }
}

最后我再贴上 scopeitem 的定义。

private class scopeitem
{
    public string id { get; }

    public scopeitem outer { get; }

    public t value { get; }

    public scopeitem(t value, scopeitem outer = null)
    {
        id = guid.newguid().tostring();

        value = value;
        outer = outer;
    }
}

这个临时值变更可能是 abp 用法当中最为复杂的一个，牵扯到了异步上下文和 using 语句嵌套的问题。但仔细阅读源码之后，其实有一种豁然开朗的感觉，也加强了对于 c# 程序设计的理解。

三、结语

通过学习 abp 框架，也了解了自己在基础方面的诸多不足。其次也是能够看到一些比较实用新奇的写法，你也可以在自己项目中进行应用，本文主要是起一个抛砖引玉的作用。最近年底了，事情也比较多，博客也是疏于更新。后面会陆续恢复博文更新，尽量 2 天 1 更，新年新气象。