ORM框架学习（四）

ORM框架----删除数据

本节是ORM框架学习的第四节，主要内容是用户数据的删除

Delete方法也是一个通用的泛型方法，其定义如下所示：

public bool Delete<T>(int id) where T : BaseModel
        {
            Type type=typeof(T);
            string sql = string.Format("delete  from [{0}] where id=@id",type.Name);
            SqlParameter[] sqlparas = new SqlParameter[]{ new SqlParameter("@id",id)};

            try
            {
                return ExecuteSql<bool>(sql, sqlparas, command =>
                {
                    int result = command.ExecuteNonQuery();
                    return result > 0;
                });
                //using (SqlConnection conn = new SqlConnection(conStr))
                //{
                //    SqlCommand cmd = new SqlCommand(sql, conn);
                //    cmd.Parameters.AddRange(sqlparas);
                //    conn.Open();
                //    int result = cmd.ExecuteNonQuery();
                //    return result > 0;
                //}
            }
            catch (Exception ex)
            {

                Console.WriteLine(ex.Message);
            }
            
            return true;
        }

上述代码和我们之前的查询、新增、更新代码类似，唯一区别就是用委托，做了代码优化。其实我们的查询、新增、更新和现在的删除代码，都存在相同点，所有的ADO .NET代码都包含下图所示部分：

 

 为了提高代码的复用性以及分离逻辑，我们采用委托的方法复用相同代码，然后委托回调各自特定的方法。泛型委托方法定义如下所示：

private T ExecuteSql<T>(string sql, SqlParameter[] paras, Func<SqlCommand, T> command)
        {
            string conStr = "Server=127.0.0.1;Database=master; integrated security=SSPI";
            using (SqlConnection conn = new SqlConnection(conStr))
            {
                SqlCommand cmd = new SqlCommand(sql, conn);
                cmd.Parameters.AddRange(paras);
                conn.Open();
                return command.Invoke(cmd);
            }
            
        }

如上代码所示，用户只需要提供操作的sql语句和参数化列表，以及需要回调的函数即可。该方法的好处有：

1.提高代码复用性 

2.可以规范ADO .Net的操作 

3.我们需要打印日志之类的只需在该方法定义即可

通过ExecuteSql方法，我们把之前的查询、新增、更新代码做了下升级

查询代码：

public T Query<T>(int id) where T : BaseModel
        {
           
            try
            {
                Type t= typeof(T);
                string sql = SqlBuilder<T>.GetSql(SqlBuilder<T>.SqlType.FindSql);
                SqlParameter[] pa = new SqlParameter[]{ new SqlParameter("@id",id)};
                return ExecuteSql<T>(sql, pa, command =>
                {
                    SqlDataReader reader = command.ExecuteReader();
                    T ti = Activator.CreateInstance<T>();
                    while (reader.Read())
                    {
                        foreach (var prop in t.GetProperties())
                        {
                            var pro = prop.GetMappingName();
                            prop.SetValue(ti, reader[pro] is DBNull ? null : reader[pro], null);
                        }
                    }
                    return ti;
                });
                //using (SqlConnection con = new SqlConnection(conStr))
                //{
                //    SqlCommand cmd = new SqlCommand(sql, con);
                //    con.Open();
                //    cmd.Parameters.Add(pa);
                   
                //}
            }
            catch (Exception ex)
            {
                return null;
            }
        }

新增代码：

public bool AddData<T>(T t) where T:BaseModel
        {
            try
            {
                Type type=typeof(T);
                string AddStr = SqlBuilder<T>.GetSql(SqlBuilder<T>.SqlType.AddSql);
                var sqlpara = type.GetProperties().FilterKey().Select(p => new SqlParameter("@" + p.GetMappingName(), p.GetValue(t) ?? DBNull.Value)).ToArray();

                return ExecuteSql<bool>(AddStr, sqlpara, command =>
                {
                    int result = command.ExecuteNonQuery();
                    return result > 0;
                });
                //using (SqlConnection conn = new SqlConnection(conStr))
                //{
                //    SqlCommand cmd = new SqlCommand(AddStr, conn);
                //    cmd.Parameters.AddRange(sqlpara);
                //    conn.Open();
                //    int result= cmd.ExecuteNonQuery();
                //    return result > 0;
                //}
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }

更新代码：

public bool Update<T>(T t) where T : BaseModel
        {

            try
            {
                Type type = typeof(T);
                string UpdateStr = SqlBuilder<T>.GetSql(SqlBuilder<T>.SqlType.UpdateSql);
                var sqlpara = type.GetProperties().Select(p => new SqlParameter("@" + p.GetMappingName(), p.GetValue(t) ?? DBNull.Value)).ToArray();
                return ExecuteSql<bool>(UpdateStr, sqlpara, command =>
                {
                    int result = command.ExecuteNonQuery();
                    return result > 0;
                });
                //using (SqlConnection conn = new SqlConnection(conStr))
                //{
                //    SqlCommand cmd = new SqlCommand(UpdateStr, conn);
                //    cmd.Parameters.AddRange(sqlpara);
                //    conn.Open();
                //    int result = cmd.ExecuteNonQuery();
                //    return result > 0;
                //}
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }

观察升级过后的代码，有没有发现ExecuteSql的妙处了。我们不管操作数据库sql语句返回的是bool类型还是一个实体对象，我们都可以调用该方法。对于每个操作返回的数据做下单独处理，就实现了所有的类型操作。

到目前为止，ORM框架基本知识已经差不多学习完成了。博主所写内容都是自己学习过程的总结和拙见，如有不妥之处，欢迎给位园友批评指正.