对一个项目架构的总结

项目名称：xx市的xx人员管理系统
英文名称：MgrBid
解决方案的工程文件结构
基础类层、实体层、数据库访问接口层、数据库访问接口实现层、数据库访问类工厂层、业务层、视图层

基础类（namespace MgrBid） 包括语言基本功能、实体基类、数据库通用访问帮助类、配置文件访问类、外部控件适配类。 

using  System;
using  System.Collections;

namespace  MgrBid
{
    public class Entity
    {
        public Entity()
        {
            this.m_data=Hashtable.Synchronized(new Hashtable());
        }

        public Entity(Hashtable m_data)
        {
            if(m_data==null)
                this.m_data=Hashtable.Synchronized(new Hashtable());
            else
                this.m_data=m_data;
        }

        public string FID
        {
            get{return EConvert.ToString(this.GetProperty("FID"));}
            set{this.SetProperty("FID",value);}
        }

        public Hashtable Data
        {
            set{this.m_data=value;}
            get{return this.m_data;}
        }

        public static string NewID
        {
            get{return System.Guid.NewGuid().ToString("N").ToUpper();}
        }

        public static object Eval(object obj,string key)
        {
            return ((Entity)obj).GetProperty(key);
        }

        public static object Eval(object obj,string key,string format)
        {
            return string.Format(format,Eval(obj,key));
        }

        #region

        protected Hashtable m_data=null;

        public  object GetProperty(string key)
        {
            return this.m_data[key.ToUpper()];
        }

        public  void SetProperty(string key,object val)
        {
            this.m_data[key.ToUpper()]=val;
        }
        #endregion
    }
}

using  System;
using  System.Data;
using  System.Data.Common;
using  System.Collections;


namespace  MgrBid.Data
{
    public sealed class DbHelper
    {
        public static object ExecuteScalar(IDbCommand cmd)
        {
            try
            {
                cmd.Connection.Open();
                object obj=cmd.ExecuteScalar();
                return obj;
            }
            catch
            {
                return 0;
            }
            finally
            {
                if(cmd!=null) 
                {
                    if(cmd.Connection!=null)
                    {
                        if(cmd.Connection.State==ConnectionState.Open)
                            cmd.Connection.Close();
                        cmd.Connection.Dispose();
                    }
                    cmd.Dispose();
                }
            }
        }


        public static bool ExecuteNonQuery(IDbCommand cmd)
        {
            try
            {
                cmd.Connection.Open();
                return cmd.ExecuteNonQuery()>0;
            }
            catch
            {
                return false;
            }
            finally
            {
                if(cmd!=null) 
                {
                    if(cmd.Connection!=null)
                    {
                        if(cmd.Connection.State==ConnectionState.Open)
                            cmd.Connection.Close();
                        cmd.Connection.Dispose();
                    }
                    cmd.Dispose();
                }
            }
        }


        public static object ExecuteObject(IDbCommand cmd)
        {
            IDataReader reader=null;
            try
            {
                cmd.Connection.Open();
                reader=cmd.ExecuteReader(CommandBehavior.SingleRow);
                if(!reader.Read()) return new object();
                return reader[0];
            }
            catch
            {
                return new object();
            }
            finally
            {
                if(reader!=null) reader.Close();
                if(cmd!=null) cmd.Dispose();
                if(cmd.Connection!=null)
                {
                    if(cmd.Connection.State==ConnectionState.Open)
                        cmd.Connection.Close();
                    cmd.Connection.Dispose();
                }
            }
        }


        public static Hashtable ExecuteHashtable(IDbCommand cmd)
        {
            IDataReader reader=null;
            Hashtable hashTable=null;

            try
            {
                cmd.Connection.Open();
                reader=cmd.ExecuteReader(CommandBehavior.SingleRow);
                
                int fieldCount=reader.FieldCount;
                hashTable=Hashtable.Synchronized(new Hashtable(fieldCount));

                if(!reader.Read()) return hashTable;

                for(int i=0;i<fieldCount;i++)
                    hashTable[reader.GetName(i).ToUpper()]=reader[i];
                return hashTable;
            }
            catch
            {
                return new Hashtable();
            }
            finally
            {
                if(reader!=null) reader.Close();
                if(cmd!=null) cmd.Dispose();
                if(cmd.Connection!=null)
                {
                    if(cmd.Connection.State==ConnectionState.Open)
                        cmd.Connection.Close();
                    cmd.Connection.Dispose();
                }
            }
    
        }


        public static IList ExecuteList(IDbCommand cmd)
        {
            IDataReader reader=null;
            IList list=new ArrayList();

            try
            {
                cmd.Connection.Open();
                reader=cmd.ExecuteReader();
                int fieldCount=reader.FieldCount;
                while(reader.Read()) 
                {
                    Hashtable hashTable=Hashtable.Synchronized(new Hashtable(fieldCount));
                    for(int i=0;i<fieldCount;i++)
                        hashTable[reader.GetName(i).ToUpper()]=reader[i];
                    list.Add(new Entity(hashTable));
                }
                return list;
            }
            catch
            {
                return list;
            }
            finally
            {
                if(reader!=null) reader.Close();
                if(cmd!=null) cmd.Dispose();
                if(cmd.Connection!=null)
                {
                    if(cmd.Connection.State==ConnectionState.Open)
                        cmd.Connection.Close();
                    cmd.Connection.Dispose();
                }
            }
        }
    

    }
}

MgrBid.Model：业务实体。

PrjName.IDAL：数据库操作接口。

using  System;
using  System.Collections;
using  MgrBid.Model;

namespace  MgrBid.IDAL
{
    public interface IPrj
    {
        IList GetAllPrj(string FIDCard);

        IList GetCurrentPrj(string FIDCard);

        bool UpdateAPrj(EPrj aEPrj);

        bool RemoveAPrj(string FID);

        bool AppendAPrj(EPrj aEPrj);
    }
}

PrjName.SqlServer：对数据库操作接口的一个SqlServer实现。

PrjName.DALFactory：数据库操作类工厂,使用单例模式。

using  System;

namespace  MgrBid.DALFactory
{
    public class Prj
    {
        private static MgrBid.IDAL.IPrj m_IPrj=null;

        public static MgrBid.IDAL.IPrj GetInstance()
        {
            if(m_IPrj==null)
                m_IPrj=new MgrBid.SqlServer.Prj();
            return m_IPrj;
        }
    }
}

PrjName.BizRule：业务对象层。从数据库操作类工厂创建数据库操作接口实例，组合调用数据库操作接口实现业务逻辑。

using  System;
using  System.Collections;
using  MgrBid.DALFactory;

namespace  MgrBid.BizRule
{
    public class PrjHelper
    {
        public static IList GetCurrentPrj(string FIDCard)
        {
            return Prj.GetInstance().GetCurrentPrj(FIDCard);
        }
    }
}

PrjName.WPL：项目视图层。 只调用BizRule和Model 完成用户的业务请求。
对于从业务层获得的Entity类型List要在Repeater中正确的显示字段使用<%#Entity.Eval(Container.DataItem,"FName")%>方法