非常不错的数据访问架构

1.根据查询结果构建实体类公共接口
 public interface IEntityTranslate
 {
    /// 用class关键字表示约束为引用类型
    /// 用struct关键字表示约束为值类型
    TEntity Translate<TEntity>(IDataReader reader) where TEntity : class;
 }
2.根据查询结果实体类的实现
 public class EntityTranslate : IEntityTranslate
    {
        public TEntity Translate<TEntity>(IDataReader reader) where TEntity : class  //执行查询返回对象集合 
        {
            Type entityType = typeof(TEntity);

            object entity = Activator.CreateInstance(entityType);
            foreach (PropertyInfo info in entityType.GetProperties())
            {
                string columnName = string.Empty;
                object[] attributes = info.GetCustomAttributes(true);
                foreach (object attribute in attributes)
                {
                    if (attribute is MD.DataColumn)
                    {
                        columnName = (attribute as MD.DataColumn).ColumnName;
                        int filedIndex = 0;
                        while (filedIndex < reader.FieldCount)
                        {
                            if (reader.GetName(filedIndex) == columnName)
                            {
                                info.SetValue(entity, reader.GetValue(filedIndex), null);
                                break;
                            }
                            filedIndex++;
                        }
                        break;
                    }
                }
            }
            return entity as TEntity;
        }
    }
3.自定义属性继承了属性类Attribute
  public class DataColumn : System.Attribute
    {
        public DataColumn()
        {
        }

        public DataColumn(string columnName)
        {
            ColumnName = columnName;
        }

        public string ColumnName
        {
            get;
            set;
        }
    }

4.数据访问接口IDataProvider
 public interface IDataProvider
 {
         DbConnection OpenConnection(); //打开一个数据库连接

　　     void Open(); //当连接为关闭状态时 再次打开连接

　　     void Close(); //关闭连接

　　    IDataReader ExecuteReader(string sql);// 执行Sql 语句返回执行结果

　　    int ExecuteNonQuery(string sql); //执行 修改、删除、增加

　　    ICollection<TEntity> ExcuteReader<TEntity>(string sql) where TEntity : class;　 //执行查询返回对象集合


  }
5. 数据访问基础类的实现
public abstract class DataProviderBase : IDataProvider
    {

        protected DbConnection _Connection;
        protected DbCommand _Command;
        protected IEntityTranslate _Translate;

        #region IDataProvider Members

        public abstract DbConnection OpenConnection();

        public virtual void Close()
        {
            _Connection.Close();
        }

        public virtual void Open()
        {
            _Connection.Open();
        }


        protected virtual DbCommand Command
        {
            get { return _Command; }
            set { _Command = value; }
        }


        protected IEntityTranslate Translate
        {
            get
            {
                if (_Translate == null)
                {
                    _Translate = new EntityTranslate();
                }
                return _Translate;
            }
        }

        public abstract IDataReader ExecuteReader(string sql);

        public abstract int ExecuteNonQuery(string sql);

        public abstract ICollection<TEntity> ExcuteReader<TEntity>(string sql) where TEntity : class;

        #endregion
    }
6.数据访问类的实现
 public class SqlDataProvider : DataProviderBase
    {

        private void BuilderCommand(string sql)
        {
            Command.CommandText = sql;
            Command.Connection = OpenConnection();
        }
        
        public override System.Data.Common.DbConnection OpenConnection()
        {
            if (_Connection == null)
            {
                _Connection = BuilderSqlConnection();
            }

            if (_Connection.State != System.Data.ConnectionState.Open)
            {
                Open();
            }
            return _Connection;
        }

        private System.Data.Common.DbConnection BuilderSqlConnection()
        {
            try
            {
                string connectionString = ConfigurationManager.ConnectionStrings["DataBaseConnectionString"].ConnectionString;
                return new SqlConnection(connectionString);
            }
            catch (Exception ex)
            {
                throw new Exception("数据库连接失败！ 失败原因：" + ex);
            }
        }

        protected override System.Data.Common.DbCommand Command
        {
            get
            {
                if (base.Command == null)
                {
                    base.Command = new SqlCommand();
                }
                return base.Command;
            }
            set
            {
                base.Command = value;
            }
        }

        public override IDataReader ExecuteReader(string sql)
        {
            BuilderCommand(sql);
            return Command.ExecuteReader();
        }

        public override int ExecuteNonQuery(string sql)
        {
            BuilderCommand(sql);
            return Command.ExecuteNonQuery();
        }


        public override ICollection<TEntity> ExcuteReader<TEntity>(string sql)
        {
            ICollection<TEntity> datas = new List<TEntity>();
            BuilderCommand(sql);
            using (IDataReader reader = Command.ExecuteReader())
            {
                while (reader.Read())
                {
                    datas.Add(Translate.Translate<TEntity>(reader));
                }
            }
            return datas;
        }
    }