Fireasy.Data系列——数据库提供者的插件服务簇

     前面已经介绍了，IProvider提供了一种插件式的服务接口，能够将一些扩展的功能附加在提供者中，因为IProvider由IDatabase所引用，因此，只要有IDatabase，就能够获得所有的扩展功能，那么本篇将介绍一下这些扩展服务如何与IProvider一起工作。

 

    首先看一下IProvider接口的定义：

 

    /// <summary>
    /// 为不同的数据库类型提供创建工厂及插件服务。
    /// </summary>
    public interface IProvider
    {
        /// <summary>
        /// 获取提供者类型。
        /// </summary>
        ProviderType ProviderType { get; }

        /// <summary>
        /// 获取数据库提供者工厂。
        /// </summary>
        DbProviderFactory DbProviderFactory { get; }

        /// <summary>
        /// 获取相应的插件服务。
        /// </summary>
        /// <typeparam name="T">插件类型。</typeparam>
        /// <returns></returns>
        T GetService<T>() where T : IProviderService;
        /// <summary>
        /// 附加一个插件服务。
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="service"></param>
        /// <param name="overlay"></param>
        void RegisterService<T>(T service, bool overlay = false) where T : IProviderService;
        /// <summary>
        /// 初始化所有插件服务。
        /// </summary>
        /// <param name="action"></param>
        void Initialize(Action<IProviderService> action);
        /// <summary>
        /// 获取所有插件服务。
        /// </summary>
        /// <returns></returns>
        IEnumerable<IProviderService> GetServices();

        /// <summary>
        /// 获取当前连接的参数。
        /// </summary>
        /// <returns></returns>
        ConnectionParameter GetConnectionParameter(ConnectionString connectionString);

    }

     本文着重关心的是IProviderServices的相关实现细节，因此其他内容不再赘述。

     接下来定义一个实现类，当然也是一个抽象类，具体还要由相应的数据库提供者来实现。

 

    /// <summary>
    /// 基本的数据库提供者。
    /// </summary>
    public abstract class BaseProvider : IProvider
    {
        private readonly Dictionary<string, IProviderService> m_plugs = new Dictionary<string, IProviderService>();

        /// <summary>
        /// 表示 <see cref="DbProviderFactory"/> 对象。
        /// </summary>
        protected DbProviderFactory Factory;
        private Action<IProviderService> m_action;

        /// <summary>
        /// 初始化 <see cref="BaseProvider"/> 类的新实例。
        /// </summary>
        protected BaseProvider()
        {
        }

        /// <summary>
        /// 使用提供者名称初始化 <see cref="BaseProvider"/> 类的新实例。
        /// </summary>
        /// <param name="providerName"></param>
        protected BaseProvider(string providerName)
        {
            Factory = DbProviderFactories.GetFactory(providerName);
        }

        /// <summary>
        /// 获取数据提供者类型。
        /// </summary>
        public abstract ProviderType ProviderType { get; }

        /// <summary>
        /// 获取数据库提供者工厂。
        /// </summary>
        public virtual DbProviderFactory DbProviderFactory
        {
            get
            {
                if (Factory == null)
                {
                    throw new Exception("DbProviderFactory 为空，请检查 providerName 或相关的程序集是否存在。");
                }
                return Factory;
            }
        }

        /// <summary>
        /// 获取相应的插件。
        /// </summary>
        /// <typeparam name="T">插件类型。</typeparam>
        /// <returns></returns>
        public virtual T GetService<T>() where T : IProviderService
        {
            var key = typeof(T).GUID.ToString();
            if (m_plugs.ContainsKey(key))
            {
                return (T)m_plugs[key];
            }
            return default(T);
        }

        /// <summary>
        /// 附加一个插件。
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="provider"></param>
        /// <param name="overwite"></param>
        public void RegisterService<T>(T provider, bool overwite = false) where T : IProviderService
        {
            var implType = provider.GetType().GetDirectImplementInterface(typeof(IProviderService));
            var key = implType.GUID.ToString();
            if (!m_plugs.ContainsKey(key))
            {
                m_plugs.Add(key, provider);
                if (m_action != null)
                {
                    m_action(provider);
                }
            }
            else if (overwite)
            {
                m_plugs[key] = provider;
                if (m_action != null)
                {
                    m_action(provider);
                }
            }
        }

        void IProvider.Initialize(Action<IProviderService> action)
        {
            if (action == null)
            {
                return;
            }
            m_action = action;
            foreach (var kvp in m_plugs)
            {
                action(kvp.Value);
            }
        }

        /// <summary>
        /// 获取所有插件服务。
        /// </summary>
        /// <returns></returns>
        IEnumerable<IProviderService> IProvider.GetServices()
        {
            return m_plugs.Select(kvp => kvp.Value);
        }

        /// <summary>
        /// 获取当前连接的参数。
        /// </summary>
        /// <returns></returns>
        public abstract ConnectionParameter GetConnectionParameter(ConnectionString connectionString);
    }

 

       着重在于RegisterService方法，为什么要用GetDirectImplementInterface方法呢？该方法用于从类型type中获得直接继承自IProviderServices接口的接口，呵呵，这个有点不清晰吧，就用前篇提到的IBatcherProvider接口为例来说吧，IBatcherProvider继承自IProviderServices，将我们用RegisterService方法注册一个IBatcherProvider的实现类时，实际上是获得了IBatcherProvider的类型，这主要是为了方便GetService方法的使用，我们想通过IProvider获得某种扩展服务的实例时，并不需要知道具体的实现类，而是使用GetService<IBatcherProvider>()这样的方式来获取。

       在不同数据库提供者的实现中，分别注册进不同的扩展服务：

 

    /// <summary>
    /// MsSql数据库提供者。
    /// </summary>
    public sealed class MsSqlProvider : BaseProvider
    {   
        /// <summary>
        /// 提供 <see cref="MsSqlProvider"/> 的静态实例。
        /// </summary>
        public readonly static MsSqlProvider Instance = new MsSqlProvider();

        /// <summary>
        /// 初始化 <see cref="MsSqlProvider"/> 类的新实例。
        /// </summary>
        public MsSqlProvider()
            : base ("System.Data.SqlClient")
        {
            RegisterService(new MsSqlBatcher());
            RegisterService(new MsSqlSyntax());
            RegisterService(new MsSqlSchema());
            RegisterService(new MsSqlBackup());
        }
    }

 

       然而，IProviderServices接口有一个上下文对象，该上下文是通过Initialize方法附加到扩展服务中的。在Database的构造函数中，我们可以看到：

 

        /// <summary>
        /// 初始化 <see cref="Database"/> 类的新实例。
        /// </summary>
        /// <param name="connectionString">数据库连接字符串。</param>
        /// <param name="provider">数据库提供者。</param>
        public Database (ConnectionString connectionString, IProvider provider)
            : this ()
        {
            Checker.ArgumentNull(provider, "provider");
            Provider = provider;
            ConnectionString = connectionString;
            var providerContext = new ServiceContext { Database = this };
            Provider.Initialize(p => p.ServiceContext = providerContext);
        }

       通过委托的方式进行了初始化，当然前提是，这部份扩展服务是在提供者的构造里注册的，如果后期注册的，则在RegisterService里由m_action进行调用处理了。

       这样，我们可以使用GetService来获取不同的扩展服务了：

 

var batcher = database.Provider.GetService<IBatcherProvider>();
var syntax = database.Provider.GetService<ISyntaxProvider>();
var schema = database.Provider.GetService<ISchemaProvider>();
var backup = database.Provider.GetService<IBackupProvider>();