Professional IronPython

LISTINg 14-3: 
 Creating a class to handle dynamic objects
// Any dynamic object you create must implement IDynamicObject.
public class ADynamicObject : DynamicObject 
{
// Calls a method provided with the dynamic object.
public override bool TryInvokeMember(InvokeMemberBinder binder, 
object[] args, out object result)
{
Console.WriteLine(“InvokeMember of method {0}.”, binder.Name);
if (args.Length > 0)
{
Console.WriteLine(“\tMethod call has {0} arguments.”, args.Length);
for (int i = 0; i < args.Length; i++)
Console.WriteLine(“\t\tArgument {0} is {1}.”, i, args[i]);
}
result = binder.Name;
return true;
}
// Gets the property value.
public override bool TryGetMember(GetMemberBinder binder,
out object result)
{
Console.WriteLine(“GetMember of property {0}.”, binder.Name);
result = binder.Name;
return true;
}
// Sets the property value.
public override bool TrySetMember(SetMemberBinder binder, object value)
{
continues
548592c14.indd 301
2/24/10 12:49:08 PM
www.finebook.ir

---

302
❘
CHAPTER 14
InteractIng wIth the DLr
Console.WriteLine(“SetMember of property {0} to {1}.”,
binder.Name, value);
return true; 
}
}
In this case, the code provides the ability to call methods, get property values, and set property values. 
Amazingly, DLR automatically calls the correct method without any hints from you.
Notice that each of the methods uses a different binder class: 
InvokeMemberBinder
, 
GetMemberBinder
, or 
SetMemberBinder
as needed. The binder provides you with information 
about the member of interest. In most cases, you use the member name to locate the member 
within the dynamic object. In this case, the code simply displays the member name onscreen so 
you can see that the code called the correct member.
Two of these methods, 
TryInvokeMember()
and 
TryGetMember()
, return something to the caller. 
It’s important to remember that the data is marshaled, so you must use the 
out
keyword for the 
argument that returns a value or the application will complain later (the compiler may very well 
accept the error without comment). In both cases, the code simply returns the 
binder.Name
value. If 
you were building this dynamic object class for an application, you’d use the 
binder.Name
value to 
access the actual property or method.
When invoking a method, the 
TryInvokeMember()
method receives an array of arguments to use 
with the method call. The code shows how you detect the presence of arguments and then displays 
them onscreen for this example. In an actual application, you’d need to compare the arguments 
provided by the caller against those required by the method to ensure the caller has supplied enough 
arguments of the right type.
All three methods return 
true
. If the code were to return 
false
instead, you’d see a 
RuntimeBinderException
in the caller code. This exception tells the caller that the requested 
method or property doesn’t exist.
When a C# application desires to create a dynamic object, it simply creates an instance of the 
dynamic class. The instance can create properties, methods, or other constructs as needed. 
Listing 14-4 shows an example of how a test application might appear.