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