国产化之 .NET Core 操作达梦数据库DM8的两种方式

2023年7月11日下午1:39 • 技术杂谈 • 阅读 84

背景

某个项目需要实现基础软件全部国产化，其中操作系统指定银河麒麟，数据库使用达梦V8，CPU平台的范围包括x64、龙芯、飞腾、鲲鹏等。考虑到这些基础产品对.NET的支持，最终选择了.NET Core 3.1。

环境

CPU平台：x86-64 / Arm64
操作系统：银河麒麟 v4
数据库：DM8
.NET：.NET Core 3.1

SDK

达梦自己提供了.NET操作其数据库的SDK，可以通过NuGet安装，也可以通过安装达梦数据库获取。因为NuGet上的版本不知道是谁提供的，所以这里以安装数据库获取相关SDK为例。

在官网下载DM8的数据库安装文件：https://www.dameng.com/list_103.html

下载前需要先登录，随便注册一个帐号就好了。

这里需要选择CPU和操作系统，按照你的开发环境选择即可，下载后按照提示安装。

这里以Windows10为例，安装后SDK文件的位置在：C:\dmdbms\drivers\dotNet

这里边有EF的SDK，也有NHibernate的SDK，不过这篇文章只使用最基础的基于ADO.NET的SDK。

这些SDK在文件夹DmProvider下边，这里还提供了一个Nuget包，可以放到自己的Nuget仓库中，方便内部安装。

可以看到，这个SDK可以支持.NET Core2.0以上的所有.NET版本。

操作数据库

这里提供两种方式：传统的DbHelperSQL方式和 Dapper 方式。

DbHelperSQL方式

这种方式早年用的比较多，现在还有很多项目在使用，通过定义一组工具方法包装对数据库的各种增删改查操作。下面给出代码：

    public class DmDbClient
    {
        private string connectionString = string.Empty;

        ///
        /// 初始化DMClient的一个新实例
        ///
        ///
        public DmDbClient(string str)
        {
            connectionString = str;
        }

        #region 通用快捷方法
        ///
        /// 执行一条SQL语句，确定记录是否存在
        ///
        /// SQL查询语句
        ///
        public bool Exists(string sql)
        {
            object obj = GetSingle(sql);

            int cmdresult;
            if (Equals(obj, null) || Equals(obj, DBNull.Value))
            {
                cmdresult = 0;
            }
            else
            {
                cmdresult = int.Parse(obj.ToString());
            }

            return cmdresult > 0;
        }

        ///
        /// 执行一条SQL语句，确定记录是否存在
        ///
        /// SQL查询语句
        ///
        public async Task ExistsAsync(string sql)
        {
            object obj = await GetSingleAsync(sql);

            int cmdresult;
            if (Equals(obj, null) || Equals(obj, DBNull.Value))
            {
                cmdresult = 0;
            }
            else
            {
                cmdresult = int.Parse(obj.ToString());
            }

            return cmdresult > 0;
        }

        ///
        /// 执行一条SQL语句，确定记录是否存在
        ///
        /// SQL查询语句
        /// SQL参数数组
        ///
        public bool Exists(string sql, params DmParameter[] paras)
        {
            object obj = GetSingle(sql, paras);

            int cmdresult;
            if ((object.Equals(obj, null)) || (object.Equals(obj, DBNull.Value)))
            {
                cmdresult = 0;
            }
            else
            {
                cmdresult = int.Parse(obj.ToString());
            }

            return cmdresult > 0;
        }

        ///
        /// 执行一条SQL语句，确定记录是否存在
        ///
        /// SQL查询语句
        /// SQL参数数组
        ///
        public async Task ExistsAsync(string sql, params DmParameter[] paras)
        {
            object obj = await GetSingleAsync(sql, paras);

            int cmdresult;
            if ((object.Equals(obj, null)) || (object.Equals(obj, DBNull.Value)))
            {
                cmdresult = 0;
            }
            else
            {
                cmdresult = int.Parse(obj.ToString());
            }

            return cmdresult > 0;
        }

        ///
        /// 获取记录条数
        ///
        /// 表名
        /// 查询条件
        ///
        public int GetCount(string tableName, string sqlCondition)
        {
            string sql = "select count(1) from " + tableName + "";

            if (!string.IsNullOrWhiteSpace(sqlCondition))
            {
                sql += " where " + sqlCondition;
            }

            object result = GetSingle(sql);

            if (result != null)
            {
                return Convert.ToInt32(result);
            }
            else
            {
                return 0;
            }
        }

        ///
        /// 获取记录条数
        ///
        /// 表名
        /// 查询条件
        ///
        public async Task GetCountAsync(string tableName, string sqlCondition)
        {
            string sql = "select count(1) from " + tableName + "";

            if (!string.IsNullOrWhiteSpace(sqlCondition))
            {
                sql += " where " + sqlCondition;
            }

            object result = await GetSingleAsync(sql);

            if (result != null)
            {
                return Convert.ToInt32(result);
            }
            else
            {
                return 0;
            }
        }

        ///
        /// 获取记录条数
        ///
        /// 表名
        /// 查询条件
        /// SQL参数数组
        ///
        public int GetCount(string tableName, string sqlCondition, DmParameter[] paras)
        {
            string sql = "select count(1) from " + tableName + "";

            if (!string.IsNullOrWhiteSpace(sqlCondition))
            {
                sql += " where " + sqlCondition;
            }

            object result = GetSingle(sql, paras);

            if (result != null)
            {
                return Convert.ToInt32(result);
            }
            else
            {
                return 0;
            }
        }

        ///
        /// 获取记录条数
        ///
        /// 表名
        /// 查询条件
        /// SQL参数数组
        ///
        public async Task GetCountAsync(string tableName, string sqlCondition, DmParameter[] paras)
        {
            string sql = "select count(1) from " + tableName + "";

            if (!string.IsNullOrWhiteSpace(sqlCondition))
            {
                sql += " where " + sqlCondition;
            }

            object result = await GetSingleAsync(sql, paras);

            if (result != null)
            {
                return Convert.ToInt32(result);
            }
            else
            {
                return 0;
            }
        }

        #endregion 通用快捷方法

        #region 执行简单SQL语句

        ///
        /// 执行SQL语句，返回影响的记录数
        ///
        /// SQL语句
        /// 影响的记录数
        public int ExecuteSql(string sql)
        {
            using (DmConnection connection = new DmConnection(connectionString))
            {
                using (DmCommand cmd = new DmCommand(sql, connection))
                {
                    connection.Open();
                    int rows = cmd.ExecuteNonQuery();
                    return rows;
                }
            }
        }

        ///
        /// 执行SQL语句，返回影响的记录数
        ///
        /// SQL语句
        /// 影响的记录数
        public async Task ExecuteSqlAsync(string sql)
        {
            using (DmConnection connection = new DmConnection(connectionString))
            {
                using (DmCommand cmd = new DmCommand(sql, connection))
                {
                    await connection.OpenAsync();
                    int rows = await cmd.ExecuteNonQueryAsync();
                    return rows;
                }
            }
        }

        ///
        /// 执行SQL语句，返回影响的记录数（可自定义超时时间）
        ///
        /// SQL语句
        /// 执行超时时间
        /// 影响的记录数
        public int ExecuteSqlByTime(string sql, int timeout)
        {
            using (DmConnection connection = new DmConnection(this.connectionString))
            {
                using (DmCommand cmd = new DmCommand(sql, connection))
                {
                    connection.Open();
                    cmd.CommandTimeout = timeout;
                    int rows = cmd.ExecuteNonQuery();
                    return rows;
                }
            }
        }

        ///
        /// 执行SQL语句，返回影响的记录数（可自定义超时时间）
        ///
        /// SQL语句
        /// 执行超时时间
        /// 影响的记录数
        public async Task ExecuteSqlByTimeAsync(string sql, int timeout)
        {
            using (DmConnection connection = new DmConnection(this.connectionString))
            {
                using (DmCommand cmd = new DmCommand(sql, connection))
                {
                    await connection.OpenAsync();
                    cmd.CommandTimeout = timeout;
                    int rows = await cmd.ExecuteNonQueryAsync();
                    return rows;
                }
            }
        }

        ///
        /// 执行多条SQL语句，实现数据库事务。
        ///
        /// 多条SQL语句
        public void ExecuteSqlTrans(ArrayList sqlList)
        {
            using (DmConnection conn = new DmConnection(connectionString))
            {
                conn.Open();
                using (DbTransaction trans = conn.BeginTransaction())
                {
                    using (DmCommand cmd = new DmCommand())
                    {
                        cmd.Connection = conn;
                        cmd.Transaction = trans;

                        try
                        {
                            for (int n = 0; n < sqlList.Count; n++)
                            {
                                string sql = sqlList[n].ToString();

                                if (sql.Trim().Length > 1)
                                {
                                    cmd.CommandText = sql;
                                    cmd.ExecuteNonQuery();
                                }
                            }

                            trans.Commit();
                        }
                        catch (DmException ex)
                        {
                            trans.Rollback();
                            throw ex;
                        }
                    }
                }
            }
        }

        ///
        /// 执行多条SQL语句，实现数据库事务。
        ///
        /// 多条SQL语句
        public async Task ExecuteSqlTransAsync(ArrayList sqlList)
        {
            using (DmConnection conn = new DmConnection(connectionString))
            {
                await conn.OpenAsync();
                using (DbTransaction trans = await conn.BeginTransactionAsync())
                {
                    using (DmCommand cmd = new DmCommand())
                    {
                        cmd.Connection = conn;
                        cmd.Transaction = trans;

                        try
                        {
                            for (int n = 0; n < sqlList.Count; n++)
                            {
                                string sql = sqlList[n].ToString();

                                if (sql.Trim().Length > 1)
                                {
                                    cmd.CommandText = sql;
                                    await cmd.ExecuteNonQueryAsync();
                                }
                            }

                            trans.Commit();
                        }
                        catch (DmException ex)
                        {
                            trans.Rollback();
                            throw ex;
                        }
                    }
                }
            }
        }

        ///
        /// 执行一条SQL查询语句，返回查询结果。
        ///
        /// SQL查询语句
        /// 查询结果
        public object GetSingle(string sql)
        {
            using (DmConnection connection = new DmConnection(connectionString))
            {
                using (DmCommand cmd = new DmCommand(sql, connection))
                {
                    connection.Open();

                    object obj = cmd.ExecuteScalar();

                    if ((object.Equals(obj, null)) || (object.Equals(obj, DBNull.Value)))
                    {
                        return null;
                    }
                    else
                    {
                        return obj;
                    }
                }
            }
        }

        ///
        /// 执行一条SQL查询语句，返回查询结果。
        ///
        /// SQL查询语句
        /// 查询结果
        public async Task GetSingleAsync(string sql)
        {
            using (DmConnection connection = new DmConnection(connectionString))
            {
                using (DmCommand cmd = new DmCommand(sql, connection))
                {
                    await connection.OpenAsync();

                    object obj = await cmd.ExecuteScalarAsync();

                    if ((object.Equals(obj, null)) || (object.Equals(obj, DBNull.Value)))
                    {
                        return null;
                    }
                    else
                    {
                        return obj;
                    }
                }
            }
        }

        ///
        /// 执行查询语句，返回DbDataReader（切记要手工关闭DbDataReader）
        ///
        /// 查询语句
        /// DmDataReader
        public DbDataReader ExecuteReader(string sql)
        {
            DmConnection connection = new DmConnection(connectionString);
            DmCommand cmd = new DmCommand(sql, connection);

            connection.Open();
            return cmd.ExecuteReader();
        }

        ///
        /// 执行查询语句，返回DbDataReader（切记要手工关闭DbDataReader）
        ///
        /// 查询语句
        /// DmDataReader
        public async Task ExecuteReaderAsync(string sql)
        {
            DmConnection connection = new DmConnection(connectionString);
            DmCommand cmd = new DmCommand(sql, connection);

            await connection.OpenAsync();
            return await cmd.ExecuteReaderAsync();
        }

        ///
        /// 执行查询语句，返回DataSet
        ///
        /// 查询语句
        /// DataSet
        public DataSet Query(string sql)
        {
            using (DmConnection connection = new DmConnection(connectionString))
            {
                using (DmDataAdapter command = new DmDataAdapter(sql, connection))
                {
                    DataSet ds = new DataSet();

                    connection.Open();
                    command.Fill(ds, "ds");

                    return ds;
                }
            }
        }

        ///
        /// 执行查询语句，返回DataSet（可自定义超时时间）
        ///
        ///
        ///
        ///
        public DataSet Query(string sql, int timeout)
        {
            using (DmConnection connection = new DmConnection(connectionString))
            {
                using (DmDataAdapter command = new DmDataAdapter(sql, connection))
                {
                    DataSet ds = new DataSet();

                    connection.Open();
                    command.SelectCommand.CommandTimeout = timeout;
                    command.Fill(ds, "ds");

                    return ds;
                }
            }
        }
        #endregion 执行简单SQL语句

        #region 执行带参数的SQL语句

        ///
        /// 执行SQL语句，返回影响的记录数
        ///
        /// SQL语句
        /// SQL参数数组
        /// 影响的记录数
        public int ExecuteSql(string sql, params DmParameter[] paras)
        {
            using (DmConnection connection = new DmConnection(connectionString))
            {
                using (DmCommand cmd = new DmCommand())
                {
                    PrepareCommand(cmd, connection, null, sql, paras);
                    int rows = cmd.ExecuteNonQuery();
                    cmd.Parameters.Clear();
                    return rows;
                }
            }
        }

        ///
        /// 执行SQL语句，返回影响的记录数
        ///
        /// SQL语句
        /// SQL参数数组
        /// 影响的记录数
        public async Task ExecuteSqlAsync(string sql, params DmParameter[] paras)
        {
            using (DmConnection connection = new DmConnection(connectionString))
            {
                using (DmCommand cmd = new DmCommand())
                {
                    await PrepareCommandAsync(cmd, connection, null, sql, paras);
                    int rows = await cmd.ExecuteNonQueryAsync();
                    cmd.Parameters.Clear();
                    return rows;
                }
            }
        }

        ///
        /// 执行添加SQL语句，返回记录的ID（自动产生的自增主键）
        ///
        /// SQL语句
        /// SQL参数
        /// 记录的ID
        public int ExecuteAdd(string sql, params DmParameter[] parms)
        {
            sql = sql + ";Select @@IDENTITY";

            using (DmConnection connection = new DmConnection(connectionString))
            {
                using (DmCommand cmd = new DmCommand())
                {
                    PrepareCommand(cmd, connection, null, sql, parms);
                    int recordID = Int32.Parse(cmd.ExecuteScalar().ToString());
                    cmd.Parameters.Clear();

                    return recordID;
                }
            }
        }

        ///
        /// 执行添加SQL语句，返回记录的ID（自动产生的自增主键）
        ///
        /// SQL语句
        /// SQL参数
        /// 记录的ID
        public async Task ExecuteAddAsync(string sql, params DmParameter[] parms)
        {
            sql = sql + ";select @@identity as newautoid";

            using (DmConnection connection = new DmConnection(connectionString))
            {
                using (DmCommand cmd = new DmCommand())
                {
                    await PrepareCommandAsync(cmd, connection, null, sql, parms);

                    int recordID;
                    try
                    {
                        recordID = int.Parse((await cmd.ExecuteScalarAsync()).ToString());
                    }
                    catch
                    {
                        recordID = -1;
                    }

                    cmd.Parameters.Clear();

                    return recordID;
                }
            }
        }

        ///
        /// 执行多条SQL语句，实现数据库事务。
        ///
        /// SQL语句的哈希表（key为sql语句，value是该语句的DmParameter[]）
        public void ExecuteSqlTrans(Hashtable sqlList)
        {
            using (DmConnection conn = new DmConnection(connectionString))
            {
                conn.Open();
                using (DbTransaction trans = conn.BeginTransaction())
                {
                    using (DmCommand cmd = new DmCommand())
                    {
                        try
                        {
                            foreach (DictionaryEntry entry in sqlList)
                            {
                                var sql = entry.Key.ToString();
                                var paras = (DmParameter[])entry.Value;

                                PrepareCommand(cmd, conn, trans, sql, paras);

                                int val = cmd.ExecuteNonQuery();

                                cmd.Parameters.Clear();
                            }

                            trans.Commit();
                        }
                        catch (DmException ex)
                        {
                            trans.Rollback();
                            throw ex;
                        }
                    }
                }
            }
        }

        ///
        /// 执行多条SQL语句，实现数据库事务。
        ///
        /// SQL语句的哈希表（key为sql语句，value是该语句的DmParameter[]）
        public async Task ExecuteSqlTransAsync(Hashtable sqlList)
        {
            using (DmConnection conn = new DmConnection(connectionString))
            {
                await conn.OpenAsync();
                using (DbTransaction trans = conn.BeginTransaction())
                {
                    using (DmCommand cmd = new DmCommand())
                    {
                        try
                        {
                            foreach (DictionaryEntry entry in sqlList)
                            {
                                var sql = entry.Key.ToString();
                                var paras = (DmParameter[])entry.Value;

                                await PrepareCommandAsync(cmd, conn, trans, sql, paras);

                                int val = await cmd.ExecuteNonQueryAsync();

                                cmd.Parameters.Clear();
                            }

                            trans.Commit();
                        }
                        catch (DmException ex)
                        {
                            trans.Rollback();
                            throw ex;
                        }
                    }
                }
            }
        }

        ///
        /// 执行一条计算查询结果语句，返回查询结果。
        ///
        /// SQL语句
        /// SQL参数
        /// 查询结果
        public object GetSingle(string sql, params DmParameter[] parms)
        {
            using (DmConnection conn = new DmConnection(connectionString))
            {
                using (DmCommand cmd = new DmCommand())
                {
                    PrepareCommand(cmd, conn, null, sql, parms);

                    object obj = cmd.ExecuteScalar();
                    cmd.Parameters.Clear();

                    if ((object.Equals(obj, null)) || (object.Equals(obj, DBNull.Value)))
                    {
                        return null;
                    }
                    else
                    {
                        return obj;
                    }
                }
            }
        }

        ///
        /// 执行一条计算查询结果语句，返回查询结果。
        ///
        /// SQL语句
        /// SQL参数
        /// 查询结果
        public async Task GetSingleAsync(string sql, params DmParameter[] parms)
        {
            using (DmConnection conn = new DmConnection(connectionString))
            {
                using (DmCommand cmd = new DmCommand())
                {
                    await PrepareCommandAsync(cmd, conn, null, sql, parms);

                    object obj = await cmd.ExecuteScalarAsync();
                    cmd.Parameters.Clear();

                    if ((object.Equals(obj, null)) || (object.Equals(obj, DBNull.Value)))
                    {
                        return null;
                    }
                    else
                    {
                        return obj;
                    }
                }
            }
        }

        ///
        /// 执行查询语句，返回DmDataReader (切记要手工关闭DmDataReader)
        ///
        /// 查询语句
        /// SQL参数
        /// DmDataReader
        public DbDataReader ExecuteReader(string sql, params DmParameter[] parms)
        {
            DmConnection connection = new DmConnection(connectionString);
            DmCommand cmd = new DmCommand();

            PrepareCommand(cmd, connection, null, sql, parms);

            DbDataReader myReader = cmd.ExecuteReader();
            cmd.Parameters.Clear();

            return myReader;
        }

        ///
        /// 执行查询语句，返回DmDataReader (切记要手工关闭DmDataReader)
        ///
        /// 查询语句
        /// SQL参数
        /// DmDataReader
        public async Task ExecuteReaderAsync(string sql, params DmParameter[] parms)
        {
            DmConnection connection = new DmConnection(connectionString);
            DmCommand cmd = new DmCommand();

            await PrepareCommandAsync(cmd, connection, null, sql, parms);

            var myReader = await cmd.ExecuteReaderAsync();
            cmd.Parameters.Clear();
            return myReader;
        }

        ///
        /// 执行查询语句，返回DataSet
        ///
        /// 查询语句
        /// 参数数组
        /// DataSet
        public DataSet Query(string sql, params DmParameter[] paras)
        {
            using (DmConnection connection = new DmConnection(connectionString))
            {
                using (DmCommand cmd = new DmCommand())
                {
                    PrepareCommand(cmd, connection, null, sql, paras);
                    DataSet ds = new DataSet();

                    using (DmDataAdapter da = new DmDataAdapter(cmd))
                    {
                        da.Fill(ds, "ds");
                        cmd.Parameters.Clear();

                        return ds;
                    }
                }
            }
        }

        ///
        /// 准备SQL查询命令
        ///
        /// SQL命令对象
        /// SQL连接对象
        /// SQL事务对象
        /// SQL语句
        /// SQL参数数组
        private void PrepareCommand(DmCommand cmd, DmConnection conn, DbTransaction trans, string cmdText, DmParameter[] paras)
        {
            if (conn.State != ConnectionState.Open)
            {
                conn.Open();
            }

            cmd.Connection = conn;
            cmd.CommandText = cmdText;

            if (trans != null)
            {
                cmd.Transaction = trans;
            }

            cmd.CommandType = CommandType.Text;
            if (paras != null)
            {
                foreach (DmParameter parameter in paras)
                {
                    if ((parameter.Direction == ParameterDirection.InputOutput || parameter.Direction == ParameterDirection.Input) &&
                        (parameter.Value == null))
                    {
                        parameter.Value = DBNull.Value;
                    }
                    cmd.Parameters.Add(parameter);
                }
            }
        }

        ///
        /// 准备SQL查询命令
        ///
        /// SQL命令对象
        /// SQL连接对象
        /// SQL事务对象
        /// SQL语句
        /// SQL参数数组
        private async Task PrepareCommandAsync(DmCommand cmd, DmConnection conn, DbTransaction trans, string cmdText, DmParameter[] paras)
        {
            if (conn.State != ConnectionState.Open)
            {
                await conn.OpenAsync();
            }

            cmd.Connection = conn;
            cmd.CommandText = cmdText;

            if (trans != null)
            {
                cmd.Transaction = trans;
            }

            cmd.CommandType = CommandType.Text;
            if (paras != null)
            {
                foreach (DmParameter parameter in paras)
                {
                    if ((parameter.Direction == ParameterDirection.InputOutput || parameter.Direction == ParameterDirection.Input) &&
                        (parameter.Value == null))
                    {
                        parameter.Value = DBNull.Value;
                    }
                    cmd.Parameters.Add(parameter);
                }
            }
        }

        #endregion 执行带参数的SQL语句
    }

使用方法也很简单，传入SQL语句和参数即可。这里给出几个增删改查的例子：

    public class PersonAdoNetDAL : IPersonDAL
    {
        static readonly DmDbClient _client = new DmDbClient("Server=127.0.0.1; UserId=TESTDB; PWD=1234567");

        public int Add(PersonModel model)
        {
            string sql = "insert into Person(Name,City) Values(:Name,:City)";
            DmParameter[] paras = new DmParameter[] {
                new DmParameter(":Name",model.Name),
                new DmParameter(":City",model.City)
            };

            return _client.ExecuteAdd(sql, paras);
        }

        public bool Update(PersonModel model)
        {
            string sql = "update Person set City=:City where Id=:Id";
            DmParameter[] paras = new DmParameter[] {
                new DmParameter(":Id",model.Id),
                new DmParameter(":City",model.City)
            };

            return _client.ExecuteSql(sql, paras) > 0 ? true : false;
        }

        public bool Delete(int id)
        {
            string sql = "delete from Person where Id=:Id";
            DmParameter[] paras = new DmParameter[] {
                new DmParameter(":Id",id),
            };

            return _client.ExecuteSql(sql, paras) > 0 ? true : false;
        }

        public PersonModel Get(int id)
        {
            string sql = "select Id,Name,City from Person where Id=:Id";
            DmParameter[] paras = new DmParameter[] {
                new DmParameter(":Id",id),
            };

            PersonModel model = null;
            using (var reader = (DmDataReader)_client.ExecuteReader(sql, paras))
            {
                while (reader.Read())
                {
                    model = new PersonModel();
                    model.Id = reader.GetInt32(0);
                    model.Name = reader.GetString(1);
                    model.City = reader.GetString(2);
                }
            }

            return model;
        }

        public List<personmodel> GetList()
        {
            var list = new List<personmodel>();
            using (var reader = (DmDataReader)_client.ExecuteReader("select Id,Name,City from Person"))
            {
                while (reader.Read())
                {
                    var model = new PersonModel();
                    model.Id = reader.GetInt32(0);
                    model.Name = reader.GetString(1);
                    model.City = reader.GetString(2);
                    list.Add(model);
                }
            }

            return list;
        }

    }
</personmodel></personmodel>

需要注意达梦数据库的参数是用冒号作为前缀的。另外数据表和字段的名字建议全部使用大写字母，单词之间使用下划线分隔，也就是蛇形命名法。此时SQL语句就不用关心大小写了，怎么写都行。

Dapper方式

Dapper是一个轻量级的ORM框架，现在使用的也很广泛，可以简化代码编写。因为Dapper扩展的IDbConnection，这是ADO.NET中的东西，我们使用的DmProvider也是实现了ADO.NET相关接口，所以Dapper可以通过DmProvider操作达梦数据库。

首先定义一个获取数据库连接对象的工厂类：

    public class DmConnectionFactory
    {
        static string sqlConnString = "Server=127.0.0.1; UserId=TESTDB; PWD=123456";
        public static IDbConnection GetConn()
        {
            return new DmConnection(sqlConnString);
        }
    }

然后就可以使用它执行SQL语句了：

   public class PersonDapperDAL : IPersonDAL
    {
        public PersonDapperDAL()
        {
        }

        public PersonModel Get(int id)
        {
            string sql = "select Id,Name,City from Person where Id=:Id";
            return DmConnectionFactory.GetConn().QueryFirstOrDefault(sql, new { Id = id });
        }

        public List GetList()
        {
            string sql = "select Id,Name,City from Person";
            return DmConnectionFactory.GetConn().Query(sql).ToList();
        }

        public int Add(PersonModel model)
        {
            string sql = "insert into Person(Name,City) Values(:Name,:City);Select @@IDENTITY";
            return DmConnectionFactory.GetConn().QuerySingle(sql, model);
        }

        public bool Update(PersonModel model)
        {
            string sql = "update Person set City=:City where Id=:Id";
            int result = DmConnectionFactory.GetConn().Execute(sql, model);
            return result > 0;
        }

        public bool Delete(int id)
        {
            string sql = "delete from Person where Id=:Id";
            int result = DmConnectionFactory.GetConn().Execute(sql, new { Id = id });
            return result > 0;
        }
    }

Query、Execute这些方法都是Dapper定义的，可以看到能够少写很多代码。这里也不用打开连接、关闭连接，也不用写using，因为Dapper的这些方法中已经做了相关处理。

好了，以上就是本文的主要内容。如有错漏欢迎指正。

收获更多架构知识，请关注微信公众号萤火架构。原创内容，转载请注明出处。

Original: https://www.cnblogs.com/bossma/p/16163640.html
Author: 波斯马
Title: 国产化之 .NET Core 操作达梦数据库DM8的两种方式

原创文章受到原创版权保护。转载请注明出处：https://www.johngo689.com/685465/

转载文章受原作者版权保护。转载请注明原作者出处！

技术杂谈

【自取】最近整理的，有需要可以领取学习：

Linux核心资料大放送~

全栈面试题汇总（持续更新&可下载）

一个提高学习100%效率的工具！

【超详细】深度学习面试题目！

LeetCode Python刷题答案下载！

LeetCode Java版刷题答案下载！

LeetCode C++ 版本，抓紧保存！

LeetCode GO语言刷题答案下载！

Android：hook很“危险”，使用需谨慎。

前言上篇文章《Android安卓进阶技术分享之AGP工作原理》和大家分析了 AGP(Android Gradle Plugin) 做了哪些事，了解到 AGP 就是为打包这个过程服…

技术杂谈 2023年7月10日
00101
log4j 不同模块输出到不同的文件

1、实现目标不同业务的日志信息需要打印到不同的文件中，每天或者每个小时生成一个文件。如，注册的信息打印到register.log，每天凌晨生成一个register-年月日.log…

技术杂谈 2023年5月31日
0098
深入C++03：面向对象

📕面向对象类和对象、this指针不用做太多笔记，都可以看初识C++的笔记；记住👀：声明后面都要加” ；“，比如声明方法和变量还有…

技术杂谈 2023年7月25日
0075
【赵渝强老师】阿里云大数据ACP认证之阿里大数据产品体系

阿里大数据产品体系是基于阿里云飞天平台上的数据处理服务。主要分为阿里云大数据基础产品和阿里云数加平台，其产品架构图如下所示：一、阿里云大数据基础产品 1、云数据库——RDS（…

技术杂谈 2023年7月24日
0090
Java中的运算符

短路 1.true || 2.true || 3.false || 4.true其中走完1表达式就不会再走了节省了不必要的计算 1.true && 2.tru…

技术杂谈 2023年7月24日
0068
HelloWorld小程序

第一步在文件夹里鼠标右键新建文本文档更改文件的后缀为java 注意事项:如果你的后缀没有出现,可以进行如下操作第二步编写代码记得写完Ctrl+s保存一下第三步编译…

技术杂谈 2023年7月24日
0083
Apache APISIX云原生网关介绍

Apache APISIX介绍 API网关的需求两个基本功能，突出了对API的需求，即普通网络服务器无法提供的东西。 1)复杂的速率限制如果支付了订阅费用，可能会访问一个有常规内…

技术杂谈 2023年6月1日
00102
使用模板来解决接口继承问题

一.定义2个有继承关系的接口 struct IA { virtual void Test1()=0; }; struct IB:public IA { virtual void T…

技术杂谈 2023年5月31日
0067
wasm示例 js canvas 动画示例

3d迷宫移动：https://developer.mozilla.org/en-US/docs/Web/API/Canvas_API/A_basic_ray-caster C:\d…

技术杂谈 2023年5月31日
0092
初步体验 Kubernetes 的 Custom Resource Definition

CRD(Custom Resource Definition) 是 kubernetes 强大扩展能力的一处体现，联系到编程场景，CRD 相当于是类(class)，custom r…

技术杂谈 2023年5月31日
00105
Nightingale 监控报警平台

Nightingale 从官方的介绍是企业版的prometheus，从功能上的确是很不错的，我们基本上可以实现基于ui 灵活的管理prometheus 的报警处理参考架构 Vic…

技术杂谈 2023年5月30日
0099
分布式系统中数据存储方案实践

数据膨胀的时候，必然放大细节。一、背景简介在项目研发的过程中，对于数据存储能力的依赖无处不在，项目初期，相比系统层面的组件选型与框架设计，由于数据体量不大，在存储管理方面通常容…

技术杂谈 2023年7月23日
0083
T 泛型转换

T为左值 result = (T)Convert.ChangeType(o,typeof(T)); Original: https://www.cnblogs.com/zfyoux…

技术杂谈 2023年5月31日
0072
NTP时钟服务器（时钟系统）在智慧教室里的应用

NTP时钟服务器（时钟系统）在智慧教室里的应用 NTP时钟服务器（时钟系统）在智慧教室里的应用 NTP时钟服务器（时钟系统）在智慧教室里的应用京准电子科技官微——ahjzsz 近…

技术杂谈 2023年6月21日
00101
回归与分类

回归与分类机器学习的主要任务便是聚焦于两个问题：回归与分类回归与分类回归的定义机器学习的过程就是寻找函数的过程，通过训练获得一个函数映射，给定函数的输入，函数会给出相应的一…

技术杂谈 2023年6月21日
0084
3. SpringBoot整合Redis

1.下载地址以及安装 https://github.com/MicrosoftArchive/redis/releases 我是安装的windows版本所以选择这个：解压之后运行…

技术杂谈 2023年7月24日
0056

2024 年 5 月
一	二	三	四	五	六	日
		1	2	3	4	5
6	7	8	9	10	11	12
13	14	15	16	17	18	19
20	21	22	23	24	25	26
27	28	29	30	31

国产化之 .NET Core 操作达梦数据库DM8的两种方式

DbHelperSQL方式

Dapper方式

大家都在看