参数的传递问题.

Question

是这样的,如果我想把Insert方法放在DateExecute接口中,那么我下面的方法是正确的 
但是最不灵活的一个地方是我用了Model.Admin这个表的属性作为参数, 
如果在其它表里例如产品表,那我得用Model.Product这个传进去,所以这个接口肯定会出错, 
要如何修改才是最好的方法,请大家帮帮我. 
public class Admin:DateExecute 
{ 
  public void Insert(Model.Admin model) 
  { 
            SqlParameter[] Params ={ 
                new SqlParameter("@UserName",SqlDbType.VarChar,50), 
                new SqlParameter("@PassWord",SqlDbType.VarChar,50), 
                new SqlParameter("@Information",SqlDbType.Int,4), 
                new SqlParameter("@News",SqlDbType.Int,4), 
                new SqlParameter("@Product",SqlDbType.Int,4), 
                new SqlParameter("@Orders",SqlDbType.Int,4), 
                new SqlParameter("@Menber",SqlDbType.Int,4), 
                new SqlParameter("@Users",SqlDbType.Int,4), 
                new SqlParameter("@GuangGao",SqlDbType.Int,4), 
                new SqlParameter("@GuestBook",SqlDbType.Int,4), 
                new SqlParameter("@LoginDate",SqlDbType.DateTime,16), 
                new SqlParameter("@UpdateDate",SqlDbType.DateTime,16), 
                new SqlParameter("@LoginIP",SqlDbType.VarChar,50), 
            }; 
            Params[0].Value = model.UserName; 
            Params[1].Value = model.PassWord; 
            Params[2].Value = model.Information; 
            Params[3].Value = model.News; 
            Params[4].Value = model.Product; 
            Params[5].Value = model.Orders; 
            Params[6].Value = model.Member; 
            Params[7].Value = model.Users; 
            Params[8].Value = model.GuangGao; 
            Params[9].Value = model.GuestBook; 
            Params[10].Value = model.LoginDate; 
            Params[11].Value = model.UpdateDate; 
            Params[12].Value = model.LoginIP; 
            StringBuilder strSql = new StringBuilder(); 
            strSql.Append("Insert into Admin ("); 
            strSql.Append("UserName,PassWord,Information,News,Product,Orders,Member,Users,GuestGao,GuestBook,LoginDate,UpdateDate,LoginIP)"); 
            strSql.Append("values("); 
            strSql.Append("@UserName,@PassWord,@Information,@News,@Product,@Orders,@Member,@Users,@GuestGao,@GuestBook,@LoginDate,@UpdateDate,@LoginIP)"); 
            SqlHelper.ExecuteSql(strSql.ToString(), Params); 
  } 
} public interface DateExecute 
  { 
    void Insert(Model.Admin model); 
  }有网友提议建个基类,
代码如下:
做一个model的基类。让model继承这个类。 
class model:ModelBase 
public void Insert(ModelBase model) 请问这个基类里的代码应该如何做,请详细点.

Answer 1

理想情况是  P[i].Value=Model.Att[i]  那些,你的Insert方法一般情况下就不用动了.
Model 肯定是要实现迭代器 IEnumerator接口 实现 即可.

Answer 2

public class DateExecute {
            public void Insert<T>(T model) where T : BaseModel {
                SqlHelper.ExecuteSql(model.GetInsertStatement(), model.GetInsertParams());
            }
        }        public abstract class BaseModel {
            public abstract string GetInsertStatement();
            public abstract SqlParameter[] GetInsertParams();
        }        public class AModel : BaseModel {
            public override string GetInsertStatement() {
                return "";
            }            public override SqlParameter[] GetInsertParams() {
                return new SqlParameter[0];
            }
        }        public class BModel : BaseModel {
            public override string GetInsertStatement() {
                return "";
            }            public override SqlParameter[] GetInsertParams() {
                return new SqlParameter[0];
            }
        }

Answer 3

其实楼主可以使用Attribute+反射来做一个通用的插入方法.

Answer 4

OK，这个问题很简单，需要利用到反射。首先你有ModelBase基类，这个基类最好是抽象基类，那么你可以在你的Insert方法中，根据传入参数的Model实例得到类型也就是调用GetType()方法，还是贴代码把
        public virtual void AddNewEntity(EntityGateway objNewEntity, SqlTransaction objTransaction)
        {
            //得到出入实体的类型
            Type objType = objNewEntity.GetType();            //得到类型的所有字段
            FieldInfo[] objFieldsCollection = objType.GetFields();            //定义插入参数集合
            SqlParameter[] parmInserts;            
            parmInserts = new SqlParameter[objFieldsCollection.Length + 1];            //遍历所有的字段
            for (int i = 0; i < objFieldsCollection.Length; i++)
            {
                //根据字段和实体来创建参数
                CreateParameter(out parmInserts[i], objFieldsCollection[i], objNewEntity);   
            }            //判断实体ID是否为空
            if (objNewEntity.ID != null)
            {
                //得到实体ID的类型
                Type objIDType = objNewEntity.ID.GetType();                //判断实体ID类型名
                if (objIDType == typeof(String))
                {
                    //如果是字符串,那么参数类型为字符串
                    parmInserts[parmInserts.Length - 1] = DB.CreateParameter(this.IDParamName, DbType.String, objNewEntity.ID);
                }
                else if (objIDType == typeof(Int32))
                {
                    //如果是Int32,那么参数的类型为Int32
                    parmInserts[parmInserts.Length - 1] = DB.CreateParameter(this.IDParamName, DbType.Int32, objNewEntity.ID);
                }
            }
            else
            {
                //如果不为空,则创建返回值参数
                parmInserts[parmInserts.Length - 1] = DB.CreateParameter(this.IDParamName, DbType.Int32, 1, ParameterDirection.ReturnValue, true, -1);
            }            try
            {
                //判断是否存在事务,调用相应的事务方法
                if (objTransaction == null)
                {
                    DB.ExecuteProcedure(m_strInsertCommand, parmInserts);
                }
                else
                {
                    DB.ExecuteProcedure(m_strInsertCommand, parmInserts, objTransaction);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }            //根据从数据库出来的返回值,给实体ID赋值
            if (objNewEntity.ID == null)
            {
                objNewEntity.ID = parmInserts[parmInserts.Length - 1].Value;
            }
        }
#region Private Methods
        /// <summary>
        /// 根据字段和实体创建参数
        /// </summary>
        /// <param name="parm">被创建的参数</param>
        /// <param name="objFieldInfo">创建参数的字段信息</param>
        /// <param name="objEntity">创建参数的实体</param>
        protected void CreateParameter(out SqlParameter parm, FieldInfo objFieldInfo, EntityGateway objEntity)
        {
            SqlParameter parmTmp = null;
            //判断实体字段类型名
            switch (objFieldInfo.FieldType.Name)
            {
                case "Byte[]":
                    byte[] image = (byte[])objFieldInfo.GetValue(objEntity);
                    if(image == null)
                    {
                        parmTmp = DB.CreateParameter(objFieldInfo.Name, DbType.Binary, DBNull.Value);
                        parmTmp.DbType = DbType.Binary;
                    }
                    else
                    {
                        parmTmp = DB.CreateParameter(objFieldInfo.Name, DbType.Binary, image);
                    }
                    break;
                case "AcceptDocStatus":
                    parmTmp = DB.CreateParameter(objFieldInfo.Name, DbType.Int32, (int)objFieldInfo.GetValue(objEntity));
                    break;
                case "String"://类型为String,参数类型为String
                    parmTmp = DB.CreateParameter(objFieldInfo.Name, DbType.String, objFieldInfo.GetValue(objEntity));
                    break;
                case "Int32"://类型为Int32, 参数类型为Int32
                    if (((int)objFieldInfo.GetValue(objEntity)) == int.MinValue)
                    {
                        parmTmp = DB.CreateParameter(objFieldInfo.Name, DbType.Int32, null);
                    }
                    else
                    {
                        parmTmp = DB.CreateParameter(objFieldInfo.Name, DbType.Int32, objFieldInfo.GetValue(objEntity));
                    }
                    break;
                case "Boolean":
                    parmTmp = DB.CreateParameter(objFieldInfo.Name, DbType.Boolean, objFieldInfo.GetValue(objEntity));
                    break;
                case "Single":
                    if (((float)objFieldInfo.GetValue(objEntity)) == float.MinValue)
                    {
                        parmTmp = DB.CreateParameter(objFieldInfo.Name, DbType.Single, null);
                    }
                    else
                    {
                        parmTmp = DB.CreateParameter(objFieldInfo.Name, DbType.Single, objFieldInfo.GetValue(objEntity));
                    }
                    break;
                case "Decimal":
                    if (((decimal)objFieldInfo.GetValue(objEntity)) == decimal.MinValue)
                    {
                        parmTmp = DB.CreateParameter(objFieldInfo.Name, DbType.Decimal, null);
                    }
                    else
                    {
                        parmTmp = DB.CreateParameter(objFieldInfo.Name, DbType.Decimal, objFieldInfo.GetValue(objEntity));
                    }
                    break;
                case "Double":
                    if (((double)objFieldInfo.GetValue(objEntity)) == double.MinValue)
                    {
                        parmTmp = DB.CreateParameter(objFieldInfo.Name, DbType.Double, null);
                    }
                    else
                    {
                        parmTmp = DB.CreateParameter(objFieldInfo.Name, DbType.Double, objFieldInfo.GetValue(objEntity));
                    }
                    break;
                case "DateTime":
                    if (((DateTime)objFieldInfo.GetValue(objEntity)) == DateTime.MinValue)
                    {
                        parmTmp = DB.CreateParameter(objFieldInfo.Name, DbType.DateTime, null);
                    }
                    else
                    {
                        parmTmp = DB.CreateParameter(objFieldInfo.Name, DbType.DateTime, objFieldInfo.GetValue(objEntity));
                    }
                    break;
            }            parm = parmTmp;        }
        #endregion有3个地方要注意一下：
1、存储过程的名称，插入的存储过程的名称必须符合一定的规范，或者由你的实体类来提供
2、在上面的代码中，我们得到实体的各个属性的类型是public field，不是property，这个可以根据你的需要自己修改
3、创建参数的时候是根据public field自动创建的，所以你的字段必须与存储过程的参数是一一对应的
4、此代码是基于sql server数据库来写的，Oracle有自己特定的语法和参数创建方法，不能简单的套用