Light non-trivial introductory example of reusability

There's a possibility that we need to add somefunctionality to the existing library but we are not in a position tochange that library. One possible reason why we can't change thatlibrary could be that such a library is copyright protected. So wecan't rely on our knowledge of IL and reengineer it. Luckily there is away to achieve our goals and leave that library in its current shape.Our example is an arithmetic tree. The purpose of arithmetic tree is tobuild OO representation of arithmetic expression. Its structure is abinary tree where leaf nodes represent numeric values and other nodesrepresent operators. We have two types of nodes – operators and numbersand they are instances of different classes. So we are dealing with anon-trivial example. Very nice example of arithmetic tree is presentedin article Polymorphism in C++ by Bartosz Milewski, naturally it waswritten in C++ and we will have to translate it to C#.

public abstract class ArithmeticNode
{
public abstract double Calculate();
}
public class NumericNode:ArithmeticNode
{
double _num;
public NumericNode(double num){_num = num;}
public override double Calculate()
{
return _num;
}
}
public abstract class BinaryNode:ArithmeticNode
{
protected ArithmeticNode _Left;
protected ArithmeticNode _Right;
public BinaryNode(ArithmeticNode mLeft, ArithmeticNode mRight)
{
_Left = mLeft;
_Right = mRight;
}
}
public class AddNode:BinaryNode
{
public AddNode(ArithmeticNode mLeft,
ArithmeticNode mRight):base(mLeft, mRight){}
public override double Calculate()
{
return _Left.Calculate() + _Right.Calculate();
}
}
public class MultiplyNode:BinaryNode
{
public MultiplyNode(ArithmeticNode mLeft,
ArithmeticNode mRight):base(mLeft, mRight) {}
public override double Calculate()
{
return _Left.Calculate() * _Right.Calculate();
}
}
public class DeductNode:BinaryNode
{
public DeductNode(ArithmeticNode mLeft,
ArithmeticNode mRight):base(mLeft, mRight){}
public override double Calculate()
{
return _Left.Calculate() – _Right.Calculate();
}
}
public class DivideNode:BinaryNode
{
public DivideNode(ArithmeticNode mLeft,
ArithmeticNode mRight):base(mLeft, mRight){}
public override double Calculate()
{
return _Left.Calculate() / _Right.Calculate();
}
}

As we can see we have hierarchy of classes andone very elegant idea which is unfortunately not mine, I justtranslated it to C#. To build such a tree we usually produce some kindof parser, but to make things simple we will skip parser and build itmanually, like this :

ArithmeticNode n1 = new AddNode(new NumericNode(1.0), new NumericNode(2.0));
ArithmeticNode n2 = new MultiplyNode(n1, new NumericNode(3.0));
double x = n2.Calculate ();

That would be (1 + 2) * 3. With tree comesfree recursion and to find out what is the result we just need to callCalculate method of the root node.

Now imagine that we are assigned to a projectwhere we should make simple arithmetic calculator. So we need parserand GUI and we may use that library, lets imagine that library is freeor that we will acquire license to use it. Unfortunately, specificationsays that arithmetic tree must print arithmetic expression. Sinceclasses are not sealed we can make them visitable and use Visitorpattern. So we will inherit from each class and add accept method.

Just in time inheritance

Repetitive task of extending all classes andadding accept method is boring so we will automate it. Even better, wewill use Reflection.Emit and extend dynamically only when and what isneeded. To make invocation easier we will use interface. That was theproject plan and now we can write the code. After few minutes thecoding is done (OK I had something similar already written) and this isthe code :

using System;
using System.Reflection;
using System.Reflection.Emit;
using System.Threading;
public interface IVisitable
{
void Accept(IVisitor v);
}
public interface IVisitor
{
void Visit(IVisitable v);
}
public class VisitableWrapper
{
static System.Collections.Hashtable _assembliesHolder =
System.Collections.Hashtable.Synchronized(new System.Collections.Hashtable());
IVisitable _instance;

public object Current
{
get{
return _instance;
}
set{
_instance = build(value);
}
}
IVisitable build(object current)
{
Type restype;
IVisitable result;
Type currentType = current.GetType();
string theName = "Visitable" + currentType.Name;
if(!_assembliesHolder.ContainsKey(theName)){
AssemblyName assemblyName = new AssemblyName();
assemblyName.Name = theName;
ILGenerator methodIL;
MethodBuilder mb;
AssemblyBuilder assembly =
Thread.GetDomain().DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
ModuleBuilder module = assembly.DefineDynamicModule(theName+".dll");
TypeBuilder visitableClass = module.DefineType(theName, TypeAttributes.Public);
visitableClass.SetParent(currentType);
visitableClass.AddInterfaceImplementation(typeof(IVisitable));
Type[] arg = new Type[0];
ConstructorBuilder cb = visitableClass.DefineConstructor(MethodAttributes.Public,
CallingConventions.Standard,null);
ILGenerator ctorIL = cb.GetILGenerator();
ConstructorInfo bc =
currentType.GetConstructor(new Type[]{typeof(ArithmeticNode),typeof(ArithmeticNode)});
if(bc != null){
ctorIL.Emit(OpCodes.Ldarg_0);
ctorIL.Emit(OpCodes.Ldnull);
ctorIL.Emit(OpCodes.Ldnull);
ctorIL.Emit(OpCodes.Call, bc);
ctorIL.Emit(OpCodes.Ret);
}
else{
bc = currentType.GetConstructor(new Type[]{typeof(double)});
ctorIL.Emit(OpCodes.Ldarg_0);
ctorIL.Emit(OpCodes.Ldc_R8,0.0);
ctorIL.Emit(OpCodes.Call, bc);
ctorIL.Emit(OpCodes.Ret);
arg = new Type[1]{typeof(IVisitor)};
}
arg = new Type[1]{typeof(IVisitor)};
mb = visitableClass.DefineMethod("Accept",
MethodAttributes.Public|MethodAttributes.NewSlot|MethodAttributes.HideBySig|
MethodAttributes.Final|MethodAttributes.Virtual,
typeof(void),arg);
methodIL = mb.GetILGenerator();
ParameterBuilder paramBuilder =
mb.DefineParameter(1,ParameterAttributes.None,"v");
methodIL.DeclareLocal(typeof(object[]));
methodIL.Emit(OpCodes.Ldarg_1);
methodIL.Emit(OpCodes.Callvirt,(new object().GetType()).GetMethod("GetType"));
methodIL.Emit(OpCodes.Ldstr,"Visit");
methodIL.Emit(OpCodes.Ldc_I4,0×100);
methodIL.Emit(OpCodes.Ldnull);
methodIL.Emit(OpCodes.Ldarg_1);
methodIL.Emit(OpCodes.Ldc_I4_1);
methodIL.Emit(OpCodes.Newarr,(new object()).GetType());
methodIL.Emit(OpCodes.Stloc_0);
methodIL.Emit(OpCodes.Ldloc_0);<

br /> me
thodIL.Emit(OpCodes.Ldc_I4_0);
methodIL.Emit(OpCodes.Ldarg_0);
methodIL.Emit(OpCodes.Stelem_Ref);
methodIL.Emit(OpCodes.Ldloc_0);
methodIL.Emit(OpCodes.Callvirt,
typeof(System.Type).GetMethod("InvokeMember",
new Type[]{typeof(string),typeof(BindingFlags),typeof(Binder),
typeof(object),typeof(object[])}));
methodIL.Emit(OpCodes.Pop);
methodIL.Emit(OpCodes.Ret);
restype=visitableClass.CreateType();
result = (IVisitable)Activator.CreateInstance(restype);
_assembliesHolder.Add(theName,result);
}
else{
result = (IVisitable)_assembliesHolder[theName];
restype = result.GetType();
}
FieldInfo[] fields = currentType.GetFields(BindingFlags.NonPublic |
BindingFlags.Instance | BindingFlags.Public | BindingFlags.Static );
for(int i = 0;i < fields.Length;i++){
fields[i].SetValue(result,fields[i].GetValue(current));
}
return result;
}
public void Accept(IVisitor v)
{
_instance.Accept(v);
}
}

As simple as that. Whatever other kind of nodeis added in the future to hierarchy, under the condition that it usesthe prescribed constructor signature, it will work on it too. Interfaceis the same as I used in the article about Visitor (please use Google Idon't have a link). If you're now wondering how I'm going to useVisitor on protected field, don't worry, Reflection will give us accessto non-public fields. Here is the code for the Visitor and test :

using System;
using System.Reflection;
class driver{
static void Main ()
{
ArithmeticNode n1 = new DeductNode(new NumericNode(18.0), new NumericNode(11.0));
ArithmeticNode n2 = new MultiplyNode(n1, new NumericNode(2.0));
ArithmeticNode n3 = new DivideNode(new NumericNode(36.0),new NumericNode(6.0));
ArithmeticNode n4 = new AddNode(n2, n3);
double x = n4.Calculate ();
VisitableWrapper vis = new VisitableWrapper();
vis.Current = n4;
Visitor v =new Visitor();
vis.Accept(v);
System.Console.WriteLine(" = {0}",x);
}
}
class Visitor:IVisitor
{
public void Visit(IVisitable ve)
{
if(ve is BinaryNode){
System.Console.Write("(");
VisitableWrapper temp = new VisitableWrapper();
temp.Current = ve.GetType().GetField("_Left",
BindingFlags.NonPublic |
BindingFlags.Instance).GetValue( ve );
temp.Accept(this);
switch(ve.GetType().ToString())
{
case "VisitableAddNode" : System.Console.Write(" + ");break;
case "VisitableMultiplyNode" : System.Console.Write(" * ");break;
case "VisitableDeductNode" : System.Console.Write(" – ");break;
case "VisitableDivideNode" : System.Console.Write(" / ");break;
}
temp.Current = ve.GetType().GetField("_Right",
BindingFlags.NonPublic |
BindingFlags.Instance).GetValue( ve );
temp.Accept(this);
System.Console.Write(")");
}
else
System.Console.Write(((NumericNode)ve).Calculate());
}
}

Maybe not very elegant, but it works and itsvery RAD. Yes, try this at home and all code in this article comeswithout any kind of warranty.Now probably comes the question why we must use Visitor. For printingonly we can leave it out, but tomorrow we may expect a request for XMLserializable arithmetic tree or who knows what and then we will behappy to have Visitor. See it as quick-fix framework.What if classes in hierarchy were sealed? Then we must do differently.The source of the problem is that we have no access to protected fieldsof BinaryNode. To gain access we may do something like this :

using System;
using System.Reflection;

class GoodBinaryNode
{
BinaryNode _target;
Type targetType;
public GoodBinaryNode(BinaryNode target)
{
_target=target;
targetType = target.GetType();
}
public ArithmeticNode Left
{
get
{
FieldInfo _LeftInfo = targetType.GetField("_Left",
BindingFlags.NonPublic |
BindingFlags.Instance);
return (ArithmeticNode)_LeftInfo.GetValue( _target );
}
}
public ArithmeticNode Right
{
get
{
FieldInfo _RightInfo = targetType.GetField("_Right",
BindingFlags.NonPublic |
BindingFlags.Instance);
return (ArithmeticNode)_RightInfo.GetValue( _target );
}
}
public double Calculate()
{
return _target.Calculate();
}
public void Print()
{
System.Console.Write("(");
if(Left is BinaryNode)
{
GoodBinaryNode temp = new GoodBinaryNode((BinaryNode)Left);
temp.Print();
}
else
{
System.Console.Write(Left.Calculate());
}

switch(targetType.ToString())
{
case "AddNode" : System.Console.Write(" + ");break;
case "MultiplyNode" : System.Console.Write(" * ");break;
case "DeductNode" : System.Console.Write(" – ");break;
case "DivideNode" : System.Console.Write(" / ");break;
}

if(Right is BinaryNode)
{
GoodBinaryNode temp = new GoodBinaryNode((BinaryNode)Right);
temp.Print();
}
else
{
System.Console.Write(Right.Calculate());
}
System.Console.Write(")");
}
}
class driver
{
static void Main ()
{
ArithmeticNode n1 = new DeductNode(new NumericNode(18.0), new NumericNode(11.0));
ArithmeticNode n2 = new MultiplyNode(n1, new NumericNode(2.0));
ArithmeticNode n3 = new DivideNode(new NumericNode(36.0),new NumericNode(6.0));
ArithmeticNode n4 = new AddNode(n2, n3);
double x = n4.Calculate ();
GoodBinaryNode printRoot = new GoodBinaryNode((BinaryNode)n4);
printRoot.Print();
System.Console.WriteLine(" = {0}",x);
}
}

It resembles Decorator pattern a little and ismuch easier to code than that Visitor example, only if we have to passinstance of it to some method which expects one of original hierarchytypes then we are in trouble. But then we are in trouble anyway.Naturally, we will skip Reflection.Emit exercise-we need to code onlyone class. It is much easier to write code in IL than to useReflection.Emit.

Isn't that against OO principles to try togain access to fields or methods which are not meant to be accessedfrom outside? Yes it is, if somebody makes fields inaccessible therecould be reason for that, but if it helps me to write less code then Iwill defend myself with reusability argument. A bit of creative hacking(that kind of hacking which won't make public prosecutor interested inyour activities) is always helpful.I can't remember any more good questions, if you have any, my e-mail isbelow.

Conclusion

As I demonstrated, Reflection andReflection.Emit may be used to achieve interesting things. Naturally,we need to know IL to use Reflection.Emit. Possible areas where itcould be used are AOP or Coordination Contracts. So highly configurableapplications where about everything could be changed at run time arepossible if appropriate OO patterns like Chain of Responsibility areused.About two and a half years ago I went to Microsoft of South Africa(that is where I am staying, but I am not South African) to get my copyof .NET beta 1. They charged me about US$ 5 for three CDs. Today thereis .NET 1.1, which I haven't got yet. Maybe I will go again toMicrosoft of South Africa to get CDs, but this t

ime I am not in ahurry. It looks to me that .NET started to lose its breath andadvantages which it used to have over its competitors. For example,UDDI V2 API client side implementation for .NET is still in beta 1stage! Lot of things have changed in the last two and a half years andin the world of programming changes are very fast.

About Myself

Currently I'm writing for CodeNotes.http://www.codenotes.com and preparing presentation for InternationalWeb Services Conference & Exposition in Toronto, Canada on October14-16, 2003. For more info visit http://www.WowGao.com. If you have anysuggestions, questions my address is filipbulovic@mail.com, I will tryto answer.

Abstract

Reflection allows the developer todynamically manipulate and inspect the members of objects, whichincludes their fields, methods and types. This is a consequence of C#being a managed language.

This Article demonstrates how the developercan use Reflection to dynamically locate and call methods within aclass, including passing the respective parameters to the method andalso manage any error conditions that could arise during this process.

This article requires that you have hadexposure to C# and are comfortable with the language. The tutoriallargely resides in the example provided, where you are shown how amethod can be dynamically invoked using console input.

The Example: Bob?s Burger Barn

Bob?s Burger Barn is quite amodern restaurant that allows it?s customers to order their meals usinga computer terminal. The user logs into the ordering application andsends commands to order what he wants. For example, if a customer wantsto order a burger, he must use the ?burger? command with the followingsyntax:

burger <bun type> <sauce name> <meat type>

Examples:

burger sesame chilli chicken

burger plain ketchup beef

Bob decided that since his Burger Barn?s menuchanges so much, it is wiser for him to allow his ordering applicationas much flexibility as possible. His C# developer recognised his needand made all ordering method invocations and listing completelydynamic.

If a customer wants to order a burger, he types burger<param1><param2><param3>and the ordering application checks to see if it has a method called?burger?. If it does, then the three parameters are passed to themethod using Reflection method invocation. If the number of parametersis not correct an exception is thrown and the user is prompted with anappropriate error message.</param3></param2></param1>

Inthis way, Bob can add new menu items to his ordering application andthe application will automatically be able to list and invoke them.

Dynamically Invoking a Method

Bob?s clever C# Developer uses a series ofeasy steps to look a method up and then invoke it. All this is doneinside the GetCommand() method. The first step he takes is to get thefirst space-seperated word from the console input string. He then getsa reflection or type representation of the object that he wants to calla method on, namely the DynamicMethods object.

Type thisType = this.GetType();

He then asks the Type object ifthe class it is reflecting holds a method with a name that matches theword he read in from the console. If there is such a method, a methoddescriptor object is returned in the form of MethodInfo:
Continues…

This article explains how to make use ofSystem.Reflection class to extract each and every detail of any classin .Net Framework.The MemberInfo class available in System.Reflection namespace is anabstract class.It discovers the attributes of a member and provides access to themember metadata.We need to assign the details we need to query about a type viz.Constructors/Methods/Interfaces/Fields/Property etc. to the MemberInfoclass local variable.For this, We can make use of the methodsGetFields/GetMethods/GetInterfaces etc. In this code example, the userwill be prompted to select the class about which he would like to viewdetails.The details of the class selected (available Methods/Interfaces/Fields)will be listed out in the corresponding listboxes.

To compile, type: csc reflection.csDownload reflection.cs

Here's what it looks like