适合医院多数据访问框架简介

       由于医院的系统很多，而且各个系统的厂商和采用数据库的类型也都不同,对没有医院综合管理平台和临床数据中心的的医院来说，想要获取各个系统的数据，没有一个方便的访问框架非常不方便。

       框架是底层采用AOD.NET来访问操作数据库的.

       

IAccessDataBase.cs

using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;

namespace JDRMYY.IService
{
    /// <summary>
    /// 连接数据库接口
    /// </summary>
    /// <typeparam name="paramType">需要传入数据库的参数类型</typeparam>
    public interface IAccessDataBase<paramType> where paramType : class
    {

        /// <summary>
        /// 执行查询，并返回由查询返回的结果集中的第一行的第一列。
        /// </summary>
        /// <param name="sql">sql语句</param>
        /// <param name="pms">sql参数</param>
        /// <returns>结果集中的第一行的第一列</returns>
        object ExecuteScalar(string sql, params paramType[] parameters);
        /// <summary>
        /// 对连接执行 SQL 语句并返回受影响的行数
        /// </summary>
        /// <param name="sql">sql语句</param>
        /// <param name="pms">sql参数</param>
        /// <returns>受影响的行数</returns>
        int ExecuteNoneQuery(string sql, params paramType[] parameters);
        /// <summary>
        ///  对连接执行 SQL 语句并返回 DataTable 
        /// </summary>
        /// <param name="sql">sql语句</param>
        /// <param name="pms">sql参数</param>
        /// <returns>DataTable</returns>
        DataTable ExecuteDataTable(string sql,params paramType[] parameters);
        /// <summary>
        /// 对连接执行 存储过程 语句并返回受影响的行数
        /// </summary>
        /// <param name="sql">sql语句</param>
        /// <param name="pms">sql参数</param>
        /// <returns></returns>
        int SpExecuteNoneQuery(string sql, params paramType[] parameters);
        /// <summary>
        /// 执行 存储过程，并返回由查询返回的结果集中的第一行的第一列。
        /// </summary>
        /// <param name="sql">sql语句</param>
        /// <param name="pms">sql参数</param>
        /// <returns>结果集中的第一行的第一列</returns>
        object SpExecuteScalar(string sql, params paramType[] parameters);
        /// <summary>
        /// 对连接执行 存储过程 语句并返回 DataTable 
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="parameters"></param>
        /// <returns></returns>
        DataTable SpExecuteDataTable(string sql, params paramType[] parameters);
        /// <summary>
        /// 更新、插入、删除数据库的时候，事务的封装
        /// </summary>
        /// <param name="ps">是一个可变参数，可以传入多个sql语句和参数，执行一个事务</param>
        /// <returns></returns>
        bool ExecuteNoneQueryByTransaction(params PS<paramType>[] ps);
    }
    /// <summary>
    /// sql语句和参数数据
    /// </summary>
    /// <typeparam name="T">数据库参数类型</typeparam>
    public class PS<T> where T : class
    {
        /// <summary>
        /// sql语句
        /// </summary>
        public string sql { get; set; }
        /// <summary>
        /// 参数数组
        /// </summary>
        public T[] pms { get; set; }
    }
}

MssqlService.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Data.SqlClient;
using System.Data;
using JDRMYY.IService;

namespace JDRMYY.Service
{ 
    public class MssqlService :IAccessDataBase<SqlParameter>
    {

        /// <summary>
        /// 数据库连接字符串
        /// </summary>
        public string _ConnStr
        {
            get;
            set;
        }
        /// <summary>
        /// 初始化数据库连接字符串
        /// </summary>
        /// <param name="ConnStr"></param>
        public MssqlService(string ConnStr)
        {
            this._ConnStr = ConnStr;

        }
        /// <summary>
        ///  对连接执行 Transact-SQL 语句并返回 DataTable 
        /// </summary>
        /// <param name="sql">sql语句</param>
        /// <param name="parameters">sql参数</param>
        /// <returns> DataTable </returns>
        public DataTable ExecuteDataTable(string sql, params SqlParameter[] parameters)
        {
            using (SqlConnection conn = new SqlConnection(this._ConnStr))
            {
                conn.Open();
                using (SqlCommand cmd = conn.CreateCommand())
                {
                    cmd.CommandText = sql;
                    cmd.CommandTimeout = 300;
                    cmd.Parameters.AddRange(parameters);
                    DataSet dataset = new DataSet();
                    SqlDataAdapter adapter = new SqlDataAdapter(cmd);
                    adapter.Fill(dataset);
                    return dataset.Tables[0];
                }
            }
        }
        /// <summary>
        /// 对连接执行 Transact-SQL 语句并返回受影响的行数
        /// </summary>
        /// <param name="sql">sql语句</param>
        /// <param name="parameters">sql参数</param>
        /// <returns>受影响的行数</returns>
        public int ExecuteNoneQuery(string sql,params SqlParameter[] parameters)
        {
            using (SqlConnection conn = new SqlConnection(this._ConnStr))
            {
                conn.Open();
                using (SqlCommand cmd = conn.CreateCommand())
                {
                    cmd.CommandText = sql;
                    cmd.Parameters.AddRange(parameters);
                    return cmd.ExecuteNonQuery();
                }
            }
        }
        /// <summary>
        /// 执行查询，并返回由查询返回的结果集中的第一行的第一列。
        /// </summary>
        /// <param name="sql">sql语句</param>
        /// <param name="parameters">sql参数</param>
        /// <returns>结果集中的第一行的第一列</returns>
        public object ExecuteScalar(string sql, params SqlParameter[] parameters)
        {
            using (SqlConnection conn = new SqlConnection(this._ConnStr))
            {
                conn.Open();
                using (SqlCommand cmd = conn.CreateCommand())
                {
                    cmd.CommandText = sql;
                    cmd.Parameters.AddRange(parameters);
                    return cmd.ExecuteScalar();
                }
            }
        }
        /// <summary>
        /// 对连接执行 存储过程 语句并返回受影响的行数
        /// </summary>
        /// <param name="sql">sql语句</param>
        /// <param name="pms">sql参数</param>
        /// <returns></returns>
        public int SpExecuteNoneQuery(string sql, params SqlParameter[] parameters)
        {
            using (SqlConnection conn = new SqlConnection(this._ConnStr))
            {
                conn.Open();
                using (SqlCommand cmd = conn.CreateCommand())
                {
                    cmd.CommandType = CommandType.StoredProcedure;
                    cmd.CommandText = sql;
                    cmd.Parameters.AddRange(parameters);
                    return cmd.ExecuteNonQuery();
                }
            }
        }
        /// <summary>
        /// 执行 存储过程，并返回由查询返回的结果集中的第一行的第一列。
        /// </summary>
        /// <param name="sql">sql语句</param>
        /// <param name="pms">sql参数</param>
        /// <returns>结果集中的第一行的第一列</returns>
        public object SpExecuteScalar(string sql, params SqlParameter[] parameters)
        {
            using (SqlConnection conn = new SqlConnection(this._ConnStr))
            {
                conn.Open();
                using (SqlCommand cmd = conn.CreateCommand())
                {
                    cmd.CommandType = CommandType.StoredProcedure;
                    cmd.CommandText = sql;
                    cmd.Parameters.AddRange(parameters);
                    return cmd.ExecuteScalar();
                }
            }
        }
        /// <summary>
        /// 对连接执行 存储过程 语句并返回 DataTable 
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="pms"></param>
        /// <returns></returns>
        public DataTable SpExecuteDataTable(string sql, params SqlParameter[] parameters)
        {
            using (SqlConnection conn = new SqlConnection(this._ConnStr))
            {
                conn.Open();
                using (SqlCommand cmd = conn.CreateCommand())
                {
                    cmd.CommandType = CommandType.StoredProcedure;
                    cmd.CommandText = sql;
                    cmd.CommandTimeout = 300;
                    cmd.Parameters.AddRange(parameters);
                    DataSet dataset = new DataSet();
                    SqlDataAdapter adapter = new SqlDataAdapter(cmd);
                    adapter.Fill(dataset);
                    return dataset.Tables[0];
                }
            }
        }
        /// <summary>
        /// 更新、插入、删除数据库的时候，事务的封装
        /// </summary>
        /// <param name="ps"></param>
        /// <returns></returns>
        public bool ExecuteNoneQueryByTransaction(params PS<SqlParameter>[] ps)
        {

            using (SqlConnection conn = new SqlConnection(this._ConnStr))
            {
                conn.Open();
                using (SqlTransaction trans = conn.BeginTransaction())
                {
                    using (SqlCommand cmd = conn.CreateCommand())
                    {
                        try
                        {
                            cmd.Transaction = trans;
                            foreach (PS<SqlParameter> p in ps)
                            {
                                cmd.Parameters.Clear();//设置参数之前先清空参数设置
                                cmd.CommandText = p.sql;
                                cmd.Parameters.AddRange(p.pms);
                                cmd.ExecuteNonQuery();
                            }
                            trans.Commit();
                            return true;
                        }
                        catch
                        {
                            trans.Rollback();
                            return false;
                        }
                    }
                }
            }
        }
    }
}

使用数据库对象的时候，引入了线程，从线程中取出数据库对象，如果取不到对象则实例化数据库对象，代码如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.OracleClient;
using System.Data.SqlClient;
using MySql.Data.MySqlClient;
using Npgsql;
using JDRMYY.IService;
using JDRMYY.Service;
using System.Runtime.Remoting.Messaging;

namespace JDRMYY.Utility
{
    /// <summary>
    /// 从线程中 操作数据库对象的 方式
    /// </summary>
    public class DBFactory
    {
        /// <summary>
        /// 联众HIS数据库访问对象
        /// </summary>
        public static IAccessDataBase<OracleParameter> LZHisObj
        {
            get
            {
                //1.从线程中取出 键 对应的值
                var db = CallContext.GetData("LZHisDB") as IAccessDataBase<OracleParameter>;
                //2.如果为空（线程中不存在）
                if (db == null)
                {
                    //3.实例化 数据库
                    db = new OracleService(ConnectionString.LZHisConnStr);
                    //4.并存入线程
                    CallContext.SetData("LZHisDB", db);
                }
                //5.返回数据库对象
                return db;
            }
        }
        /// <summary>
        /// 矽岛HealthCare数据库的访问对象
        /// </summary>
        public static IAccessDataBase<SqlParameter> SIHealthCareObject
        {
            get
            {
                //1.从线程中取出 键 对应的值
                var db = CallContext.GetData("SIHealthCareDB") as IAccessDataBase<SqlParameter>;
                //2.如果为空（线程中不存在）
                if (db == null)
                {
                    //3.实例化 数据库
                    db = new MssqlService(ConnectionString.SIHealthCareConnStr);
                    //4.并存入线程
                    CallContext.SetData("SIHealthCareDB", db);
                }
                //5.返回数据库对象
                return db;
            }
        }
        /// <summary>
        /// 矽岛HealthMedicalRecord数据库的访问对象
        /// </summary>
        public static IAccessDataBase<SqlParameter> SIHealthMedicalRecordObject
        {
            get
            {
                //1.从线程中取出 键 对应的值
                var db = CallContext.GetData("SIHealthMedicalRecordDB") as IAccessDataBase<SqlParameter>;
                //2.如果为空（线程中不存在）
                if (db == null)
                {
                    //3.实例化 数据库
                    db = new MssqlService(ConnectionString.SIHealthMedicalRecordConnStr);
                    //4.并存入线程
                    CallContext.SetData("SIHealthMedicalRecordDB", db);
                }
                //5.返回数据库对象
                return db;
            }
        }
        /// <summary>
        /// 在线考试数据库的访问对象
        /// </summary>
        public static IAccessDataBase<MySqlParameter> ExamObj
        {
            get
            {
                //1.从线程中取出 键 对应的值
                var db = CallContext.GetData("ExamDB") as IAccessDataBase<MySqlParameter>;
                //2.如果为空（线程中不存在）
                if (db == null)
                {
                    //3.实例化 数据库
                    db = new MysqlService(ConnectionString.ExamConnStr);
                    //4.并存入线程
                    CallContext.SetData("ExamDB", db);
                }
                //5.返回数据库对象
                return db;
            }
        }
        /// <summary>
        /// PACS数据库访问对象
        /// </summary>
        public static IAccessDataBase<OracleParameter> PacsObj
        {
            get
            {
                //1.从线程中取出 键 对应的值
                var db = CallContext.GetData("PacsDB") as IAccessDataBase<OracleParameter>;
                //2.如果为空（线程中不存在）
                if (db == null)
                {
                    //3.实例化 数据库
                    db = new OracleService(ConnectionString.PacsConnStr);
                    //4.并存入线程
                    CallContext.SetData("PacsDB", db);
                }
                //5.返回数据库对象
                return db;
            }
        }
        /// <summary>
        /// 医惠数据库访问对象
        /// </summary>
        public static IAccessDataBase<OracleParameter> EwellObj
        {
            get
            {
                //1.从线程中取出 键 对应的值
                var db = CallContext.GetData("EwellDB") as IAccessDataBase<OracleParameter>;
                //2.如果为空（线程中不存在）
                if (db == null)
                {
                    //3.实例化 数据库
                    db = new OracleService(ConnectionString.EwellConnStr);
                    //4.并存入线程
                    CallContext.SetData("EwellDB", db);
                }
                //5.返回数据库对象
                return db;
            }

        }
        /// <summary>
        /// 静脉配置中心数据库访问对象
        /// </summary>
        public static IAccessDataBase<SqlParameter> PivasObj
        {
            get
            {
                //1.从线程中取出 键 对应的值
                var db = CallContext.GetData("PivasDB") as IAccessDataBase<SqlParameter>;
                //2.如果为空（线程中不存在）
                if (db == null)
                {
                    //3.实例化 数据库
                    db = new MssqlService(ConnectionString.PivasConnStr);
                    //4.并存入线程
                    CallContext.SetData("PivasDB", db);
                }
                //5.返回数据库对象
                return db;
            }
        }
        /// <summary>
        /// 短信机数据库访问对象
        /// </summary>
        public static IAccessDataBase<SqlParameter> OpenMasObj
        {
            get
            {
                //1.从线程中取出 键 对应的值
                var db = CallContext.GetData("OpenMasDB") as IAccessDataBase<SqlParameter>;
                //2.如果为空（线程中不存在）
                if (db == null)
                {
                    //3.实例化 数据库
                    db = new MssqlService(ConnectionString.OpenMasConnStr);
                    //4.并存入线程
                    CallContext.SetData("OpenMasDB", db);
                }
                //5.返回数据库对象
                return db;
            }
        }
        /// <summary>
        /// Oa数据库访问对象
        /// </summary>
        public static IAccessDataBase<OracleParameter> OaObj
        {
            get
            {
                //1.从线程中取出 键 对应的值
                var db = CallContext.GetData("OaDB") as IAccessDataBase<OracleParameter>;
                //2.如果为空（线程中不存在）
                if (db == null)
                {
                    //3.实例化 数据库
                    db = new OracleService(ConnectionString.OaConnStr);
                    //4.并存入线程
                    CallContext.SetData("OaDB", db);
                }
                //5.返回数据库对象
                return db;
            }
        }
        /// <summary>
        /// 手麻系统数据库访问对象
        /// </summary>
        public static IAccessDataBase<OracleParameter> DoCareObj
        {
            get
            {
                //1.从线程中取出 键 对应的值
                var db = CallContext.GetData("DoCareDB") as IAccessDataBase<OracleParameter>;
                //2.如果为空（线程中不存在）
                if (db == null)
                {
                    //3.实例化 数据库
                    db = new OracleService(ConnectionString.DoCareConnStr);
                    //4.并存入线程
                    CallContext.SetData("DoCareDB", db);
                }
                //5.返回数据库对象
                return db;
            }
        }
        /// <summary>
        /// 心电图数据库访问对象
        /// </summary>
        public static IAccessDataBase<SqlParameter> EcgObj
        {
            get
            {
                //1.从线程中取出 键 对应的值
                var db = CallContext.GetData("EcgDB") as IAccessDataBase<SqlParameter>;
                //2.如果为空（线程中不存在）
                if (db == null)
                {
                    //3.实例化 数据库
                    db = new MssqlService(ConnectionString.EcgConnStr);
                    //4.并存入线程
                    CallContext.SetData("EcgDB", db);
                }
                //5.返回数据库对象
                return db;
            }
        }
        /// <summary>
        /// Pacs检查预约数据库访问对象
        /// </summary>
        public static IAccessDataBase<SqlParameter> PacsYyObj
        {

            get
            {
                //1.从线程中取出 键 对应的值
                var db = CallContext.GetData("PacsYyDB") as IAccessDataBase<SqlParameter>;
                //2.如果为空（线程中不存在）
                if (db == null)
                {
                    //3.实例化 数据库
                    db = new MssqlService(ConnectionString.PacsYyConnStr);
                    //4.并存入线程
                    CallContext.SetData("PacsYyDB", db);
                }
                //5.返回数据库对象
                return db;
            }
        }
        /// <summary>
        /// DataV数据库对象初始化
        /// </summary>
        public static IAccessDataBase<OracleParameter> MbeaconObj
        {

            get
            {
                //1.从线程中取出 键 对应的值
                var db = CallContext.GetData("MbeaconDB") as IAccessDataBase<OracleParameter>;
                //2.如果为空（线程中不存在）
                if (db == null)
                {
                    //3.实例化 数据库
                    db = new OracleService(ConnectionString.MbeaconConnStr);
                    //4.并存入线程
                    CallContext.SetData("MbeaconDB", db);
                }
                //5.返回数据库对象
                return db;
            }
        }

    }
}

然后项目中使用时就很方便了，通过DBFactory类，就可以拿到各个系统的数据可访问对象了，通过对象就可以操作数据的增、删、改、查了。