Reflecting Types

Lately I've been posting about using IL generation to connect elements.

I know I was about to post series about Scene Graph, but since I like to do things in an non ordered fashion (and at the end of the day, it's my blog ;) , I'll go a bit deeper into objects.

In most graph oriented architecture, we have to create nodes, and connectors, so we have to build inputs/outputs...

We have several ways to do it:

• Big factory: You have calls like CreateIntParameter, CreateValueInput, or generic version like CreateInput<T> ...
• Injection : You use decorators in order to inject some implementation. (So doing ISpread<int> internally generates a IntInputPin or something like that).

Going deeper, why do we even need pins? Let's take the following example:

Code Snippet

32. public class Prop
33. {
34.     public double Hello { get; set; }
35.  
36.     public int Integer { get; set; }
37.  
38.     public string ReadOnly { get { return "ReadOnly"; } }
39. }
40.  
41. public class Prop2
42. {
43.     public double Double { get; set; }
44.  
45.     public string DoubleOutput { get; set; }
46. }

This is pretty easy to reflect properties, since we know about get/set, we can create a "virtual pin" automatically, so why even wrap the property?

In most systems we would work it like that:

• Wrap hello as input and Output Pin. 
• Wrap ReadOnly as Output pin.
• Create a link that wraps InputPin<double> and OutputPin<double>

So let's do this in a simpler way, let's say we want to connect Hello (output) to Prop2 "DoubleOutput"

First we need a Func to access Property:

Code Snippet

274. public static Func<T> BuildGetter<T>(object instance, PropertyInfo property)
275. {
276.     return (Func<T>)Delegate.CreateDelegate(typeof(Func<T>), instance, property.GetGetMethod());
277. }

And a way to set property:

Code Snippet

279. static Action<T> BuildSetter<T>(object instance, PropertyInfo property)
280. {
281.     return (Action<T>)Delegate.CreateDelegate(typeof(Action<T>), instance, property.GetSetMethod());
282. }

Now we have to connect both, eg: read from source and write to destination:

Code Snippet

284. static Action Connect<T>(object source, PropertyInfo getter, object dest, PropertyInfo setter)
285. {
286.     var getFunc = BuildGetter<T>(source, getter);
287.     var setAction = BuildSetter<T>(dest, setter);
288.     return () => setAction(getFunc());
289. }

That was that easy, now we can simply have:

Code Snippet

315. Prop p = new Prop()
316. {
317.     Hello = 20.0,
318.     Integer = 20
319. };
320.  
321. Prop2 p2 = new Prop2();
322.  
323. var connect = Connect<double>(p, typeof(Prop).GetProperty("Hello"), p2, typeof(Prop2).GetProperty("Double"));
324. connect();

All done, out connector is ready ;)

If we need conversion, this is as easy, we can use a small interface:

Code Snippet

19. public interface ITypeConverter<TSource,TDest>
20. {
21.     TDest Convert(TSource source);
22. }
23.  
24. public class DoubleToStringConverter : ITypeConverter<double, string>
25. {
26.     public string Convert(double source)
27.     {
28.         return source.ToString() + " from converter";
29.     }
30. }

Then our connector can either use this small interface, or we can just set a lambda is case we can't be bother ed adding one file + namespaces + new class, get rid of object oriented verbosity basically ;)

Code Snippet

291. static Action Connect<TSource, TDest>(object source, PropertyInfo getter, object dest, PropertyInfo setter, Func<TSource,TDest> converter)
292. {
293.     var getFunc = BuildGetter<TSource>(source, getter);
294.     var setAction = BuildSetter<TDest>(dest, setter);
295.     return () => setAction(converter(getFunc()));
296. }
297.  
298. static Action Connect<TSource, TDest>(object source, PropertyInfo getter, object dest, PropertyInfo setter, ITypeConverter<TSource, TDest> converter)
299. {
300.     var getFunc = BuildGetter<TSource>(source, getter);
301.     var setAction = BuildSetter<TDest>(dest, setter);
302.     return () => setAction(converter.Convert(getFunc()));
303. }

In action:

Code Snippet

327. var connectConverter = Connect<double, string>(p, typeof(Prop).GetProperty("Hello"), p2, typeof(Prop2).GetProperty("DoubleOutput"), (d) => d.ToString() + " Hello");
328.  
329. connectConverter();
330.  
331. var connectInterface = Connect<double, string>(p, typeof(Prop).GetProperty("Hello"), p2, typeof(Prop2).GetProperty("DoubleOutput"), new DoubleToStringConverter());
332.  
333. connectInterface();

Now we can actually simply reflect type, create IO on rules, but operate directly on properties.
Direct access costs us a few virtual calls, but since we haven't got a layer on top, this is even more minimized.


Once we have this, let's looks at it further, let's show how to display our element, with custom formatted string per type, in this example I just log to console, bu this is easily extendable to user interface, writing, serialization...

Code Snippet

108. public interface IPropertyDisplayFactory
109. {
110.     Type PropertyType { get; }
111.     IPropertyDisplay DisplayObject(object instance, PropertyInfo property);
112. }
113.  
114. public interface IPropertyDisplay
115. {
116.     void Display();
117. }

First we do some simple defaults:

Code Snippet

203. public class BasicDisplay : IPropertyDisplay
204. {
205.     private readonly Action display;
206.  
207.     public BasicDisplay(Action display)
208.     {
209.         this.display = display;
210.     }
211.  
212.     public void Display()
213.     {
214.         display();
215.     }
216. }
217.  
218. public abstract class TypedDisplayFactory<T> : IPropertyDisplayFactory
219. {
220.     public Type PropertyType
221.     {
222.         get { return typeof(T); }
223.     }
224.  
225.     public abstract IPropertyDisplay DisplayObject(object instance, PropertyInfo property);
226. }

Then two stupid int and double implementations:

Code Snippet

228. public class DoubleDisplayFactory : TypedDisplayFactory<double>
229. {
230.     public override IPropertyDisplay DisplayObject(object instance, PropertyInfo property)
231.     {
232.         Func<double> getter = Program.BuildGetter<double>(instance, property);
233.  
234.         Action action = () =>
235.             {
236.                 Console.WriteLine(property.Name + " Double: " + getter().ToString());
237.             };
238.  
239.         return new BasicDisplay(action);
240.     }
241. }
242.  
243. public class IntDisplayFactory : TypedDisplayFactory<int>
244. {
245.     public override IPropertyDisplay DisplayObject(object instance, PropertyInfo property)
246.     {
247.         Func<int> getter = Program.BuildGetter<int>(instance, property);
248.  
249.         Action action = () =>
250.         {
251.             Console.WriteLine(property.Name + "Int: " + getter().ToString());
252.         };
253.  
254.         return new BasicDisplay(action);
255.     }
256. }

Now we need to know if a property is capable of display of not:

Code Snippet

155. public class DisplayPropertyRegistry
156. {
157.     private readonly IEnumerable<IPropertyDisplayFactory> factories;
158.  
159.     public DisplayPropertyRegistry(IEnumerable<IPropertyDisplayFactory> factories)
160.     {
161.         this.factories = factories;
162.     }
163.  
164.     public DisplayPropertyRegistry(params IPropertyDisplayFactory[] factories)
165.     {
166.         this.factories = factories;
167.     }
168.  
169.     private IEnumerable<IPropertyDisplayFactory> SearchCandidate(Type type)
170.     {
171.         return factories.Where(f => f.PropertyType == type);
172.     }
173.  
174.     public bool CanDisplay(Type type)
175.     {
176.         return SearchCandidate(type).FirstOrDefault() != null;
177.     }
178.  
179.     public IPropertyDisplayFactory GetFactory(Type type)
180.     {
181.         return SearchCandidate(type).First();
182.     }
183. }

Add filtering support:

Code Snippet

119.   public class DisplayPropertyFilter
120.   {
121.       private readonly DisplayPropertyRegistry registry;
122.  
123.       public DisplayPropertyFilter(DisplayPropertyRegistry registry)
124.       {
125.           this.registry = registry;
126.       }
127.  
128.       public IEnumerable<Tuple<PropertyInfo,IPropertyDisplayFactory>> ReflectType(Type type)
129.       {
130.           var props = type.GetProperties().Where(p => p.GetGetMethod() != null && registry.CanDisplay(p.PropertyType));
131.  
132.             return props.Select(p => newTuple<PropertyInfo,IPropertyDisplayFactory>(p, registry.GetFactory(p.PropertyType)));
133.       }
134.   }

From here we know from a given type, every property that we can display, and how to create them. We only used object type so far, so now we need to add instance in the mix:

Code Snippet

136. public class DisplayObjectFactory
137. {
138.     private readonly DisplayPropertyFilter filter;
139.  
140.     public DisplayObjectFactory(DisplayPropertyFilter filter)
141.     {
142.         this.filter = filter;
143.     }
144.  
145.     public ObjectDisplay GetDisplay(object instance)
146.     {
147.         var factories = filter.ReflectType(instance.GetType());
148.  
149.         var elements = factories.Select(f => f.Item2.DisplayObject(instance, f.Item1));
150.  
151.         return new ObjectDisplay(elements);
152.     }
153. }

And the final object that displays our information:

Code Snippet

185. public class ObjectDisplay
186. {
187.     private readonly IEnumerable<IPropertyDisplay> displayElements;
188.  
189.     public ObjectDisplay(IEnumerable<IPropertyDisplay> displayElements)
190.     {
191.         this.displayElements = displayElements;
192.     }
193.  
194.     public void Display()
195.     {
196.         foreach (IPropertyDisplay display in displayElements)
197.         {
198.             display.Display();
199.         }
200.     }
201. }

Our final code, that gets an instance and displays any supported data:

Code Snippet

307. DisplayPropertyRegistry registry = new DisplayPropertyRegistry(
308.     new DoubleDisplayFactory(),
309.     new IntDisplayFactory());
310.  
311. DisplayPropertyFilter filter = new DisplayPropertyFilter(registry);
312.  
313. DisplayObjectFactory builder = new DisplayObjectFactory(filter);
314.  
315. Prop p = new Prop()
316. {
317.     Hello = 20.0,
318.     Integer = 20
319. };
320.  
321. var display = builder.GetDisplay(p);
322. display.Display();

You can easily think that's a lot of classes and a lot of code to just display properties of a class (we could just iterate through property list and do some "tostring"

But...

• This is more extensible, and if you need to access your properties a lot, you get a pretty big gain over reflection.
• You can register any type, replace as you wish, so you avoid the dreaded massive switch.
• By having more classes, and less work per class, you have much more invariants, pretty much every class is ready to go once constructed, no temporal coupling (only edge case is CanDisplay/GetFactory which could create a related exception).
• You are not limited to just a "tostring", create a controller, network serializer, add a proxy for automatic property change dispatch, possibilities are endless ;)

Here we are for now, promised I'll get back into Scene Graph next post (or maybe not ;)