AI导航网
微信公众号搜"智元新知"关注
微信扫一扫可直接关注哦！

轻量级ORM

分类：C#作者：秋荷雨翔原文地址

    不知道可能称的上是ORM，其实就是一个DBHelper。看到网上不少人写自己的ORM，但我觉得都不太好。

    我这个ORM，学习成本非常低，常用的方法仅有几个，在使用的过程中，你不需要有太多要注意的地方，也不会有“我怎样实现连表查询”的疑问。反射牺牲一些性能，但是降低了实现和使用的复杂度。

    支持Oracle、MSsql、MysqL、sqlite四种数据库，并配有Model生成器。

Model层的设计：

    Models目录中的类及其属性和数据库中的表和字段是完全对应的，Models全部由生成器生成，并且不允许手动修改。ExtModels目录中的类是扩展类，主要用于查询与显示，比如表中存的是code，但你需要关联查询另一张表中的name，就可以在这个扩展类中扩展一个用于显示的name字段。Models和ExtModels目录的中类都是partial修饰。

    例(由于是sqlite数据库，所以生成的Model没有注释，其它三种数据库有注释)：

Model：

using System;
 System.Collections.Generic;
 System.Linq;

namespace Models
{
    /// <summary>
    /// 
    </summary>
    [Serializable]
    public partial class BS_Template
    {
        <summary>
        /// 
                [IsId]
        [IsDBField]
        string id { get; set; }
                [IsDBField]
        string typeCode { string type { string code { string name { string path { string folder { string remarks { ; }
    }
}
View Code

ExtModel：

</summary>
     BS_Template
    {
        //暂没有扩展字段
    }
}
View Code

 

DBHelper代码：

 System.ComponentModel;
 System.Configuration;
 System.Data;
 System.Data.Common;
 System.Data.Objects.DataClasses;
 System.Data.OracleClient;
 System.Data.sqlClient;
 System.Data.sqlite;
 System.Reflection;
 System.Text;
 Models;
 MysqL.Data.MysqLClient;

 DBUtil
{
    /// 数据库操作类
     2016年09月09日
     DBHelper
    {
        #region 变量
         数据库类型
        </summary>
        private static string m_DBType = ConfigurationManager.AppSettings["DBType"];
        bool m_AutoIncrement = ConfigurationManager.AppSettings[AutoIncrement"].ToLower() == true" ? true : false;
         数据库连接字符串
        string m_ConnectionString = ConfigurationManager.ConnectionStrings[DefaultConnection].ToString();
         事务
                [ThreadStatic]
        static DbTransaction m_Tran;
         带参数的sql插入和修改语句中，参数前面的符号
        string m_ParameterMark = GetParameterMark();
        #endregion

        #region 构造函数
         数据库操作类
        public DBHelper()
        {
        }
        #region 生成变量
        #region 生成 IDbCommand
         生成 IDbCommand
        private DbCommand GetCommand()
        {
            DbCommand command = null;

            switch (m_DBType)
            {
                case oracle:
                    command = new OracleCommand();
                    break;
                mssql sqlCommand();
                    MysqL MysqLCommand();
                    sqlite sqliteCommand();
                    ;
            }

            return command;
        }
        private DbCommand GetCommand(string sql,DbConnection conn)
        {
            DbCommand command =  OracleCommand(sql);
                    command.Connection = conn;
                     sqlCommand(sql);
                    command.Connection = MysqLCommand(sql);
                    command.Connection = sqliteCommand(sql);
                    command.Connection = command;
        }
        #region 生成 IDbConnection
         生成 IDbConnection
         DbConnection GetConnection()
        {
            DbConnection conn = :
                    conn =  OracleConnection(m_ConnectionString);
                     sqlConnection(m_ConnectionString);
                     MysqLConnection(m_ConnectionString);
                     sqliteConnection(m_ConnectionString);
                     conn;
        }
        #region 生成 IDbDataAdapter
         生成 IDbDataAdapter
         DbDataAdapter GetDataAdapter(DbCommand cmd)
        {
            DbDataAdapter dataAdapter = :
                    dataAdapter =  OracleDataAdapter();
                    dataAdapter.SelectCommand = cmd;
                     sqlDataAdapter();
                    dataAdapter.SelectCommand = MysqLDataAdapter();
                    dataAdapter.SelectCommand = sqliteDataAdapter();
                    dataAdapter.SelectCommand = dataAdapter;
        }
        #region 生成 m_ParameterMark
         生成 m_ParameterMark
         GetParameterMark()
        {
            :
                    return :@;
            }
            ;
        }
        #region 生成 DbParameter
         生成 DbParameter
        private DbParameter GetDbParameter(string name,object value)
        {
            DbParameter dbParameter = :
                    dbParameter =  OracleParameter(name,value);
                     sqlParameter(name,1)"> MysqLParameter(name,1)"> sqliteParameter(name,1)"> dbParameter;
        }
        #endregion
        #region 基础方法
        #region  执行简单sql语句
        #region Exists
        bool Exists( sqlString)
        {
            using (DbConnection conn = GetConnection())
            {
                using (DbCommand cmd = GetCommand(sqlString,conn))
                {
                    try
                    {
                        conn.open();
                        object obj = cmd.ExecuteScalar();
                        if ((Object.Equals(obj,1)">null)) || (Object.Equals(obj,System.dbnull.Value)))
                        {
                            return ;
                        }
                        else
                        {
                            true;
                        }
                    }
                    catch (Exception ex)
                    {
                        throw ex;
                    }
                    finally
                    {
                        cmd.dispose();
                        conn.Close();
                    }
                }
            }
        }
        #region 执行sql语句，返回影响的记录数
         执行sql语句，返回影响的记录数
        </summary>
        <param name="sqlString">sql语句</param>
        <returns>影响的记录数</returns>
        int Executesql( sqlString)
        {
            DbConnection conn = m_Tran == null ? GetConnection() : m_Tran.Connection;
            
                {
                    if (conn.State != ConnectionState.Open) conn.open();
                    if (m_Tran != null) cmd.Transaction = m_Tran;
                    int rows = cmd.ExecuteNonQuery();
                     rows;
                }
                 (Exception ex)
                {
                    throw  Exception(ex.Message);
                }
                
                {
                    cmd.dispose();
                    if (m_Tran == ) conn.Close();
                }
            }
        }
        #region 执行一条计算查询结果语句，返回查询结果
         执行一条计算查询结果语句，返回查询结果（object）
        计算查询结果语句查询结果（object）object GetSingle(
                    {
                         ConnectionState.Open) conn.open();
                         obj;
                        }
                    }
                    
                    {
                        cmd.dispose();
                    }
                }
            }
        }
        #region 执行查询语句，返回IDataReader
         执行查询语句，返回IDataReader ( 注意：调用该方法后，一定要对IDataReader进行Close )
        查询语句IDataReaderpublic DbDataReader ExecuteReader( sqlString)
        {
            DbConnection conn = GetConnection();
            DbCommand cmd =
            {
                 ConnectionState.Open) conn.open();
                DbDataReader myReader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
                 myReader;
            }
             (Exception ex)
            {
                 ex;
            }
        }
        #region 执行查询语句，返回DataSet
         执行查询语句，返回DataSet
        DataSetpublic DataSet Query( GetConnection())
            {
                DataSet ds =  DataSet();
                
                {
                    conn.open();
                     GetDataAdapter(cmd);
                        adapter.Fill(ds,ds);
                    }
                }
                 ex;
                }
                
                {
                    conn.Close();
                }
                 ds;
            }
        }
        #region 执行带参数的sql语句
        <param name="sqlString">string sqlString,1)">params DbParameter[] cmdParms)
        {
            DbConnection conn = m_Tran ==  GetCommand())
            {
                
                {
                    PrepareCommand(cmd,conn,m_Tran,sqlString,cmdParms);
                     cmd.ExecuteNonQuery();
                    cmd.Parameters.Clear();
                    <param name="strsql">string sqlString,1)"> DbParameter[] cmdParms)
        {
            DbConnection conn = GetCommand();
            
            {
                PrepareCommand(cmd,,sqlString,cmdParms);
                DbDataReader myReader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
                cmd.Parameters.Clear();
                 ex;
            }

        }
         GetCommand();
            PrepareCommand(cmd,cmdParms);
            using (DbDataAdapter da = GetDataAdapter(cmd))
            {
                DataSet ds = 
                {
                    da.Fill(ds,1)">);
                    cmd.Parameters.Clear();
                }
                
                {
                    cmd.dispose();
                    conn.Close();
                }
                #region PrepareCommand
        void PrepareCommand(DbCommand cmd,DbConnection conn,DbTransaction trans,1)"> cmdText,DbParameter[] cmdParms)
        {
             ConnectionState.Open) conn.open();
            cmd.Connection = conn;
            cmd.CommandText = cmdText;
            if (trans !=  trans;
            cmd.CommandType = CommandType.Text;
            if (cmdParms != )
            {
                foreach (DbParameter parm in cmdParms)
                {
                    cmd.Parameters.Add(parm);
                }
            }
        }
        #region 增删改查
        #region 获取最大编号
         获取最大编号
        <typeparam name="T">实体Model</typeparam>
        <param name="key">主键</param>
        int GetMaxID<T>( key)
        {
            Type type = typeof(T);

            string sql = ;
            :
                    sql = string.Format(SELECT Max({0}) FROM {1}SELECT Max(cast({0} as int)) FROM {1}using (IDbCommand cmd = GetCommand(sql,1)">1int.Parse(obj.ToString()) + #region 添加
         添加
        void Insert( obj)
        {
            Insert(obj,m_AutoIncrement);
        }
        object obj,1)">bool autoIncrement)
        {
            StringBuilder strsql =  StringBuilder();
            Type type = obj.GetType();
            strsql.Append(insert into {0}( GetEntityProperties(type);
            List<string> propertyNameList = new List<string>();
            int savedCount = 0foreach (PropertyInfo propertyInfo  propertyInfoList)
            {
                if (propertyInfo.GetCustomAttributes(typeof(IsIdAttribute),1)">false).Length > 0 && autoIncrement) typeof(IsDBFieldAttribute),1)">)
                {
                    propertyNameList.Add(propertyInfo.Name);
                    savedCount++;
                }
            }

            strsql.Append({0})",1)">string.Join(sql.Append( values ({0})string>(a => m_ParameterMark + a).ToArray())));
            DbParameter[] parameters =  DbParameter[savedCount];
            int k = for (int i = 0; i < propertyInfoList.Length && savedCount > 0; i++)
            {
                PropertyInfo propertyInfo = propertyInfoList[i];
                )
                {
                    object val = propertyInfo.GetValue(obj,1)">);
                    DbParameter param = GetDbParameter(m_ParameterMark + propertyInfo.Name,val ==  dbnull.Value : val);
                    parameters[k++] = param;
                }
            }

            Executesql(strsql.ToString(),parameters);
        }
        #region 修改
         修改
        void Update( obj)
        {
            object oldobj = Find(obj,1)">);
            if (oldobj == null) new Exception(无法获取到旧数据);

            StringBuilder strsql = update {0} object oldVal = propertyInfo.GetValue(oldobj,1)">);
                    if (!.Equals(oldVal,val))
                    {
                        propertyNameList.Add(propertyInfo.Name);
                        savedCount++;
                    }
                }
            }

            strsql.Append( set ));
            DbParameter[] parameters =  DbParameter[savedCount];
            StringBuilder sbPros =  StringBuilder();
             {0}={1}{0},propertyInfo.Name,m_ParameterMark));
                        DbParameter param = GetDbParameter(m_ParameterMark + propertyInfo.Name,1)"> dbnull.Value : val);
                        parameters[k++] = param;
                    }
                }
            }
            if (sbPros.Length > )
            {
                strsql.Append(sbPros.ToString(0,sbPros.Length - ));
            }
            strsql.Append( where {0}='{1}'if (savedCount > )
            {
                Executesql(strsql.ToString(),parameters);
            }
        }
        #region 删除
         根据Id删除
        void Delete<T>(int id)
        {
            Type type = (T);
            StringBuilder sbsql =  StringBuilder();
            sbsql.Append(delete from {0} where {2}='{1}'sql(sbsql.ToString());
        }
         根据Id集合删除
        void BatchDelete<T>( ids)
        {
            if (string.IsNullOrWhiteSpace(ids)) ;

            Type type = delete from {0} where {2} in ({1}) 根据条件删除
         conditions)
        {
            string.IsNullOrWhiteSpace(conditions)) delete from {0} where {1}sql(sbsql.ToString());
        }
        #region 获取实体
        #region 根据实体获取实体
         根据实体获取实体
        object Find(bool readCache = )
        {
            Type type = obj.GetType();

            object result = Activator.CreateInstance(type);
            bool hasValue = ;
            IDataReader rd = select * from {0} where {2}='{1}'
            {
                rd = ExecuteReader(sql);

                PropertyInfo[] propertyInfoList = GetEntityProperties(type);

                int fcnt = rd.FieldCount;
                List<string> fileds = ();
                0; i < fcnt; i++)
                {
                    fileds.Add(rd.GetName(i).toupper());
                }

                while (rd.Read())
                {
                    hasValue = ;
                    IDataRecord record = rd;

                    foreach (PropertyInfo pro  propertyInfoList)
                    {
                        if (!fileds.Contains(pro.Name.toupper()) || record[pro.Name] == dbnull.Value)
                        {
                            continue;
                        }

                        pro.SetValue(result,record[pro.Name] == dbnull.Value ? null : getReaderValue(record[pro.Name],pro.PropertyType),1)">);
                    }
                }
            }
             ex;
            }
            if (rd != null && !rd.IsClosed)
                {
                    rd.Close();
                    rd.dispose();
                }
            }

            if (hasValue)
            {
                 result;
            }
            ;
            }
        }
        #region 根据Id获取实体
         根据Id获取实体
        object FindById(Type type,1)"> id)
        {
             Activator.CreateInstance(type);
            IDataReader rd = public T FindById<T>(string id) where T : ()
        {
            Type type = (T);
            T result = (T)Activator.CreateInstance(type);
            IDataReader rd = default(T);
            }
        }
        #region 根据sql获取实体
         根据sql获取实体
        public T FindBysql<T>(string sql) #region 获取列表
         获取列表
        public List<T> FindListBysql<T>(()
        {
            List<T> list = new List<T> obj;
            IDataReader rd =  ExecuteReader(sql);

                typeof(T) == typeof())
                {
                     (rd.Read())
                    {
                        list.Add((T)rd[]);
                    }
                }
                else 
                {
                    PropertyInfo[] propertyInfoList = ((T)).GetProperties();

                     rd.FieldCount;
                    List<();
                    )
                    {
                        fileds.Add(rd.GetName(i).toupper());
                    }

                     (rd.Read())
                    {
                        IDataRecord record = rd;
                        obj =  T();


                         propertyInfoList)
                        {
                             dbnull.Value)
                            {
                                ;
                            }

                            pro.SetValue(obj,1)">);
                        }
                        list.Add((T)obj);
                    }
                }
            }
             list;
        }
        string sql,1)">params DbParameter[] cmdParms)  ExecuteReader(sql,cmdParms);

                #region 分页获取列表
         分页(任意entity，尽量少的字段)
        public PagerModel FindPageBysql<T>(string orderby,1)">int pageSize,1)">int currentPage) ()
        {
            PagerModel pagerModel =  PagerModel(currentPage,pageSize);

            using (DbConnection connection = GetConnection())
            {
                connection.open();
                IDbCommand cmd = ;
                StringBuilder sb =  StringBuilder();
                string commandText = int startRow = int endRow =  (m_DBType)
                {
                    :
                        #region 分页查询语句
                        commandText = select count(*) from ({0}) Tsql);
                        cmd = GetCommand(commandText,connection);
                        pagerModel.totalRows = .Parse(cmd.ExecuteScalar().ToString());

                        startRow = pageSize * (currentPage - );
                        endRow = startRow + pageSize;

                        sb.Append(select * from ( select row_limit.*,rownum rownum_ from ();
                        sb.Append(sql);
                        string.IsNullOrWhiteSpace(orderby))
                        {
                            sb.Append(" );
                            sb.Append();
                        }
                        sb.Append( ) row_limit where rownum <= );
                        sb.Append(endRow);
                        sb.Append( ) where rownum_ >);
                        sb.Append(startRow);
                        #endregion
                        ;
                    1) + ;
                        endRow = startRow + pageSize - ;

                        sb.Append(@"
                            select * from 
                            (select ROW_NUMBER() over({1}) as rowNumber,t.* from ({0}) t) tempTable
                            where rowNumber between {2} and {3} sql,startRow,endRow));
                        );

                        sb.Append(select * from ();
                        }
                        sb.AppendFormat( ) row_limit limit {0},{1});

                        sb.Append(sql);
                         limit {0} offset {1};
                }

                List<T> list = FindListBysql<T>(sb.ToString());
                pagerModel.result = list;
            }

             pagerModel;
        }
        <typeparam name="T"></typeparam>
        <param name="sql"></param>
        <returns></returns>
        int currentPage,1)">(sb.ToString(),cmdParms);
                pagerModel.result = pagerModel;
        }


        public DataSet FindPageBysql(out int totalCount,1)"> DbParameter[] cmdParms)
        {
            DataSet ds = ;
                totalCount = ;
                }

                ds = Query(sql,cmdParms);
            }
             ds;
        }
        #region getReaderValue 转换数据
         转换数据
         Object getReaderValue(Object rdValue,Type ptype)
        {
            if (ptype == double))
                 Convert.Todouble(rdValue);

            decimal Convert.ToDecimal(rdValue);

             Convert.ToInt32(rdValue);

            long Convert.ToInt64(rdValue);

            (DateTime))
                 Convert.ToDateTime(rdValue);

            typeof(Nullable<double>decimal>int>long>typeof(Nullable<DateTime> rdValue;
        }
        #region 获取主键名称
         获取主键名称
         GetIdName(Type type)
        {
            PropertyInfo[] propertyInfoList = GetEntityProperties(type);
             propertyInfo.Name;
                }
            }
            Id#region 获取主键值
        object GetIdVal( val)
        {
            string idName = GetIdName(val.GetType());
            .IsNullOrWhiteSpace(idName))
            {
                return val.GetType().GetProperty(idName).GetValue(val,1)">);
            }
            #region 获取实体类属性
         获取实体类属性
         PropertyInfo[] GetEntityProperties(Type type)
        {
            List<PropertyInfo> result = new List<PropertyInfo>();
            PropertyInfo[] propertyInfoList = type.GetProperties();
            typeof(EdmRelationshipNavigationPropertyAttribute),1)">false).Length == 0
                    && propertyInfo.GetCustomAttributes(typeof(browsableAttribute),1)">)
                {
                    result.Add(propertyInfo);
                }
            }
             result.ToArray();
        }
        #region 获取基类
         获取基类
         Type GetBaseType(Type type)
        {
            while (type.BaseType != null && type.BaseType.Name != (Object).Name)
            {
                type = type.BaseType;
            }
             type;
        }
        #region 事务
        #region 开始事务
         开始事务
        void BeginTransaction()
        {
            DbConnection conn = GetConnection();
             ConnectionState.Open) conn.open();
            m_Tran = conn.BeginTransaction();
        }
        #region 提交事务
         提交事务
         CommitTransaction()
        {
            DbConnection conn = m_Tran.Connection;
            
            {
                m_Tran.Commit();
            }
             (Exception ex)
            {
                m_Tran.Rollback();
            }
            if (conn.State == ConnectionState.Open) conn.Close();
                m_Tran.dispose();
                m_Tran = #region 回滚事务(出错时调用该方法回滚)
         回滚事务(出错时调用该方法回滚)
         RollbackTransaction()
        {
            DbConnection conn = m_Tran.Connection;
            m_Tran.Rollback();
             ConnectionState.Open) conn.Close();
        }
        #endregion
    }
}
View Code

 

如何使用：

    添加：

<summary>
 添加
 obj)
{
    dbHelper.Insert(obj);
}
View Code

    修改：

 修改
 obj)
{
    dbHelper.Update(obj);
}
View Code

    根据ID删除：

 删除
void Del( id)
{
    dbHelper.Delete<BS_Template>(id);
}
View Code

    根据ID批量删除：

void BatchDelete( ids)
{
    dbHelper.BatchDelete<BS_Template>(ids);
}
View Code

    根据条件删除：

void Delete( conditions)
{
    dbHelper.Delete<BS_Template>(conditions);
}
View Code

    获取最大ID(当然，ID一般采用自增，对于并发量极少的系统，或单机系统，为了省事，可以这样做)：

 GetMaxId
 GetMaxId()
{
    return dbHelper.GetMaxID<BS_Template>(id);
}
View Code

    根据条件查询实体：

public BS_Template Get( typeCode,Enums.TemplateType templateType)
{
    StringBuilder sql = new StringBuilder(
        select *
        from BS_Template 
        where typeCode='{0}' 
        and type='{1}')templateType));
    return dbHelper.FindBysql<BS_Template>(sql.ToString());
}
public BS_Template Get2( templateId,1)">
        select *
        from BS_Template 
        where id='{0}' 
        and type='{1}'(sql.ToString());
}
View Code

    根据ID查询实体：

public BS_Test Get( id)
{
    return dbHelper.FindById<BS_Test>(id);
}
View Code

    查询列表：

 查询列表
public List<BS_Test> GetList( name)
{
    StringBuilder sql = 
        select *
        from BS_Test t
        where 1=1 ));

    .IsNullOrWhiteSpace(name))
    {
        sql.AppendFormat( and t.name like '%{0}%'return dbHelper.FindListBysql<BS_Test>(sql.ToString());
}
View Code

    分页查询列表：

 分页获取模板集合
public List<BS_Template> GetList(ref PagerModel pager,1)">string noticeType,1)">string coreType,1)"> name,1)">
        select *
        from BS_Template t
        where 1=1 .IsNullOrWhiteSpace(noticeType))
    {
        sql.AppendFormat( and nt.name like '%{0}%'.IsNullOrWhiteSpace(coreType))
    {
        sql.AppendFormat( and ct.name like '%{0}%'sql.AppendFormat( and t.type = '{0}')templateType);

    orderby = order by cast(id as int);
    pager = dbHelper.FindPageBysql<BS_Template>(sql.ToString(),pager.rows,pager.page);
    return pager.result as List<BS_Template>;
}
View Code

    完整DAL：

 System.Linq;
 DBUtil;
 Models;

 DAL
{
     模板
     TemplateDal
    {
        #region 变量
        private DBHelper dbHelper =  DBHelper();
        #region 分页获取模板集合
         分页获取模板集合
        sql = 
                select *
                from BS_Template t
                where 1=1 ));

            .IsNullOrWhiteSpace(noticeType))
            {
                sql.AppendFormat(.IsNullOrWhiteSpace(coreType))
            {
                sql.AppendFormat(.IsNullOrWhiteSpace(name))
            {
                sql.AppendFormat(sql.AppendFormat()templateType);

            ;
            pager = dbHelper.FindPageBysql<BS_Template>(sql.ToString(),pager.page);
            #region 获取字段关联模板集合
         获取字段关联模板集合
         fieldId)
        {
            StringBuilder sql = 
                select *
                from BS_Template t
                left join BS_TplFieldRelation r on r.templateId=t.id
                left join BS_TplField f on f.id=r.fieldId  
                where f.id='{0}'return dbHelper.FindListBysql<BS_Template>(sql.ToString());
        }
        #region 获取
        
                select *
                from BS_Template 
                where typeCode='{0}' 
                and type='{1}')templateType));
            
                select *
                from BS_Template 
                where id='{0}' 
                and type='{1}'#region GetMaxId
         GetMaxId
         GetMaxId()
        {
            );
        }
         obj)
        {
            dbHelper.Insert(obj);
        }
         obj)
        {
            dbHelper.Update(obj);
        }
         删除
         id)
        {
            dbHelper.Delete<BS_Template>(id);
        }
         ids)
        {
            dbHelper.BatchDelete<BS_Template>(ids);
        }
         conditions)
        {
            dbHelper.Delete<BS_Template>(conditions);
        }
        

    }
}
View Code

    查询sql书写规范：

    sql不能写的乱七八糟，该换行换行，该对齐对齐，例：

;
}
View Code

    select换行，from换行，join换行，where换行，and换行。

    

    数据库事务：


{
    DBHelper.BeginTransaction();

    BS_Template model =  BS_Template();
    model.id = m_TemplateDal.GetMaxId().ToString();
    model.code = k.ToString(0000);
    model.name = 测试" + k.ToString();
    model.remarks =  k.ToString();
    model.type = (()Enums.TemplateType.Notice).ToString();
    m_TemplateDal.Insert(model);
    throw new Exception("a");

    BS_Test test =  BS_test();
    test.id = m_TestDal.GetMaxId().ToString();
    test.code =  k.ToString();
    test.name =  k.ToString();
    test.remarks =  k.ToString();
    m_TestDal.Insert(test);

    DBHelper.CommitTransaction();
    MessageBox.Show(成功);
}
 (Exception ex)
{
    DBHelper.RollbackTransaction();
    MessageBox.Show(ex.Message);
}
View Code

 

    代码下载：https://files.cnblogs.com/files/s0611163/DBHelperDemo.zip

    Model生成器下载：https://files.cnblogs.com/files/s0611163/Model%E7%94%9F%E6%88%90%E5%99%A8.zip

 

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 [email protected] 举报，一经查实，本站将立刻删除。

相关推荐

Blazor 调用 Clipboard API 读写剪贴板数据
目录简介使用JS互操作使用ClipLazor库创建项目使用方法简单测试参考链接 简介 Clipboard API 是一种允许网页读取剪贴板数据或向其中写入数据的API，主要有两个方法： navigator.clipboard.writeText() ：用于将文本写...
C# 轻量级 ORM 框架 NPoco 的简单应用
目录简介快速入门安装 NuGet 包实体类User数据库类DbFactory增删改查InsertSelectUpdateDelete总结 简介 NPoco 是 PetaPoco 的一个分支，具有一些额外的功能，截至现在 github 星数 839。NPoco 中文资料没多少，我是...
C#简单配置类及数据绑定
本文实现一个简单的配置类，原理比较简单，适用于一些小型项目。主要实现以下功能：保存配置到json文件、从文件或实例加载配置类的属性值、数据绑定到界面控件。&#xA;一般情况下，项目都会提供配置的设置界面，很...
C#获取Description特性的扩展类
C#中Description特性主要用于枚举和属性，方法比较简单，记录一下以便后期使用。 扩展类DescriptionExtension代码如下： using System; using System.ComponentModel; using System.Reflection; /// &lt;
C#实现软件开机自启动（不需要管理员权限）
[TOC] # 原理简介 本文参考[C#/WPF/WinForm/程序实现软件开机自动启动的两种常用方法](https://blog.csdn.net/weixin_42288432/article/details/120059296)，将里面中的第一种方法做了封装成**AutoStart**类，使
C#爬取动态网页上的信息：B站主页
目录简介获取 HTML 文档解析 HTML 文档测试补充：使用 CSS 选择器参考文章 简介 动态内容网站使用 JavaScript 脚本动态检索和渲染数据，爬取信息时需要模拟浏览器行为，否则获取到的源码基本是空的。 本文使用的爬取...
C#项目管理引用的dll文件
这篇文章主要简单记录一下C#项目的dll文件管理方法，以便后期使用。 设置dll路径 参考C#开发奇技淫巧三：把dll放在不同的目录让你的程序更整洁中间的 方法一：配置App.config文件的privatePath ： &lt;runtime&a...
C# 常用特性(Attribute)
使用特性，可以有效地将元数据或声明性信息与代码（程序集、类型、方法、属性等）相关联。 将特性与程序实体相关联后，可以在运行时使用反射这项技术查询特性。&#xA;在 C# 中，通过用方括号 ([]) 将特性名称括起...
C#事件总线
事件总线是对发布-订阅模式的一种实现，是一种集中式事件处理机制，允许不同的组件之间进行彼此通信而又不需要相互依赖，达到一种解耦的目的。&#xA;EventBus维护一个事件的字典，发布者、订阅者在事件总线中获取...
C#中使用jieba.NET、WordCloudSharp制作词云图
词云”由美国西北大学新闻学副教授、新媒体专业主任里奇·戈登（Rich Gordon）于2006年最先使用，是通过形成“关键词云层”或“关键词渲染”，对文本中出现频率较高的“关键词”的视觉上的突出。词云图过滤掉大量的文...
    pythonJavaScriptjavaHTMLreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-bootreact-native