Creating a dynamic proxy object using the dynamic type

Like many people who are faced with the task of writing the next UI for my application, I occasionally encounter the need to create my own model for the UI, which to some extent repeats the domain model, but at the same time expands and / or changes it. And that's what came of it.

Formulation of the problem

For example, we have a Region class of such a structure.

public class Region { public string Name { get ; set ; } public int Index { get ; set ; } public IEnumerable <Region> SubRegions { get ; set ; } } * This source code was highlighted with Source Code Highlighter .

1. public class Region { public string Name { get ; set ; } public int Index { get ; set ; } public IEnumerable <Region> SubRegions { get ; set ; } } * This source code was highlighted with Source Code Highlighter .
2. public class Region { public string Name { get ; set ; } public int Index { get ; set ; } public IEnumerable <Region> SubRegions { get ; set ; } } * This source code was highlighted with Source Code Highlighter .
3. public class Region { public string Name { get ; set ; } public int Index { get ; set ; } public IEnumerable <Region> SubRegions { get ; set ; } } * This source code was highlighted with Source Code Highlighter .
4. public class Region { public string Name { get ; set ; } public int Index { get ; set ; } public IEnumerable <Region> SubRegions { get ; set ; } } * This source code was highlighted with Source Code Highlighter .
5. public class Region { public string Name { get ; set ; } public int Index { get ; set ; } public IEnumerable <Region> SubRegions { get ; set ; } } * This source code was highlighted with Source Code Highlighter .
6. public class Region { public string Name { get ; set ; } public int Index { get ; set ; } public IEnumerable <Region> SubRegions { get ; set ; } } * This source code was highlighted with Source Code Highlighter .

public class Region { public string Name { get ; set ; } public int Index { get ; set ; } public IEnumerable <Region> SubRegions { get ; set ; } } * This source code was highlighted with Source Code Highlighter .

And there is a task to show the user in the UI tree of regions, built on this model, as well as give the opportunity to select specific regions that are subject to some further processing. If we make our UI according to MVVM architecture, then it is obvious that we will need to create a class of the RegionViewModel type, with a structure similar to the Region class, but with the additional IsSelected property. In addition, it would be convenient if the RegionViewModel's SubRegions property returned an enumerator of type IEnumerable <RegionViewModel> , then all the UI code would be reduced to creating a TreeView bindig on the RegionViewModel list and getting all RegionViewModel properties that have the IsSelected property true . And what's the problem? The problem is that most of the code of the RegionViewModel class will be data forwarding to the Region class, which it wraps around. Of course, such an implementation is possible, somewhat simplifying life:

1. public class RegionViewModel
2. {
3. public Region Value { get ; set ; }
4. public IEnumerable <RegionViewModel> SubRegions { get { /*...*/ }}
5. }

* This source code was highlighted with Source Code Highlighter .

But it also requires us to implement the SubRegions property with our hands. And if the Region does not implement INotifyPropertyChanged , then most likely we will have to manually describe each property, adding a call to the corresponding event to the value setting.
If a task similar to the one described above occurs quite often, then writing a model-view with my hands each time can be tiring. Therefore, I asked myself the question of automating this process and this is what happened.

Possible solutions

If you look closely, it becomes clear that our task is to create a certain proxy generator that creates a proxy for a given class and complements it with some aspects, such as INotifyPropertyChanged , or / and adds new properties, methods, etc. What does the .net stack offer us to create proxies?

We can distinguish the following solutions

• DynamicProxy by Castle
• RealProxy from MS
• T4 based code generation
• create something based on code instrumentation using PostSharp .
• Use the new one that appeared in C # 4.0

I chose the 5th option, because RealProxy will require intervention in the model classes themselves, the proxy from the castl will allow intercepting only virtual members of the class, postsharp costs money, and I just don’t like code generation for religious reasons. Besides creating your own bike is always more interesting.

Implementation

And so, the main idea concludes as follows - we describe a class that inherits from the type DynamicObject and overrides TryInvokeMember , TrySetMember and TryGetMember .
for example

1. public override bool TryInvokeMember (InvokeMemberBinder binder, object [] args, out object result)
2. {
3. result = _methods.ContainsKey (binder.Name)? _methods [binder.Name] .DynamicInvoke ( new [] { this } .Concat (args) .ToArray ()): InvokeNativeMethod (binder.Name, args);
5. result = GetResult (result);
7. return true ;
8. }

* This source code was highlighted with Source Code Highlighter .

Affairs so that he took at the entrance of the desired object, and when you try to call a member of a class, prokidyval call to this object. Add to this the ability to add new methods and property. For the construction of the object we will use the pillar Fluent builder.
')
The proxy class code itself turned out to be quite large (about 280 lines), so those who want to see it can download the source code and all the examples from the link at the bottom of the post. Here I will give examples of use.

Adding properties

1. private class MyClass
2. {
3. MyClass _i;
5. public string Name { get ; set ; }
6. public MyClass Foo ()
7. {
8. return _i ?? (_i = new MyClass {Name = "_sdfdsfsdfsfd" });
9. }
11. public IEnumerable <MyClass> GetChilds ()
12. {
13. yield return new MyClass ();
14. yield return new MyClass ();
15. }
16. }
18. [TestMethod]
19. public void TestAddProperties ()
20. {
21. var a = new MyClass {Name = "123" };
23. Assert.AreEqual ( "123" , a.Name);
24. dynamic proxy = DynamicProxy.Create (a) .AddProperty < bool > ( "IsSelected" )
25. .AddProperty ( "X" , _ => x, (_, value ) => x = value )
26. .AddProperty ( "LastName" , "FFFF" )
29. proxy.Name = "567" ;
30. proxy.IsSelected = true ;
31. proxy.X = 42;
33. Assert.AreEqual ( "567" , a.Name);
34. Assert.IsTrue (proxy.IsSelected);
35. Assert.AreEqual (42, x);
37. proxy.IsSelected = false ;
39. Assert.IsFalse (proxy.IsSelected);
40. }

* This source code was highlighted with Source Code Highlighter .

Auto-create proxies for function and property values.

1. [TestMethod]
2. public void TestChilds ()
3. {
4. var a = new MyClass {Name = "123" };
6. Assert.AreEqual ( "123" , a.Name);
7. Assert.AreEqual ( "_sdfdsfsdfsfd" , a.Foo (). Name);
9. var x = 0;
11. dynamic proxy = DynamicProxy.Create (a) .AddProperty < bool > ( "IsSelected" )
12. .AddProperty ( "X" , _ => x, (_, value ) => x = value )
13. .AddProperty ( "LastName" , "FFFF" )
14. .AddMethod ( "Boo" , new Func <DynamicProxy <MyClass>, int , string > ((m, i) => ((MyClass) m) .Name + i.ToString ())));
17. proxy.Name = "567" ;
18. proxy.IsSelected = true ;
19. proxy.X = 42;
20. var b = proxy.Foo ();
21. b.IsSelected = true ;
23. Assert.AreEqual ( "567" , a.Name);
24. Assert.AreEqual ( "5674" , proxy.Boo (4));
25. Assert.IsTrue (proxy.IsSelected);
26. Assert.AreEqual (42, x);
27. Assert.IsTrue (b.IsSelected);
29. b.IsSelected = false ;
31. Assert.IsTrue (proxy.IsSelected);
32. Assert.IsFalse (b.IsSelected);
34. proxy.LastName = "890" ;
35. var d = proxy.Foo ();
36. Assert.AreEqual ( "FFFF" , d.LastName);
38. var d2 = proxy.Foo ();
39. d2.LastName = "RRRRR" ;
41. Assert.AreEqual ( "567" , Foo (proxy));
43. Assert.AreEqual (d.LastName, d2.LastName);
45. // It is possible to rob the cows to do an impassable caste
47. var c = (MyClass) proxy;
49. Assert.AreEqual ( "567" , c.Name);
51. foreach ( var child in proxy.GetChilds ())
52. {
53. child.IsSelected = true ;
54. Assert.IsTrue (child.IsSelected);
55. }
56. }

* This source code was highlighted with Source Code Highlighter .

Automatic implementation of INotifyPropertyChanged is also done .

1. [TestMethod]
2. public void TestPropertyChange ()
3. {
4. var myClass = new MyClass ();
5. var propertyName = string .Empty;
6. dynamic proxy = DynamicProxy.Create (myClass);
8. ((INotifyPropertyChanged) proxy). PropertyChanged + = (s, a) => propertyName = a.PropertyName;
10. proxy.Name = "aaaa" ;
12. Assert.AreEqual ( "Name" , propertyName);
13. }

* This source code was highlighted with Source Code Highlighter .

Practical use

Let's try using this proxy to solve the problem described in the beginning of the article. To simplify this, we will generate a small tree of regions, let the user select the necessary ones and show the list of selected ones on the right. Actually, this is how the window code is used.

1. public MainWindow ()
2. {
3. Initializecomponent ();
4. DataContext = this ;
5. Items = new [] {DynamicProxy.Create (CreateRegions (). First ()). AddProperty < bool > ( "IsSelected" )};
6. }
8. IEnumerable <Region> GetSelectedItems ( IEnumerable <dynamic> items)
9. {
10. Return items.Where (x => x.IsSelected) .Concat (items.SelectMany (x => GetSelectedItems (( IEnumerable <dynamic>) x.SubRegions))). Select (x => (Region) x);
11. }
13. private void ButtonClick ( object sender, RoutedEventArgs e)
14. {
15. var res = GetSelectedItems (Items) .Take (10) .ToList ();
16. SelectedItems = res;
17. }

* This source code was highlighted with Source Code Highlighter .

And xaml to him

1. < Window x: Class = "WpfApplication1.MainWindow"
2. xmlns = "http://schemas.microsoft.com/winfx/2006/xaml/presentation"
3. xmlns: x = "http://schemas.microsoft.com/winfx/2006/xaml" xmlns: WpfApplication1 = "clr-namespace: WpfApplication1"
4. Title = "MainWindow" Height = "350" Width = "525" >
6. < Window.Resources >
8. < DataTemplate DataType = "{x: Type WpfApplication1: Region}" >
9. < WrapPanel >
10. < TextBlock Text = "{Binding Path = Name, StringFormat = '{} {0},'}" />
11. < TextBlock Text = "{Binding Path = Index}" />
12. </ WrapPanel >
13. </ DataTemplate >
16. </ Window.Resources >
17. < Grid >
18. < Grid.ColumnDefinitions >
19. < ColumnDefinition Width = "*" />
20. < ColumnDefinition Width = "auto" />
21. < ColumnDefinition Width = "*" />
22. </ Grid.ColumnDefinitions >
24. < TreeView Grid . Column = "0" ItemsSource = "{Binding Items}" BorderThickness = "0" >
25. < TreeView.ItemTemplate >
26. < HierarchicalDataTemplate ItemsSource = "{Binding SubRegions}" >
27. < CheckBox IsChecked = "{Binding IsSelected, Mode = TwoWay}" Content = "{Binding Value}" />
29. </ HierarchicalDataTemplate >
30. </ TreeView.ItemTemplate >
31. </ TreeView >
32. < Button Content = "Show selected" VerticalAlignment = "Center" Grid . Column = "1" Click = "ButtonClick" />
33. < ListBox Grid . Column = "2" ItemsSource = "{Binding SelectedItems}" BorderThickness = "0" />
34. </ Grid >
35. </ Window >

* This source code was highlighted with Source Code Highlighter .

Application screenshot

Links

1. Project sources
2. Compiled binaries
3. DynamicObject
4. MVVM
5. Fluent interface

Thanks for attention.