The dynamic type in C# 4.0 is a welcome addition
to the language. One thing I’ve been doing a lot with it is
to remove explicit Reflection
code that’s often necessary when you ‘dynamically’ need
to walk and object hierarchy. In the past I’ve had a number of ReflectionUtils that used string based expressions
to walk an object hierarchy. With the introduction of dynamic much of the ReflectionUtils
code can be removed for cleaner
code that runs considerably faster
to boot. The old Way - Reflection Here’s a really contrived example, but assume for a second, you’d want
to dynamically retrieve a Page.Request.Url.AbsoluteUrl based on a Page instance in an ASP.NET Web Page request. The strongly typed version looks
like this: string path = Page.Request.Url.AbsolutePath;
Now assume for a second that Page wasn’t available as a strongly typed instance and all you had was an object reference
to start with and you couldn’t cast it (right
I said this was contrived :-))
If you’re using raw Reflection
code to retrieve this you’d end up writing 3 sets of Reflection calls using GetValue(). Here’s some internal
code I use
to retrieve Property values as part of ReflectionUtils:
/// <summary>
/// Retrieve a property value from an object dynamically. This is a simple version
/// that uses Reflection calls directly. It doesn't support indexers.
/// </summary>
/// <param name="instance">Object
to make the call on</param>
/// <param name="property">Property
to retrieve</param>
/// <returns>Object - cast
to proper type</returns>
public static object GetProperty(object instance, string property)
{
return instance.GetType().GetProperty(property, ReflectionUtils.MemberAccess).GetValue(instance, null);
}
If you want more control over properties and support both fields and properties as well as array indexers a little more work is required:
/// <summary>
/// Parses Properties and Fields including Array and Collection references.
/// Used internally for the 'Ex' Reflection methods.
/// </summary>
/// <param name="Parent"></param>
/// <param name="Property"></param>
/// <returns></returns>
private static object GetPropertyInternal(object Parent, string Property)
{
if (Property == "this" || Property == "me")
return Parent;
object result = null;
string pureProperty = Property;
string indexes = null;
bool isArrayOrCollection = false;
// Deal with Array Property
if (Property.IndexOf("[") > -1)
{
pureProperty = Property.Substring(0, Property.IndexOf("["));
indexes = Property.Substring(Property.IndexOf("["));
isArrayOrCollection = true;
}
// Get the member
MemberInfo member = Parent.GetType().GetMember(pureProperty, ReflectionUtils.MemberAccess)[0];
if (member.MemberType == MemberTypes.Property)
result = ((PropertyInfo)member).GetValue(Parent, null);
else
result = ((FieldInfo)member).GetValue(Parent);
if (isArrayOrCollection)
{
indexes = indexes.Replace("[", string.Empty).Replace("]", string.Empty);
if (result is Array)
{
int Index = -1;
int.TryParse(indexes, out Index);
result = CallMethod(result, "GetValue", Index);
}
else if (result is ICollection)
{
if (indexes.StartsWith("\""))
{
// String Index
indexes = indexes.Trim('\"');
result = CallMethod(result, "get_Item", indexes);
}
else
{
// assume numeric index
int index = -1;
int.TryParse(indexes, out index);
result = CallMethod(result, "get_Item", index);
}
}
}
return result;
}
/// <summary>
/// Returns a property or field value using a base object and sub members including . syntax.
/// For example, you can access: oCustomer.oData.Company with (this,"oCustomer.oData.Company")
/// This method also supports indexers in the Property value such as:
/// Customer.DataSet.Tables["Customers"].Rows[0]
/// </summary>
/// <param name="Parent">Parent object
to 'start' parsing from. Typically this will be the Page.</param>
/// <param name="Property">The property
to retrieve. Example: 'Customer.Entity.Company'</param>
/// <returns></returns>
public static object GetPropertyEx(object Parent, string Property)
{
Type type = Parent.GetType();
int at = Property.IndexOf(".");
if (at < 0)
{
// Complex parse of the property
return GetPropertyInternal(Parent, Property);
}
// Walk the . syntax - split into current object (Main) and further parsed objects (Subs)
string main = Property.Substring(0, at);
string subs = Property.Substring(at + 1);
// Retrieve the next . section of the property
object sub = GetPropertyInternal(Parent, main);
// Now go parse the left over sections
return GetPropertyEx(sub, subs);
}
As you can see there’s a fair bit of
code involved into retrieving a property or field value reliably especially if you want
to support array indexer syntax. This method is then used by a variety of routines
to retrieve individual properties including one called GetPropertyEx() which can walk the dot syntax hierarchy easily.
Anyway with ReflectionUtils
I can retrieve Page.Request.Url.AbsolutePath using
code like this:
string url = ReflectionUtils.GetPropertyEx(Page, "Request.Url.AbsolutePath") as string;
This works fine, but is bulky
to write and of course requires that
I use my custom routines. It’s also quite slow as the
code in GetPropertyEx does all sorts of string parsing
to figure out which members
to walk in the hierarchy.
Enter dynamic – way easier!
.NET 4.0’s dynamic type makes the above really easy. The following
code is all that it takes:
object objPage = Page; // force
to object for contrivance :)
dynamic page = objPage; // convert
to dynamic from untyped object
string scriptUrl = page.Request.Url.AbsolutePath;
The dynamic type assignment in the first two lines turns the strongly typed Page object into a dynamic. The first assignment is just part of the contrived example
to force the strongly typed Page reference into an untyped value
to demonstrate the dynamic member access. The next line then just creates the dynamic type from the Page reference which allows you
to access any public properties and methods easily. It also lets you access any child properties as dynamic types so when you look at Intellisense you’ll see something
like this when typing Request.:
In other words any dynamic value access on an object returns another dynamic object which is what allows the walking of the hierarchy chain.
Note also that the result value doesn’t have
to be explicitly cast as string in the
code above – the compiler is perfectly happy without the cast in this case inferring the target type based on the type being assigned
to. The dynamic conversion automatically handles the cast when making the final assignment which is nice making for natural syntnax that looks *exactly*
like the fully typed syntax, but is completely dynamic.
Note that you can also use indexers in the same natural syntax so the following also works on the dynamic page instance:
string scriptUrl = page.Request.ServerVariables["SCRIPT_NAME"];
The dynamic type is going
to make a lot of Reflection
code go away as it’s simply so much nicer
to be able
to use natural syntax
to write out
code that previously required nasty Reflection syntax.
Another interesting thing about the dynamic type is that it actually works considerably faster than Reflection. Check out the following methods that check performance:
void Reflection()
{
Stopwatch stop = new Stopwatch();
stop.Start();
for (int
i = 0;
i < reps; i++)
{
// string url = ReflectionUtils.GetProperty(Page,"Title") as string;// "Request.Url.AbsolutePath") as string;
string url = Page.GetType().GetProperty("Title", ReflectionUtils.MemberAccess).GetValue(Page, null) as string;
}
stop.Stop();
Response.Write("Reflection: " + stop.ElapsedMilliseconds.ToString());
}
void Dynamic()
{
Stopwatch stop = new Stopwatch();
stop.Start();
dynamic page = Page;
for (int
i = 0;
i < reps; i++)
{
string url = page.Title; //Request.Url.AbsolutePath;
}
stop.Stop();
Response.Write("Dynamic: " + stop.ElapsedMilliseconds.ToString());
}
The dynamic
code runs in 4-5 milliseconds while the Reflection
code runs around 200+ milliseconds! There’s a bit of overhead in the first dynamic object call but subsequent calls are blazing fast and performance is actually much better than manual Reflection.
Dynamic is definitely a huge win-win situation when you need dynamic access
to objects at runtime.© Rick Strahl, West Wind Technologies, 2005-2010Posted in .NET CSharp
