C#版本的CBO

由于需要用到CBO，就把VB版的做了一些修改
CBO.cs

using  System;
using  System.Data;
using  System.Collections;
using  System.Collections.Generic;
using  System.IO;
using  System.Reflection;
using  System.Text;
using  System.Web.Caching;
using  System.Xml;
using  System.Xml.Serialization;

namespace  Portal
{
    public class CBO
    {
        "Private Shared Methods"#region "Private Shared Methods"

        private static object CreateObject(Type objType, IDataReader dr)
        {
            object objObject = Activator.CreateInstance(objType);

            if ( objObject is IHydratable)
            {
                // Create Object and Use IHydratable's Fill
                IHydratable objHydratable = objObject as IHydratable;
                if (objHydratable != null)
                {
                    objHydratable.Fill(dr);
                }
            }
            else
            {
                // Use Reflection
                HydrateObject(objObject, dr);
            }

            return objObject;
        }

        private static T CreateObject<T>(IDataReader dr)
        {
            T objObject = Activator.CreateInstance<T>();

            if (objObject is IHydratable)
            {
                // Use IHydratable's Fill
                IHydratable objHydratable = objObject as IHydratable;
                if (objHydratable != null)
                {
                    objHydratable.Fill(dr);
                }
            }
            else
            {
                // Use Reflection
                HydrateObject(objObject, dr);
            }

            return objObject;
        }

        private static int[] GetOrdinals(ArrayList objProperties, IDataReader dr)
        {
            int[] arrOrdinals = new int[objProperties.Count];
            string propertyName;
            int intIndex;
            Hashtable columns = new Hashtable();

            if (dr != null)
            {
                for(intIndex = 0; intIndex < dr.FieldCount; intIndex ++)
                {
                    columns[dr.GetName(intIndex).ToUpperInvariant()] = "";
                }

                for (intIndex = 0; intIndex <= (objProperties.Count - 1); intIndex++)
                {
                    propertyName = ((PropertyInfo)objProperties[intIndex]).Name.ToUpperInvariant();
                    arrOrdinals[intIndex] = -1;
                    try
                    {
                        arrOrdinals[intIndex] = dr.GetOrdinal(propertyName);
                    }
                    catch
                    {
                        arrOrdinals[intIndex] = -1;
                    }
                }
            }

            return arrOrdinals;
        }
        
        private static bool IsNumeric(object data)
        {
            try
            {
                Int32.Parse(data.ToString());
                return true;
            }
            catch
            {
                return false;
            }
        }


        private static void HydrateObject(object objObject, IDataReader dr)
        {
            PropertyInfo objPropertyInfo;
            Type objPropertyType = null;
            object objDataValue;
            Type objDataType;
            int intProperty;

            // get properties for type
            ArrayList objProperties = GetPropertyInfo(objObject.GetType());

            // get ordinal positions in datareader
            int[] arrOrdinals = GetOrdinals(objProperties, dr);

            // fill object with values from datareader
            for( intProperty = 0; intProperty < objProperties.Count; intProperty++)
            {
                // Get the property to set
                objPropertyInfo = (PropertyInfo)objProperties[intProperty];

                // Get its type
                objPropertyType = objPropertyInfo.PropertyType;

                // If property can be set
                if(objPropertyInfo.CanWrite)
                {
                    // If the DataReader contains the column that matches the Properties name
                    if( arrOrdinals[intProperty] != -1)
                    {
                        // Get the Data Value from the data reader
                        objDataValue = dr.GetValue(arrOrdinals[intProperty]);

                        // Get the Dat Value's type
                        objDataType = objDataValue.GetType();

                        if (objDataValue == DBNull.Value)
                        {
                            // set property value to Null
                            objPropertyInfo.SetValue(objObject, Null.SetNull(objPropertyInfo), null);
                        }
                        else if(objPropertyType.Equals(objDataType))
                        {
                            // Property and data objects are the same type
                            objPropertyInfo.SetValue(objObject, objDataValue, null);
                        }
                        else
                        {
                            // business object info class member data type does not match datareader member data type
                            try
                            {
                                // need to handle enumeration conversions differently than other base types
                                if (objPropertyType.BaseType.Equals(typeof(System.Enum)))
                                {
                                    // check if value is numeric and if not convert to integer ( supports databases like Oracle )
                                    if (IsNumeric(objDataValue))
                                        objPropertyInfo.SetValue(objObject, System.Enum.ToObject(objPropertyType, Convert.ToInt32(objDataValue)), null);
                                    else
                                        objPropertyInfo.SetValue(objObject, System.Enum.ToObject(objPropertyType, objDataValue), null);
                                }
                                else if( objPropertyType.FullName.Equals("System.Guid"))
                                {
                                    // guid is not a datatype common across all databases ( ie. Oracle )
                                    objPropertyInfo.SetValue(objObject, Convert.ChangeType(new Guid(objDataValue.ToString()), objPropertyType), null);
                                }
                                else
                                {
                                    // try explicit conversion
                                    objPropertyInfo.SetValue(objObject, Convert.ChangeType(objDataValue, objPropertyType), null);
                                }
                            }
                            catch
                            {
                                objPropertyInfo.SetValue(objObject, Convert.ChangeType(objDataValue, objPropertyType), null);
                            }
                        }
                    }
                    else
                    {
                        // property does not exist in datareader
                    }
                }
            }
        }

        #endregion

        "Public Shared Methods"#region "Public Shared Methods"

        public static ArrayList FillCollection(IDataReader dr, Type objType)
        {
            ArrayList objFillCollection = new ArrayList();
            object objFillObject;

            // iterate datareader
            while(dr.Read())
            {
                // fill business object
                objFillObject = CreateObject(objType, dr);
                // add to collection
                objFillCollection.Add(objFillObject);
            }

            // close datareader
            if (dr != null )
                dr.Close();

            return objFillCollection;
        }

        public static IList FillCollection(IDataReader dr, Type objType, IList objToFill)
        {
            object objFillObject;

            // iterate datareader
            while(dr.Read())
            {
                // fill business object
                objFillObject = CreateObject(objType, dr);
                // add to collection
                objToFill.Add(objFillObject);
            }

            // close datareader
            if(dr != null)
                dr.Close();
            return objToFill;
        }

        public static List<T> FillCollection<T>(IDataReader dr)
        {
            return FillCollection<T>(dr, true);
        }

        public static List<T> FillCollection<T>(IDataReader dr, bool ManageDataReader)
        {
            List<T> objFillCollection = new List<T>();
            T objFillObject;

            // iterate datareader
            while(dr.Read())
            {
                // fill business object
                objFillObject = CreateObject<T>(dr);
                // add to collection
                objFillCollection.Add(objFillObject);
            }

            if (ManageDataReader)
            {
                // close datareader
                if (dr != null)
                    dr.Close();
            }
            return objFillCollection;
        }

        public static IList<T> FillCollection<T>(IDataReader dr, IList<T> objToFill)
        {
            T objFillObject;

            // iterate datareader
            while(dr.Read())
            {
                // fill business object
                objFillObject = CreateObject<T>(dr);
                // add to collection
                objToFill.Add(objFillObject);
            }

            // close datareader
            if (dr != null)
                dr.Close();

            return objToFill;
        }

        public static List<T> FillCollection<T>(IDataReader dr, ref int totalRecords)
        {
            List<T> objFillCollection = new List<T>();
            T objFillObject;

            try
            {
                // iterate first datareader to fill collection
                while(dr.Read())
                {
                    // fill business object
                    objFillObject = CreateObject<T>(dr);
                    // add to collection
                    objFillCollection.Add(objFillObject);
                }

                if(dr.NextResult())
                {
                    // Get the total no of records from the second result
                    totalRecords = Globals.GetTotalRecords(dr);
                }
            }
            catch(Exception exc)
            {
                // Exceptions.LogException(exc)
            }
            finally
            {
                // close datareader
                if(dr != null)
                    dr.Close();
            }

            return objFillCollection;
        }

        public static IDictionary<int, T> FillDictionary<T>(IDataReader dr)
        {
            IDictionary<int, T> objFillDictionary = new Dictionary<int, T>();
            T objFillObject;

            // iterate datareader
            while(dr.Read())
            {
                // fill business object
                objFillObject = CreateObject<T>(dr);

                // add to dictionary
                if(objFillObject != null)
                    objFillDictionary.Add(((IHydratable)objFillObject).KeyID, objFillObject);
            }
            // close datareader
            if(dr != null)
                dr.Close();

            return objFillDictionary;
        }

        public static IDictionary<int, T> FillDictionary<T>(IDataReader dr, ref IDictionary<int, T> objToFill)
        {
            T objFillObject;

            // iterate datareader
            while(dr.Read())
            {
                // fill business object
                objFillObject = CreateObject<T>(dr);

                // add to dictionary
                if(objFillObject != null)
                    objToFill.Add(((IHydratable)objFillObject).KeyID, objFillObject);
            }

            // close datareader
            if (dr != null)
                dr.Close();

            return objToFill;
        }

        public static object FillObject(IDataReader dr, Type objType)
        {
            return FillObject(dr, objType, true);
        }

        public static object FillObject(IDataReader dr, Type objType, bool ManageDataReader)
        {
            object objFillObject;

            if (dr.Read())
            {
                // create custom business object
                objFillObject = CreateObject(objType, dr);
            }
            else
            {
                objFillObject = null;
            }

            if(ManageDataReader)
            {
                // close datareader
                if (dr != null)
                    dr.Close();
            }

            return objFillObject;
        }

        public static T FillObject<T>(IDataReader dr)
        {
            return FillObject<T>(dr, true);
        }

        public static T FillObject<T>(IDataReader dr, bool ManageDataReader)
        {
            T objFillObject;

            if (dr.Read())
            {
                // create custom business object
                objFillObject = CreateObject<T>(dr);
            }
            else
            {
                objFillObject = default(T);
            }
            if(ManageDataReader)
            {
                // close datareader
                if (dr != null)
                    dr.Close();
            }

            return objFillObject;
        }
        
        public static ArrayList GetPropertyInfo(Type objType)
        {
            // Use the cache because the reflection used later is expensive
            ArrayList objProperties = (ArrayList)DataCache.GetCache(objType.FullName);

            if(objProperties == null)
            {
                objProperties = new ArrayList();
                foreach(PropertyInfo objProperty in objType.GetProperties())
                {
                    objProperties.Add(objProperty);
                }
                DataCache.SetCache(objType.FullName, objProperties);
            }

            return objProperties;
        }

        public static object InitializeObject(object objObject, Type objType)
        {
            PropertyInfo objPropertyInfo;
            object objValue;
            int intProperty;

            // get properties for type
            ArrayList objProperties = GetPropertyInfo(objType);

            // initialize properties
            for (intProperty = 0; intProperty < objProperties.Count; intProperty++)
            {
                objPropertyInfo = (PropertyInfo)objProperties[intProperty];
                if (objPropertyInfo.CanWrite)
                {
                    objValue = Null.SetNull(objPropertyInfo);
                    objPropertyInfo.SetValue(objObject, objValue, null);
                }
            }

            return objObject;
        }

        #endregion
    }
}

DataCache.cs

using  System;
using  System.Web;

namespace  Portal
{
     public   class  DataCache
    {
         public   static   object  GetCache( string  CacheKey)
        {
             //  System.Web.Caching.Cache = HttpRuntime.Cache;
             //  System.Web.Caching.Cache objCache;
             return  HttpRuntime.Cache[CacheKey];
        }

         public   static   void  SetCache( string  CacheKey,  object  objObject)
        {
             //  System.Web.Caching.Cache = HttpRuntime.Cache;
             //  System.Web.Caching.Cache objCache;
            HttpRuntime.Cache.Insert(CacheKey, objObject);
        }
    }
}

Null.cs

using  System;
using  System.Data;
using  System.Reflection;

namespace  Portal
{
     public   class  Null
    {
         public   static   short  NullShort
        {
             get  {  return   - 1 ;}
        }

         public   static   int  NullInteger
        {
             get  { return   - 1 ;}
        }

         public   static   byte  NullByte
        {
             get  {  return   255 ; }
        }

         public   static  Single NullSingle
        {
             get  {  return  Single.MinValue; }
        }

         public   static   double  NullDouble
        {
             get  {  return   double .MinValue; }
        }

         public   static   decimal  NullDecimal
        {
             get  {  return   decimal .MinValue; }
        }

         public   static  DateTime NullDate
        {
             get  {  return  DateTime.MinValue; }
        }
        
         public   static   string  NullString
        {
             get  {  return   "" ; }
        }

         public   static   bool  NullBoolean
        {
             get  {  return   false ; }
        }

         public   static  Guid NullGuid
        {
             get  {  return  Guid.Empty; }
        }

         //  sets a field to an application encoded null value ( used in BLL layer )
         public   static   object  SetNull( object  objValue,  object  objField)
        {
             object  rtn  =   null ; 
             if  (objValue  ==  DBNull.Value)
            {
                 if  (objField  is  Int16)
                    rtn  =  NullShort;
                 else   if (objField  is  Byte)
                    rtn  =  NullByte;
                 else   if (objField  is  Int32)
                    rtn  =  NullInteger;
                 else   if (objField  is  Single)
                    rtn  =  NullSingle;
                 else   if (objField  is  Double)
                    rtn  =  NullDouble;
                 else   if (objField  is  Decimal)
                    rtn  =  NullDecimal;
                 else   if (objField  is  DateTime)
                    rtn  =  NullDate;
                 else   if (objField  is   string )
                    rtn  =  NullString;
                 else   if (objField  is  Boolean)
                    rtn  =  NullBoolean;
                 else   if (objField  is  Guid)
                    rtn  =  NullGuid;
                 else   //  complex object
                    rtn  =   null ;
            }
             else     
            {
                 //  return value
                rtn  =  objValue;
            }
             return  rtn;
        }

         //  sets a field to an application encoded null value ( used in BLL layer )
         public   static   object  SetNull(PropertyInfo objPropertyInfo)
        {
             object  rtn  =   null ;
             switch (objPropertyInfo.PropertyType.ToString())
            {
                 case   " System.Int16 "  :
                    rtn  =  NullShort;
                     break ;
                 case   " System.Int32 "  :
                 case   " System.Int64 "  :
                    rtn  =  NullInteger;
                     break ;
                 case   " system.Byte "  :
                    rtn  =  NullByte;
                     break ;
                 case   " System.Single "  :
                    rtn  =  NullSingle;
                     break ;
                 case   " System.Double "  :
                    rtn  =  NullDouble;
                     break ;
                 case   " System.Decimal "  :
                    rtn  =  NullDecimal;
                     break ;
                 case   " System.DateTime "  :
                    rtn  =  NullDate;
                     break ;
                 case   " System.String "  :
                 case   " System.Char "  :
                    rtn  =  NullString;
                     break ;
                 case   " System.Boolean "  :
                    rtn  =  NullBoolean;
                     break ;
                 case   " System.Guid "  :
                    rtn  =  NullGuid;
                     break ;
                 default  :
                     //  Enumerations default to the first entry
                    Type pType  =  objPropertyInfo.PropertyType;
                     if (pType.BaseType.Equals( typeof (System.Enum)))
                    {
                        System.Array objEnumValues  =  System.Enum.GetValues(pType);
                        Array.Sort(objEnumValues);
                        rtn  =  System.Enum.ToObject(pType, objEnumValues.GetValue( 0 ));
                    }
                     else   //  complex object
                    {
                        rtn  =   null ;
                    }
                     break ;
            }
             return  rtn;
        }

         //  convert an application encoded null value to a database null value ( used in DAL )
         public   static   object  GetNull( object  objField,  object  objDBNull)
        {
             object  rtn  =  objField;
             if  (objField  ==   null )
            {
                rtn  =  objDBNull;
            }
             else   if  (objField  is  Byte)
            {
                 if  (Convert.ToByte(objField)  ==  NullByte)
                    rtn  =  objDBNull;
            }
             else   if  (objField  is  Int16)
            {
                 if  (Convert.ToInt16(objField)  ==  NullShort)
                    rtn  =  objDBNull;
            }
             else   if  (objField  is  Int32)
            {
                 if  (Convert.ToInt32(objField)  ==  NullInteger)
                    rtn  =  objDBNull;
            }
             else   if  (objField  is  Single)
            {
                 if  (Convert.ToSingle(objField)  ==  NullSingle)
                    rtn  =  objDBNull;
            }
             else   if  (objField  is  Double)
            {
                 if  (Convert.ToDouble(objField)  ==  NullDouble)
                    rtn  =  objDBNull;
            }
             else   if  (objField  is  Decimal)
            {
                 if  (Convert.ToDecimal(objField)  ==  NullDecimal)
                    rtn  =  objDBNull;
            }
             else   if  (objField  is  DateTime)
            {
                 //  compare the Date part of the DateTime with the DatePart of the NullDate ( this avoids subtle time differences )
                 if  (Convert.ToDateTime(objField).Date  ==  NullDate.Date)
                    rtn  =  objDBNull;
            }
             else   if  (objField  is  String)
            {
                 if  (objField  ==   null )
                    rtn  =  objDBNull;
                 else
                     if  (objField.ToString()  ==  NullString)
                        rtn  =  objDBNull;
            }
             else   if  (objField  is  Boolean)
            {
                 if  (Convert.ToBoolean(objField)  ==  NullBoolean)
                    rtn  =  objDBNull;
            }
             else   if  (objField  is  Guid)
            {
                 if  ((Guid)objField  ==  NullGuid)
                    rtn  =  objDBNull;
            }
             return  rtn;
        }

         //  checks if a field contains an application encoded null value
         public   static   bool  IsNull( object  objField)
        {
             bool  rtn  =   false ;
             if  (objField  !=   null )
            {
                 if (objField  is  Int32)
                    rtn  =  objField.Equals(NullInteger);
                 else   if  (objField  is  Int16)
                    rtn  =  objField.Equals(NullShort);
                 else   if  (objField  is  Byte)
                    rtn  =  objField.Equals(NullByte);
                 else   if  (objField  is  Single)
                    rtn  =  objField.Equals(NullSingle);
                 else   if  (objField  is  Double)
                    rtn  =  objField.Equals(NullDouble);
                 else   if  (objField  is  Decimal)
                    rtn  =  objField.Equals(NullDecimal);
                 else   if  (objField  is  DateTime)
                {
                    DateTime objDate  =  (DateTime)objField;
                    rtn  =  objDate.Date.Equals(NullDate.Date);
                }
                 else   if  (objField  is  String)
                    rtn  =  objField.Equals(NullString);
                 else   if  (objField  is  Boolean)
                    rtn  =  objField.Equals(NullBoolean);
                 else   if  (objField  is  Guid)
                    rtn  =  objField.Equals(NullGuid);
                 else   //  complex object
                    rtn  =   false ;
            }
             else
                rtn  =   true ;
             return  rtn;
        }
    }
}