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
