非常不错的数据访问架构

代码

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;
        }
    }

转载于:https://www.cnblogs.com/hubcarl/archive/2010/04/07/1706360.html