1using System;
  2using System.Reflection;
  3
  4namespace IFNuke.Data
  5...{    
  6    //*********************************************************************
  7    //
  8    // Null Class
  9    //
 10    // Class for dealing with the translation of database null values.
 11    //
 12    //*********************************************************************
 13    
 14    [Obsolete("will replaced by MagicValue later.")]
 15    public class Null
 16    ...{        
 17        // define application encoded null values
 18        public static short NullShort
 19        ...{
 20            get
 21            ...{
 22                return - 1;
 23            }
 24        }
 25        public static int NullInteger
 26        ...{
 27            get
 28            ...{
 29                return - 1;
 30            }
 31        }
 32        public static byte NullByte
 33        ...{
 34            get
 35            ...{
 36                return 255;
 37            }
 38        }
 39        public static float NullSingle
 40        ...{
 41            get
 42            ...{
 43                return float.MinValue;
 44            }
 45        }
 46        public static double NullDouble
 47        ...{
 48            get
 49            ...{
 50                return double.MinValue;
 51            }
 52        }
 53        public static decimal NullDecimal
 54        ...{
 55            get
 56            ...{
 57                return decimal.MinValue;
 58            }
 59        }
 60        public static DateTime NullDate
 61        ...{
 62            get
 63            ...{
 64                return DateTime.MinValue;
 65            }
 66        }
 67        public static string NullString
 68        ...{
 69            get
 70            ...{
 71                return "";
 72            }
 73        }
 74        public static bool NullBoolean
 75        ...{
 76            get
 77            ...{
 78                return false;
 79            }
 80        }
 81        public static Guid NullGuid
 82        ...{
 83            get
 84            ...{
 85                return Guid.Empty;
 86            }
 87        }
 88        
 89        // sets a field to an application encoded null value ( used in BLL layer )
 90        public static object SetNull(object objValue, object objField)
 91        ...{
 92            object returnValue;
 93            if (Convert.IsDBNull(objValue))
 94            ...{
 95                if (objField is short)
 96                ...{
 97                    returnValue = NullShort;
 98                }
 99                else if (objField is byte)
100                ...{
101                    returnValue = NullByte;
102                }
103                else if (objField is int)
104                ...{
105                    returnValue = NullInteger;
106                }
107                else if (objField is Single)
108                ...{
109                    returnValue = NullSingle;
110                }
111                else if (objField is double)
112                ...{
113                    returnValue = NullDouble;
114                }
115                else if (objField is decimal)
116                ...{
117                    returnValue = NullDecimal;
118                }
119                else if (objField is DateTime)
120                ...{
121                    returnValue = NullDate;
122                }
123                else if (objField is string)
124                ...{
125                    returnValue = NullString;
126                }
127                else if (objField is bool)
128                ...{
129                    returnValue = NullBoolean;
130                }
131                else if (objField is Guid)
132                ...{
133                    returnValue = NullGuid;
134                }
135                else // complex object
136                ...{
137                    returnValue = null;
138                }
139            }
140            else // return value
141            ...{
142                returnValue = objValue;
143            }
144            return returnValue;
145        }
146        
147        // sets a field to an application encoded null value ( used in BLL layer )
148        public static object SetNull(PropertyInfo objPropertyInfo)
149        ...{
150            object returnValue;
151            switch (objPropertyInfo.PropertyType.ToString())
152            ...{
153                case "System.Int16":
154                    returnValue = NullShort;
155                    break;
156                case "System.Int32":
157                case "System.Int64":
158                    returnValue = NullInteger;
159                    break;
160                case "system.Byte":
161                    returnValue = NullByte;
162                    break;
163                case "System.Single":
164                    returnValue = NullSingle;
165                    break;
166                case "System.Double":
167                    returnValue = NullDouble;
168                    break;
169                case "System.Decimal":
170                    returnValue = NullDecimal;
171                    break;
172                case "System.DateTime":
173                    returnValue = NullDate;
174                    break;
175                case "System.String":
176                case "System.Char":
177                    returnValue = NullString;
178                    break;
179                case "System.Boolean":
180                    returnValue = NullBoolean;
181                    break;
182                case "System.Guid":
183                    returnValue = NullGuid;
184                    break;
185                default:
186                    // Enumerations default to the first entry
187                    Type pType = objPropertyInfo.PropertyType;
188                    if (pType.BaseType.Equals(typeof(System.Enum)))
189                    ...{
190                        System.Array objEnumValues = System.Enum.GetValues(pType);
191                        Array.Sort(objEnumValues);
192                        returnValue = System.Enum.ToObject(pType, objEnumValues.GetValue(0));
193                    }
194                    else // complex object
195                    ...{
196                        returnValue = null;
197                    }
198                    break;
199            }
200            return returnValue;
201        }
202        
203        // convert an application encoded null value to a database null value ( used in DAL )
204        public static object GetNull(object objField, object objDBNull)
205        ...{
206            object returnValue;
207            returnValue = objField;
208            if (objField == null)
209            ...{
210                returnValue = objDBNull;
211            }
212            else if (objField is byte)
213            ...{
214                if (Convert.ToByte(objField) == NullByte)
215                ...{
216                    returnValue = objDBNull;
217                }
218            }
219            else if (objField is short)
220            ...{
221                if (Convert.ToInt16(objField) == NullShort)
222                ...{
223                    returnValue = objDBNull;
224                }
225            }
226            else if (objField is int)
227            ...{
228                if (Convert.ToInt32(objField) == NullInteger)
229                ...{
230                    returnValue = objDBNull;
231                }
232            }
233            else if (objField is Single)
234            ...{
235                if (Convert.ToSingle(objField) == NullSingle)
236                ...{
237                    returnValue = objDBNull;
238                }
239            }
240            else if (objField is double)
241            ...{
242                if (Convert.ToDouble(objField) == NullDouble)
243                ...{
244                    returnValue = objDBNull;
245                }
246            }
247            else if (objField is decimal)
248            ...{
249                if (Convert.ToDecimal(objField) == NullDecimal)
250                ...{
251                    returnValue = objDBNull;
252                }
253            }
254            else if (objField is DateTime)
255            ...{
256                // compare the Date part of the DateTime with the DatePart of the NullDate ( this avoids subtle time differences )
257                if (Convert.ToDateTime(objField).Date == NullDate.Date)
258                ...{
259                    returnValue = objDBNull;
260                }
261            }
262            else if (objField is string)
263            ...{
264                if (objField == null)
265                ...{
266                    returnValue = objDBNull;
267                }
268                else
269                ...{
270                    if (objField.ToString() == NullString)
271