[設計模式] 靜態代理居然能解決這種問題，我驚訝了！

• 2022 年 9 月 13 日
• 筆記
• .NET ORM, c# orm, freesql, 設計模式

前言

23種設計模式都會了嗎？今天講一下靜態代理模式的實戰場景。

代理模式給某一個對象提供一個代理對象，並由代理對象控制對原對象的引用。通俗的來講代理模式就是我們生活中常見的中介。

舉個例子來說明：假如說我現在想買一輛二手車，雖然我可以自己去找車源，做質量檢測等一系列的車輛過戶流程，但是這確實太浪費我得時間和精力了。我只是想買一輛車而已為什麼我還要額外做這麼多事呢？於是我就通過中介公司來買車，他們來給我找車源，幫我辦理車輛過戶流程，我只是負責選擇自己喜歡的車，然後付錢就可以了。

為什麼要用代理模式？

中介隔離作用：在某些情況下，一個客戶類不想或者不能直接引用一個委託對象，而代理類對象可以在客戶類和委託對象之間起到中介的作用，其特徵是代理類和委託類實現相同的接口。

解決問題

這篇文章借用 FreeSql.Cloud 開源項目的代碼，講解代理模式的實際應用和收益，以及需要注意的地方。

FreeSql 是 c#.NET 功能強大的 ORM 框架，定義了 IFreeSql 接口，主要針對單個 ConnectionString 生產 ORM 操作對象。

跨多數據庫的時候，不同的 ConnectionString 需要生成多個 IFreeSql 原始對象，如果是多租戶場景每個租戶 ConnectionString 都不相同的情況下，就需要創建 N個 IFreeSql 原始對象。

FreeSql.Cloud 正是為了跨多數據庫的問題而產生，它可以解決：

1、FreeSqlCloud 實現多庫版 IFreeSql 接口，從使用習慣上保持與單庫版 IFreeSql 一致；

2、運行時，FreeSqlCloud 可動態添加或刪除多個 ConnectionString 對應的 IFreeSql；

3、FreeSqlCloud 存儲多租戶 IFreeSql，最後活躍時間 > 10分鐘的租戶，釋放對應 IFreeSql 減少內存開銷；

4、FreeSqlCloud 支持隨時 Change 切換到對應的 IFreeSql 進行操作；

代理模式實戰（一）Scoped FreeSqlCloud 多庫版本

IFreeSql 是一個極為嚴格、簡單，且功能強大的接口，我們一直在嚴格控制 API 泛濫增長，泛濫的 API 在後續改造時非常痛苦。

正因為它的簡單定義，讓我們有機會使用到代理模式實現新的 IFreeSql 實現類 FreeSqlCloud。

public class FreeSqlCloud : IFreeSql
{
    IFreeSql CurrentOrm => ...; //請看後面

    public IAdo Ado => CurrentOrm.Ado;
    public IAop Aop => CurrentOrm.Aop;
    public ICodeFirst CodeFirst => CurrentOrm.CodeFirst;
    public IDbFirst DbFirst => CurrentOrm.DbFirst;
    public GlobalFilter GlobalFilter => CurrentOrm.GlobalFilter;

    public void Transaction(Action handler) => CurrentOrm.Transaction(handler);
    public void Transaction(IsolationLevel isolationLevel, Action handler) => CurrentOrm.Transaction(isolationLevel, handler);
    public ISelect<T1> Select<T1>() where T1 : class => CurrentOrm.Select<T1>();
    public ISelect<T1> Select<T1>(object dywhere) where T1 : class => Select<T1>().WhereDynamic(dywhere);
    public IDelete<T1> Delete<T1>() where T1 : class => CurrentOrm.Delete<T1>();
    public IDelete<T1> Delete<T1>(object dywhere) where T1 : class => Delete<T1>().WhereDynamic(dywhere);
    public IUpdate<T1> Update<T1>() where T1 : class => CurrentOrm.Update<T1>();
    public IUpdate<T1> Update<T1>(object dywhere) where T1 : class => Update<T1>().WhereDynamic(dywhere);
    public IInsert<T1> Insert<T1>() where T1 : class => CurrentOrm.Insert<T1>();
    public IInsert<T1> Insert<T1>(T1 source) where T1 : class => Insert<T1>().AppendData(source);
    public IInsert<T1> Insert<T1>(T1[] source) where T1 : class => Insert<T1>().AppendData(source);
    public IInsert<T1> Insert<T1>(List<T1> source) where T1 : class => Insert<T1>().AppendData(source);
    public IInsert<T1> Insert<T1>(IEnumerable<T1> source) where T1 : class => Insert<T1>().AppendData(source);
    public IInsertOrUpdate<T1> InsertOrUpdate<T1>() where T1 : class => CurrentOrm.InsertOrUpdate<T1>();
}

如上代碼，若 CurrentOrm 返回值是原始 IFreeSql 對象，即會代理調用原始數據庫 ORM 操作方法。方法不多，功能卻強大，代理模式應用起來就會很輕鬆。

由於多個 ConnectionString 的原因，我們需要定義一個字典保存多個原始 IFreeSql 對象：

    readonly Dictionary<string, IFreeSql> _orms = new Dictionary<string, IFreeSql>();

我們已經有了 _orms，還缺什麼？？還缺一個當前 string _dbkey，有了它我們的 CurrentOrm 方法才知道怎麼獲取對應的 IFreeSql：

    string _dbkey;
    IFreeSql CurrentOrm => _orms[_dbkey]; //測試不糾結代碼安全

    //切換數據庫
    IFreeSql Change(string db)
    {
        _dbkey = db;
        return _orms[_dbkey];
    }
    //添加 IFreeSql
    FreeSqlCloud Add(string db, IFreeSql orm)
    {
        if (_dbkey == null) _dbkey = db;
        _orms.Add(db, orm);
        return this;
    }

至此我們基於 Scoped 生命周期的 FreeSqlCloud 就完成了，DI 代碼大概如下：

public void ConfigureServices(IServiceCollection services)
{
    var db1 = new FreeSqlBuilder().UseConnectionString(DataType.Sqlite, "data source=db1.db").Build();
    var db2 = new FreeSqlBuilder().UseConnectionString(DataType.Sqlite, "data source=db2.db").Build();
    services.AddScoped(provider =>
    {
        var cloud = new FreeSqlCloud();
        cloud.Add("db1", db1);
        cloud.Add("db2", db2);
        return cloud;
    });
}

代理模式實戰（二）Singleton FreeSqlCloud 多庫版本

實戰（一）我們實現了 Scoped 版本，可是其實項目中 Singleton 單例才是高性能的保證，特別是多租戶場景，每次 new FreeSqlCloud 不止還要循環 Add 那麼多次，實屬浪費！！！

其實單例並非難事，只需要將 _dbkey 類型修改成 AsyncLocal，這個類型多線程是安全的，有關它的原理請看資料：//www.cnblogs.com/eventhorizon/p/12240767.html

    AsyncLocal<string> _dbkey;
    IFreeSql CurrentOrm => _orms[_dbkey.Value];

    IFreeSql Change(string db)
    {
        _dbkey.Value = db;
        return _orms[_dbkey];
    }
    FreeSqlCloud Add(string db, IFreeSql orm)
    {
        if (_dbkey.Value == null) _dbkey.Value = db;
        _orms.Add(db, orm);
        return this;
    }

至此我們就完成了一個多線程安全的代理模式實現，因此我們只需要在 Ioc 注入之前 Register 好原始 IFreeSql 對象即可：

public void ConfigureServices(IServiceCollection services)
{
    var db1 = new FreeSqlBuilder().UseConnectionString(DataType.Sqlite, "data source=db1.db").Build();
    var db2 = new FreeSqlBuilder().UseConnectionString(DataType.Sqlite, "data source=db2.db").Build();
    var cloud = new FreeSqlCloud();
    cloud.Add("db1", db1);
    cloud.Add("db2", db2);

    services.AddSingleton(cloud);
}

代理模式實現（三）Singleton FreeSqlCloud 多庫多租戶版本

如上，我們使用字典存儲多個 IFreeSql 原始對象，在數量不多的情況下是可行的。

但是如果我們做的是多租戶系統，那麼數量很可能達到幾百，甚至上千個 IFreeSql 對象，並且這些租戶不全都是活躍狀態。

因此我們需要一種釋放機制，當租戶最後活躍時間 > 10分鐘，釋放 IFreeSql 資源，減少內存開銷；

我們可以引用 IdleBus 組件解決該問題，IdleBus 空閑對象管理容器，有效組織對象重複利用，自動創建、銷毀，解決【實例】過多且長時間佔用的問題。有時候想做一個單例對象重複使用提升性能，但是定義多了，有的又可能一直空閑着佔用資源。

IdleBus 專門解決：又想重複利用，又想少佔資源的場景。

此時我們只需要修改內部實現部分代碼如下：

public class FreeSqlCloud : IFreeSql
{
    IdleBus<IFreeSql> _orms = new IdleBus<string, IFreeSql>();
    AsyncLocal<string> _dbkey;
    IFreeSql CurrentOrm => _orms.Get(_dbkey.Value);

    IFreeSql Change(string db)
    {
        _dbkey.Value = db;
        return this;
    }
    FreeSqlCloud Register(string db, Func<IFreeSql> create) //注意 create 類型是 Func
    {
        if (_dbkey.Value == null) _dbkey.Value = db;
        _orms.Register(db, create);
        return this;
    }
    //...
}

public void ConfigureServices(IServiceCollection services)
{
    var cloud = new FreeSqlCloud();
    cloud.Add("db1", () => new FreeSqlBuilder().UseConnectionString(DataType.Sqlite, "data source=db1.db").Build());
    cloud.Add("db2", () => new FreeSqlBuilder().UseConnectionString(DataType.Sqlite, "data source=db1.db").Build());

    services.AddSingleton(cloud);
}

代理模式實現（四）跟隨切換數據庫的倉儲對象

1、靜態倉儲對象

FreeSql.Repository 對象創建時固定了原始 IFreeSql，因此無法跟隨 FreeSqlCloud Change 切換數據庫。

注意：是同一個對象實例創建之後，無法跟隨切換，創建新對象實例不受影響。

因為要在 Repository 創建之前，先調用 fsql.Change 切換好數據庫。

2、動態倉儲對象

但是。。。仍然有一種特殊需求，Repository 在創建之後，仍然能跟隨 fsql.Change 切換數據庫。

實戰中 Scoped 生命同期可能有多個 Repository 對象，因此切換 cloud 即改變所有 Repository 對象狀態，才算方便。

var repo1 = cloud.GetCloudRepository<User>();
var repo2 = cloud.GetCloudRepository<UserGroup>();
cloud.Change("db2");
Console.WriteLine(repo1.Orm.Ado.ConnectionString); //repo -> db2
Console.WriteLine(repo2.Orm.Ado.ConnectionString); //repo -> db2
cloud.Change("db1");
Console.WriteLine(repo1.Orm.Ado.ConnectionString); //repo -> db1
Console.WriteLine(repo2.Orm.Ado.ConnectionString); //repo -> db1

我們仍然使用了代理模式，IBaseRepository 接口定義也足夠簡單：

提示：關鍵看 CurrentRepo 的獲取

class RepositoryCloud<TEntity> : IBaseRepository<TEntity> where TEntity : class
{
    readonly FreeSqlCloud _cloud;
    public RepositoryCloud(FreeSqlCloud cloud)
    {
        _cloud = cloud;
    }

    public IBaseRepository<TEntity> CurrentRepo => ...; //請看後面
    public IUnitOfWork UnitOfWork
    {
        get => CurrentRepo.UnitOfWork;
        set => CurrentRepo.UnitOfWork = value;
    }

    public IFreeSql Orm => CurrentRepo.Orm;
    public Type EntityType => CurrentRepo.EntityType;
    public IDataFilter<TEntity> DataFilter => CurrentRepo.DataFilter;
    public ISelect<TEntity> Select => CurrentRepo.Select;
    public IUpdate<TEntity> UpdateDiy => CurrentRepo.UpdateDiy;
    public ISelect<TEntity> Where(Expression<Func<TEntity, bool>> exp) => CurrentRepo.Where(exp);
    public ISelect<TEntity> WhereIf(bool condition, Expression<Func<TEntity, bool>> exp) => CurrentRepo.WhereIf(condition, exp);

    public void Attach(TEntity entity) => CurrentRepo.Attach(entity);
    public void Attach(IEnumerable<TEntity> entity) => CurrentRepo.Attach(entity);
    public IBaseRepository<TEntity> AttachOnlyPrimary(TEntity data) => CurrentRepo.AttachOnlyPrimary(data);
    public Dictionary<string, object[]> CompareState(TEntity newdata) => CurrentRepo.CompareState(newdata);
    public void FlushState() => CurrentRepo.FlushState();

    public void BeginEdit(List<TEntity> data) => CurrentRepo.BeginEdit(data);
    public int EndEdit(List<TEntity> data = null) => CurrentRepo.EndEdit(data);

    public TEntity Insert(TEntity entity) => CurrentRepo.Insert(entity);
    public List<TEntity> Insert(IEnumerable<TEntity> entitys) => CurrentRepo.Insert(entitys);
    public TEntity InsertOrUpdate(TEntity entity) => CurrentRepo.InsertOrUpdate(entity);
    public void SaveMany(TEntity entity, string propertyName) => CurrentRepo.SaveMany(entity, propertyName);

    public int Update(TEntity entity) => CurrentRepo.Update(entity);
    public int Update(IEnumerable<TEntity> entitys) => CurrentRepo.Update(entitys);

    public int Delete(TEntity entity) => CurrentRepo.Delete(entity);
    public int Delete(IEnumerable<TEntity> entitys) => CurrentRepo.Delete(entitys);
    public int Delete(Expression<Func<TEntity, bool>> predicate) => CurrentRepo.Delete(predicate);
    public List<object> DeleteCascadeByDatabase(Expression<Func<TEntity, bool>> predicate) => CurrentRepo.DeleteCascadeByDatabase(predicate);
}

如上代碼關鍵實現部分 CurrentRepo，我們定義了字典存儲多個 IBaseRepository 原始倉儲對象：

因為一個 CloudRepository 對象會創建 1-N 個 IBaseRepository 原始對象，在不使用 cloud.Change(..) 方法的時候只會創建 1 個，最多創建 cloud.Registers 數量，真實場景中不會有人在同一個業務把所有 db 都切換個遍。

    readonly Dictionary<string, IBaseRepository<TEntity>> _repos = new Dictionary<string, IBaseRepository<TEntity>>();
    protected void ForEachRepos(Action<IBaseRepository<TEntity>> action)
    {
        foreach (var repo in _repos.Values) action(repo);
    }
    public void Dispose()
    {
        ForEachRepos(repo => repo.Dispose());
        _repos.Clear();
    }
    
    protected IBaseRepository<TEntity> CurrentRepo
    {
        get
        {
            var dbkey = _cloud._dbkey.Value;
            if (_repos.TryGetValue(dbkey, out var repo) == false)
            {
                _repos.Add(dbkey, repo = _cloud.Use(dbkey).GetRepository<TEntity>());
                if (_dbContextOptions == null) _dbContextOptions = repo.DbContextOptions;
                else
                {
                    repo.DbContextOptions = _dbContextOptions;
                    if (_asTypeEntityType != null) repo.AsType(_asTypeEntityType);
                    if (_asTableRule != null) repo.AsTable(_asTableRule);
                }
            }
            return repo;
        }
    }

    Type _dbContextOptions;
    public DbContextOptions DbContextOptions
    {
        get => CurrentRepo.DbContextOptions;
        set => ForEachRepos(repo => repo.DbContextOptions = value);
    }
    Type _asTypeEntityType;
    public void AsType(Type entityType)
    {
        _asTypeEntityType = entityType;
        ForEachRepos(repo => repo.AsType(entityType));
    }
    Func<string, string> _asTableRule;
    public void AsTable(Func<string, string> rule)
    {
        _asTableRule = rule;
        ForEachRepos(repo => repo.AsTable(rule));
    }

由於 DbContextOptions、AsType、AsTable 比較特殊，需要將多個原始倉儲對象傳播設置，代碼如上。

最終還要為 CloudRepository 創建擴展方法：

public static IBaseRepository<TEntity> GetCloudRepository<TEntity>(this FreeSqlCloud cloud)
    where TEntity : class
{
    return new RepositoryCloud<TEntity>(cloud);
}

結語

Repository 是一種非常方便做設計的模式，FreeSql 還有很多一些其他設計模式的應用，如果有興趣以後找機會再寫文章。

作者是什麼人？

作者是一個入行 18年的老批，他目前寫的.net 開源項目有：

需要的請拿走，這些都是最近幾年的開源作品，以前更早寫的就不發了。