小结面向对象的类的设计方式

开始接触。NET的人都会知道。NET是面向对象的编程，即使是从ASP往ASP。NET转型的人也会发现，尽管代码页面还是熟悉的HTML页，而后置页却也是一个继承于 System.Web.UI.Page的类。在类中实现了3个方法：
Page_Load(object sender, System.EventArgs e)
OnInit(EventArgs e)
 InitializeComponent()

代码后置页主要是实现业务层的功能，实现对数据有效性，业务逻辑等方面的功能。而肩负着对数据库桥梁的则是自己定义的数据实体类，通常我们都是定义一个只包含某对象的属性的类，
如下: 实体类：DatfaultInfo，该类封装了相关属性。

using System;
namespace oilManage
{
    public class DatfaultInfo
    {
        public DatfaultInfo()
        {
        }
        public DatfaultInfo(string descrption,string dispose,decimal fault_id,DateTime operatedate,string operateuser,decimal trialinfo_id)
        {
            this.Descrption=descrption;
            this.Dispose=dispose;
            this.Fault_id=fault_id;
            this.Operatedate=operatedate;
            this.Operateuser=operateuser;
            this.Trialinfo_id=trialinfo_id;
        }
        private string mDescrption;
        public string Descrption
        {
            get{ return mDescrption ;}
            set{ mDescrption=value ;}
        }
        private string mDispose;
        public string Dispose
        {
            get{ return mDispose ;}
            set{ mDispose=value ;}
        }
        private decimal mFault_id;
        public decimal Fault_id
        {
            get{ return mFault_id ;}
            set{ mFault_id=value ;}
        }
        private DateTime mOperatedate;
        public DateTime Operatedate
        {
            get{ return mOperatedate ;}
            set{ mOperatedate=value ;}
        }
        private string mOperateuser;
        public string Operateuser
        {
            get{ return mOperateuser ;}
            set{ mOperateuser=value ;}
        }
        private decimal mTrialinfo_id;
        public decimal Trialinfo_id
        {
            get{ return mTrialinfo_id ;}
            set{ mTrialinfo_id=value ;}
        }
    }
}

对于自定义的类，考虑到要提供集合的功能，以便于实现各种接口，如：IList,ICollection,IEnumerable 方面访问集合，于是又利用arrayList实现了对该数据类的集合类。
如下：DatfaultInfoCollection
using System;
using System.Collections;
namespace oilManage
{
    public class DatfaultInfoCollection:IList,ICollection,IEnumerable
    {
        System.Collections.ArrayList elements;
        public DatfaultInfoCollection()
        {
            elements=new System.Collections.ArrayList();
        }

        public DatfaultInfo this[int index]
        {
            get
            {
                return (DatfaultInfo)this.elements[index];
            }
            set
            {
                this.elements[index]=value;
            }
        }

        int IList.IndexOf(object value)
        {
            return ((DatfaultInfoCollection)this).IndexOf((DatfaultInfo)value);
        }

        public int IndexOf(DatfaultInfo value)
        {
            return this.elements.IndexOf(value);
        }

        public bool IsReadOnly
        {
            get
            {
                return this.elements.IsReadOnly;
            }
        }

        object IList.this[int index]
        {
            get
            {
                return ((DatfaultInfoCollection)this)[index];
            }
            set
            {
                ((DatfaultInfoCollection)this)[index]=(DatfaultInfo)value;
            }
        }

        public bool IsFixedSize
        {
            get
            {
                return this.elements.IsSynchronized;
            }
        }

        public bool IsSynchronized
        {
            get
            {
                return true;
            }
        }

        public int Count
        {
            get
            {
                return this.elements.Count;
            }
        }

        public void CopyTo(System.Array array,int index)
        {
            this.elements.CopyTo(array,index);
        }

        public object SyncRoot
        {
            get
            {
                return this.elements.SyncRoot;
            }
        }

        public System.Collections.IEnumerator GetEnumerator()
        {
            return this.elements.GetEnumerator();
        }

        public int Add(DatfaultInfo value)
        {
            return this.elements.Add(value);
        }

        int IList.Add(object value)
        {
            return ((DatfaultInfoCollection)this).Add((DatfaultInfo)value);
        }

        void IList.Insert(int index, object value)
        {
            ((DatfaultInfoCollection)this).Insert(index,(DatfaultInfo)value);
        }

        public void Insert(int index, DatfaultInfo value)
        {
            this.elements.Insert(index,value);
        }

        public void RemoveAt(int index)
        {
            this.elements.RemoveAt(index);
        }

        void IList.Remove(object value)
        {
            ((DatfaultInfoCollection)this).Remove((DatfaultInfo)value);
        }

        public void Remove(DatfaultInfo value)
        {
            this.elements.Remove(value);
        }

        bool IList.Contains(object value)
        {
            return ((DatfaultInfoCollection)this).Contains((DatfaultInfo)value);
        }

        public bool Contains(DatfaultInfo value)
        {
            return this.elements.Contains(value);
        }

        public void Clear()
        {
            this.elements.Clear();
        }
    }
}

对于给定的数据我们都用加上一些与数据库通信的CRUD方法。
于是我们对于其定义了数据访问类：DatfaultDB  

using System;
using System.Data;
using System.Data.OracleClient;
using Fjeptri.DataAccess.DataHelper;
namespace oilManage
{
    public class DatfaultDB
    {
        public static bool Create(DatfaultInfo datfaultInfo)
        {
            string CREATE="insert into DATFAULT(DESCRPTION,DISPOSE,FAULT_ID,OPERATEDATE,OPERATEUSER,TRIALINFO_ID) values(:DESCRPTION,:DISPOSE,:FAULT_ID,:OPERATEDATE,:OPERATEUSER,:TRIALINFO_ID)";
            OracleParameter[] param=OracleHelper.GetCacheParameter(CREATE);
            if(param==null)
            {
                param=new OracleParameter[6];
                param[0]=new OracleParameter("DESCRPTION",OracleType.VarChar,4000);
                param[1]=new OracleParameter("DISPOSE",OracleType.VarChar,4000);
                param[2]=new OracleParameter("FAULT_ID",OracleType.Number);
                param[3]=new OracleParameter("OPERATEDATE",OracleType.DateTime);
                param[4]=new OracleParameter("OPERATEUSER",OracleType.VarChar,20);
                param[5]=new OracleParameter("TRIALINFO_ID",OracleType.Number);
                OracleHelper.CacheParameter(CREATE,param);
            }
            param[0].Value=datfaultInfo.Descrption==null?string.Empty:datfaultInfo.Descrption;
            param[1].Value=datfaultInfo.Dispose==null?string.Empty:datfaultInfo.Dispose;
            param[2].Value=datfaultInfo.Fault_id;
            param[3].Value=datfaultInfo.Operatedate;
            param[4].Value=datfaultInfo.Operateuser==null?string.Empty:datfaultInfo.Operateuser;
            param[5].Value=datfaultInfo.Trialinfo_id;
            return OracleHelper.ExecuteNonQuery(ConfigInfo.GetConnectionString(),CommandType.Text,CREATE,param)>0?true:false;
        }
        public static int Delete(DatfaultPK datfaultPK)
        {
            string DELETE="delete DATFAULT where FAULT_ID=:FAULT_ID";
            OracleParameter[] param=OracleHelper.GetCacheParameter(DELETE);
            if(param==null)
            {
                param=new OracleParameter[1];
                param[0]=new OracleParameter("FAULT_ID",OracleType.Number);
                OracleHelper.CacheParameter(DELETE,param);
            }
            param[0].Value=datfaultPK.Fault_id;
            return OracleHelper.ExecuteNonQuery(ConfigInfo.GetConnectionString(),CommandType.Text,DELETE,param);
        }
        public static DatfaultInfo Read(DatfaultPK datfaultPK)
        {
            string READ="select DESCRPTION,DISPOSE,FAULT_ID,OPERATEDATE,OPERATEUSER,TRIALINFO_ID from DATFAULT where FAULT_ID=:FAULT_ID";
            OracleParameter[] param=OracleHelper.GetCacheParameter(READ);
            if(param==null)
            {
                param=new OracleParameter[1];
                param[0]=new OracleParameter("FAULT_ID",OracleType.Number);
                OracleHelper.CacheParameter(READ,param);
            }
            param[0].Value=datfaultPK.Fault_id;
            using(OracleDataReader dr=OracleHelper.ExecuteReader(ConfigInfo.GetConnectionString(),CommandType.Text,READ,param))
            {
                if(dr.Read()==false)
                    return null;
                DatfaultInfo obj=new DatfaultInfo();
                if(!dr.IsDBNull(0))
                    obj.Descrption=dr.GetString(0);
                if(!dr.IsDBNull(1))
                    obj.Dispose=dr.GetString(1);
                if(!dr.IsDBNull(2))
                    obj.Fault_id=dr.GetDecimal(2);
                if(!dr.IsDBNull(3))
                    obj.Operatedate=dr.GetDateTime(3);
                if(!dr.IsDBNull(4))
                    obj.Operateuser=dr.GetString(4);
                if(!dr.IsDBNull(5))
                    obj.Trialinfo_id=dr.GetDecimal(5);
                return obj;
            }
        }
        public static DataTable SelectAllDatfaultInfo()
        {
            string SELECTALLDATFAULTINFO="select DESCRPTION,DISPOSE,FAULT_ID,OPERATEDATE,OPERATEUSER,TRIALINFO_ID from DATFAULT";
            return OracleHelper.ExecuteDataTable(ConfigInfo.GetConnectionString(),CommandType.Text,SELECTALLDATFAULTINFO);
        }
        public static bool Update(DatfaultInfo datfaultInfo)
        {
            string UPDATE="update DATFAULT set DESCRPTION=:DESCRPTION,DISPOSE=:DISPOSE,FAULT_ID=:FAULT_ID,OPERATEDATE=:OPERATEDATE,OPERATEUSER=:OPERATEUSER,TRIALINFO_ID=:TRIALINFO_ID where FAULT_ID=:FAULT_ID";
            OracleParameter[] param=OracleHelper.GetCacheParameter(UPDATE);
            if(param==null)
            {
                param=new OracleParameter[7];
                param[0]=new OracleParameter("DESCRPTION",OracleType.VarChar,4000);
                param[1]=new OracleParameter("DISPOSE",OracleType.VarChar,4000);
                param[2]=new OracleParameter("FAULT_ID",OracleType.Number);
                param[3]=new OracleParameter("OPERATEDATE",OracleType.DateTime);
                param[4]=new OracleParameter("OPERATEUSER",OracleType.VarChar,20);
                param[5]=new OracleParameter("TRIALINFO_ID",OracleType.Number);
                param[6]=new OracleParameter("FAULT_ID",OracleType.Number);
                OracleHelper.CacheParameter(UPDATE,param);
            }
            param[0].Value=datfaultInfo.Descrption==null?string.Empty:datfaultInfo.Descrption;
            param[1].Value=datfaultInfo.Dispose==null?string.Empty:datfaultInfo.Dispose;
            param[2].Value=datfaultInfo.Fault_id;
            param[3].Value=datfaultInfo.Operatedate;
            param[4].Value=datfaultInfo.Operateuser==null?string.Empty:datfaultInfo.Operateuser;
            param[5].Value=datfaultInfo.Trialinfo_id;
            param[6].Value=datfaultInfo.Fault_id;
            return OracleHelper.ExecuteNonQuery(ConfigInfo.GetConnectionString(),CommandType.Text,UPDATE,param)>0?true:false;
        }
    }
}