Recently while writing
the monotonous code for pulling data out of a DataReader to hydrate some objects in an application I suddenly wondered "is this really necessary?" You've probably asked yourself
the same question, and many of you have: - Used a code generator - Used a ORM such as Entity Framework - Wrote
the code anyway because you like busy work In most of
the cases I've dealt with when making a call to a stored procedure
the column names match up with
the properties of
the object I am hydrating. Sure that isn't always
the case, but most of
the time it's 1 to 1 mapping. Given that fact I whipped up
the following method of hydrating my objects without having write
all of
the code. First I'll show
the code, and then explain what it is doing. /// <summary> /// Abstract base class for
all Shared objects. /// </summary> /// <typeparam name="T"></typeparam> [Serializable, DataContract(Name = "{0}SharedBase")] public abstract class SharedBase<T> where T : SharedBase<T> { private static List<PropertyInfo> cachedProperties; /// <summary> /// Hydrates derived class with values from record. /// </summary> /// <param name="dataRecord"></param> /// <param name="instance"></param> public static void Hydrate(IDataRecord dataRecord, T instance) { var instanceType = instance.GetType(); //Caching properties to avoid repeated calls to GetProperties. //Noticable performance gains when processing same types repeatedly. if (cachedProperties == null) { cachedProperties = instanceType.GetProperties().ToList(); } foreach (var property in cachedProperties) { if (!dataRecord.ColumnExists(property.Name)) continue; var ordinal = dataRecord.GetOrdinal(property.Name); var isNullable = property.PropertyType.IsGenericType && property.PropertyType.GetGenericTypeDefinition() == typeof (Nullable<>); var isNull = dataRecord.IsDBNull(ordinal); var propertyType = property.PropertyType; if (isNullable) { if (!string.IsNullOrEmpty(propertyType.FullName)) { var nullableType = Type.GetType(propertyType.FullName); propertyType = nullableType != null ? nullableType.GetGenericArguments()[0] : propertyType; } } switch (Type.GetTypeCode(propertyType)) { case TypeCode.Int32: property.SetValue(instance, (isNullable && isNull) ? (int?) null : dataRecord.GetInt32(ordinal), null); break; case TypeCode.Double: property.SetValue(instance, (isNullable && isNull) ? (double?) null : dataRecord.GetDouble(ordinal), null); break; case TypeCode.Boolean: property.SetValue(instance, (isNullable && isNull) ? (bool?) null : dataRecord.GetBoolean(ordinal), null); break; case TypeCode.String: property.SetValue(instance, (isNullable && isNull) ? null : isNull ? null : dataRecord.GetString(ordinal), null); break; case TypeCode.Int16: property.SetValue(instance, (isNullable && isNull) ? (int?) null : dataRecord.GetInt16(ordinal), null); break; case TypeCode.DateTime: property.SetValue(instance, (isNullable && isNull) ? (DateTime?) null : dataRecord.GetDateTime(ordinal), null); break; } } } } Here is a class which utilizes
the above: [Serializable] [DataContract] public class
foo : SharedBase<foo> { [DataMember] public int? ID { get; set; } [DataMember] public string Name { get; set; } [DataMember] public string Description { get; set; } [DataMember] public string Subject { get; set; } [DataMember] public string Body { get; set; } public foo(IDataRecord record) { Hydrate(record, this); } public foo() {} } Explanation: - Class
foo inherits from SharedBase specifying itself as
the type. (NOTE SharedBase is abstract here in
the event we want to provide additional methods which could be overridden by
the instance class) public class
foo : SharedBase<foo> - One of
the foo class constructors accepts a data record which then calls
the Hydrate method on SharedBase passing in
the record and itself. public foo(IDataRecord record) { Hydrate(record, this); } - Hydrate method on SharedBase will use reflection on
the object passed in to determine its properties. At
the same time, it will effectively cache these properties to avoid repeated expensive reflection calls public static void Hydrate(IDataRecord dataRecord, T instance) { var instanceType = instance.GetType(); //Caching properties to avoid repeated calls to GetProperties. //Noticable performance gains when processing same types repeatedly. if (cachedProperties == null) { cachedProperties = instanceType.GetProperties().ToList(); } . . . - Hydrate method on SharedBase will iterate each property on
the object and determine if a column with matching name exists in data record foreach (var property in cachedProperties) { if (!dataRecord.ColumnExists(property.Name)) continue; var ordinal = dataRecord.GetOrdinal(property.Name); . . . NOTE: ColumnExists is an extension method I put on IDataRecord which I’ll include at
the end of this post. - Hydrate method will determine if
the property is nullable and whether
the value in
the corresponding column of
the data record has a null value var isNullable = property.PropertyType.IsGenericType && property.PropertyType.GetGenericTypeDefinition() == typeof (Nullable<>); var isNull = dataRecord.IsDBNull(ordinal); var propertyType = property.PropertyType; . . . - If Hydrate method determines
the property is nullable it will determine
the underlying type and set propertyType accordingly - Hydrate method will set
the value of
the property based upon
the propertyType That’s it!!!
The magic here is in a few places. First, you may have noticed
the following: public abstract class SharedBase<T> where T : SharedBase<T> This says that SharedBase can be created with any type and that for each type it will have it’s own instance. This is important because of
the static members within SharedBase. We want this behavior because we are caching
the properties for each type. If we did not handle things in this way only 1 type could be cached at a time, or, we’d need to create a collection that allows us to cache
the properties for each type = not very elegant. Second, in
the constructor for
foo you may have noticed this (literally): public foo(IDataRecord record) { Hydrate(record, this); } I wanted
the code for auto-hydrating to be as simple as possible. At first I wasn’t quite sure how I could call Hydrate on SharedBase within an instance of
the class and pass in
the instance itself. Fortunately simply passing in “this” does
the trick. I wasn’t sure it would work until I tried it out, and fortunately it did. So, to actually use this feature when utilizing ADO.NET you’d do something like
the following: public List<foo> GetFoo(int? fooId) { List<foo> fooList; const string uspName = "usp_GetFoo"; using (var conn = new SqlConnection(_dbConnection)) using (var cmd = new SqlCommand(uspName, conn)) { cmd.CommandType = CommandType.StoredProcedure; cmd.Parameters.Add(new SqlParameter("@FooID", SqlDbType.Int) {Direction = ParameterDirection.Input, Value = fooId}); conn.Open(); using (var dr = cmd.ExecuteReader()) { fooList= (from row in dr.Cast<DbDataRecord>() select new foo(row) ).ToList(); } } return fooList; } Nice! Instead of having line after line manually assigning values from data record to an object you simply create a new instance and pass in
the data record. Note that there are certainly instances where columns returned from stored procedure do not always match up with property names. In this scenario you can still use
the above method and simply do your manual assignments afterward.
