.net core连接dm达梦数据库

背景

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

环境

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

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<bool> 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<bool> 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<int> 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<int> 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<int> 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<int> 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<object> 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<int> 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<int> 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<object> 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 GetList()
 {
 var list = new List();
 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;
 }
 }

需要注意达梦数据库的参数是用冒号作为前缀的。另外数据表和字段的名字建议全部使用大写字母，单词之间使用下划线分隔，也就是蛇形命名法。此时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<int>(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的这些方法中已经做了相关处理。
原文：https://blog.csdn.net/weixin_45566993/article/details/124270941

背景

环境

DbHelperSQL方式

Dapper方式

net core 使用 EF Code First

.net mvc分部页，.net core分部页

StackExchange.redis操作redis(net core支持)

.net core 使用session

通俗易懂，什么是.net?什么是.net Framework？什么是.net core?

asp.net core2.0 依赖注入 AddTransient与AddScoped的区别

.net core 使用 Kestrel

net core中使用cookie

net core项目结构简单分析

net core使用EF之DB First

.net core使用requestresponse下载文件下载excel等

iframe自适应高度与配合net core使用

net core启动报错Unable to configure HTTPS endpoint. No server certificate was specified

net core中使用url编码与解码操作

下载net core

net core使用依赖注入来装载EF的上下文对象