Writing an Extensible Application – Part 3: IC#Code Addin Tree

 

Hi All,

This is the third part of my extensibility series and this time I would like to describe an open source extensibility mechanism which is part of SharpDevelop called the Addin Tree. To use the Addin Tree all you have to do is to download the latest version of SharpDevelop and reference the file ICSharpCode.Core.dll in your project. For my example I will be using the dll from version 4.1 which can be downloaded from the site.

The Addin Tree (AT for short) is a very simple mechanism based on XML files called Addins. Each Addin file may contain one or more Path elements which maps all child elements of the Path element to a specific node within the AT. The AT is a tree data structure where each node may contain one or more Codons that describe any user data. Each node in the tree can be reached using a path statement of the form “A/B/…/C/D” where A,B,C are the ids of the nodes to pass on the way to node D which is represented by this statement. When the application loads it can read any number of Addins and build the tree. Later, you may access any node of the tree and Build the codons within this node. Each codon is built by a Doozer which is mapped to that specific codon (the core mechanism provides some basic doozers to build elementary program elements).

The addins are defined using XML files that contain the following elements:

• Root Addin Element which contains some general data on the addin.
• The Manifest Element which describes the addin file.
• The Runtime Element which defines the Doozers and the assemblies needed in the addin.
• The Paths Elements which contain the codons of the addin.

Here is an example of such an Addin file (from SharpDevelop):

19.         <AddIn name= "AddInScout"
20.              author= "Satguru P Srivastava"
21.           copyright= "prj:///doc/copyright.txt"
22.                 url= "http://home.mchsi.com/~ssatguru"
23.        description = "Display AddIn Information"
24.        addInManagerHidden = "preinstalled">
25.  
26.   <Manifest>
27.     <Identity name = "ICSharpCode.AddInScout"/>
28.   </Manifest>
29.  
30.   <Runtime>
31.     <Import assembly="AddInScout.dll"/>
32.   </Runtime>
33.  
34.   <Path name = "/Workspace/Tools">
35.     <MenuItem id = "ShowAddInScout"
36.                   label = "AddIn Scout"
37.                   class = "AddInScout.AddInScoutCommand"/>
38.   </Path>
39. </AddIn>

The Balls Game

Back to our example… To use the Addin tree extensibility I made some small changes. First, the build process now builds the entire game into a single root Bin folder and all the Addins into an Addins folder. This structure is needed for the Runtime mechanism of the AT. I created a main addin file for the application called Main.addin which contains the definition of the three Doozers I will use to support the extensibility of my application. The doozers are defined in the Interfaces project as internal classes and they contain some logic to build the required class from the codon definition. The main addin file looks like this:

1. <AddIn name="Balls Main Addin"
2.        author="Boris Kozorovitzky"
3.        description="The main addin of the game"
4.        addInManagerHidden="preinstalled">
5.  
6.   <Manifest>
7.     <Identity name="MainAddin"/>
8.   </Manifest>
9.  
10.   <Runtime>
11.     <Import assembly=":BallsInterfaces">
12.       <Doozer name="Collider" class="BallsInterfaces.Doozers.ColliderDoozer"/>
13.       <Doozer name="Mover" class="BallsInterfaces.Doozers.MoverDoozer"/>
14.       <Doozer name="Drawer" class="BallsInterfaces.Doozers.DrawerDoozer"/>
15.     </Import>
16.   </Runtime>
17. </AddIn>

One important thing to notice here is that the Import element tells the extensibility mechanism where to find the doozers. In this case I use the “:” syntax to tell it that the required assembly is in the Bin folder. You will understand why this is important next.

The extensibility Addin may sit anywhere in the Addin folder (any directory structure) and it looks like this:

1. <AddIn name="Balls Addin"
2.        author="Boris Kozorovitzky"
3.        description="Adds some balls to the game"
4.        addInManagerHidden="preinstalled">
5.  
6.   <Manifest>
7.     <Identity name="AddinExtensibility"/>
8.   </Manifest>
9.  
10.   <Runtime>
11.     <Import assembly=":BallsInterfaces"></Import>
12.     <Import assembly="AddinExtensibility.dll"></Import>
13.   </Runtime>
14.  
15.   <Path name="/Balls/Colliders">
16.     <Collider type="AddinExtensibility.BasicCollider"></Collider>
17.     <Collider type="AddinExtensibility.StopperCollider"></Collider>
18.   </Path>
19.  
20.   <Path name="/Balls/Movers">
21.     <Mover type="AddinExtensibility.BasicMover"></Mover>
22.     <Mover type="AddinExtensibility.ParabolicMover"></Mover>
23.  
24.   </Path>
25.  
26.   <Path name="/Balls/Drawers">
27.     <Drawer type="AddinExtensibility.BasicDrawer" fill="Yellow"></Drawer>
28.       <Drawer type="AddinExtensibility.BlinkerDrawer"></Drawer>
29.  
30.   </Path>
31.  
32. </AddIn>

Note that the import section references the Dll where all the classes are defined – AddinExtensibility.dll and the BallsInterfaces assembly. The main section of the addin contains three Path elements (I chose the path randomly to something logical) and each path contains Codon which can be built by a specific doozer (see doozer mapping in the main addin file). The collider doozer code will reveal the nice trick which the import does for us:

9. internal class ColliderDoozer:IDoozer
10. {
11.   public object BuildItem(BuildItemArgs args)
12.   {
13.     string stringType = args.Codon.Properties["type"];
14.     object result = args.AddIn.CreateObject(stringType);
15.     return result;
16.   }
17.  
18.   public bool HandleConditions
19.   {
20.     get { return false; }
21.   }
22. }

The AT mechanism will call the BuildItem method on any codon which is mapped to that doozer. In this case I expect the element to have a “type” attribute where the type of the object is written. Now that the type is resolved I can call the CreateObject method which will do the magic for us and find the correct type from the assemblies referenced in the Runtime section and thus returning the correct item each time. To show you how the extensibility mechanism can work for us I added two editable properties to the BasicDrawer type. The Drawer doozer calls a new method – Configure which takes the codon and extracts the needed arguments from it. Now we can control the color and the diameter of the basic drawer directly from the addin file!

11. public class BasicDrawer : IDrawer
12.   {
13.     private static double _initialDiameter;
14.     private static Brush _initialBrush;
15.  
16.     public void Initialize(IBall ball)
17.     {
18.       ball.Diameter = _initialDiameter;
19.       ball.Fill = _initialBrush??Brushes.Blue;
20.     }
21.  
22.     public void Tick(IBall ball)
23.     {
24.  
25.     }
26.  
27.     public object Clone()
28.     {
29.       return new BasicDrawer();
30.     }
31.  
32.  
33.     public void Configure(ICSharpCode.Core.Codon codon)
34.     {
35.       _initialDiameter = 15;
36.       if (codon.Properties.Contains("diameter"))
37.       {
38.         string diameterString = codon.Properties["diameter"];
39.         double diameter = 15d;
40.         Double.TryParse(diameterString, out diameter);
41.         _initialDiameter = diameter;
42.       }
43.  
44.       _initialBrush = null;
45.       if (codon.Properties.Contains("fill"))
46.       {
47.         string fillString = codon.Properties["fill"];
48.         _initialBrush = (SolidColorBrush)new BrushConverter().ConvertFromString(fillString);
49.       }
50.  
51.     }
52.   }

In the example I set the color of all the balls created with the BasicDrawer to Yellow but the user may chose to edit this value as he wishes.

The extensibility initialization code changed slightly and now it loads all the addin files from the Addins path:

93. private void LoadExtensibility()
94. {
95.   Assembly applicationAssembly =  Assembly.GetAssembly(GetType());
96.   string extensibilityPath = System.IO.Path.Combine(System.IO.Path.GetDirectoryName(applicationAssembly.Location), ConfigurationManager.AppSettings["AddinsPath"]);
97.   string[] addinFiles = System.IO.Directory.GetFiles(extensibilityPath, "*.addin",System.IO.SearchOption.AllDirectories);
98.   AddInTree.Load(new List<string>(addinFiles), new List<string>());
99.   foreach (ICollider collider in AddInTree.BuildItems<ICollider>("/Balls/Colliders", null))
100.     Colliders.Add(new StrategyAdapter(collider));
101.  
102.   foreach (IMover mover in AddInTree.BuildItems<IMover>("/Balls/Movers", null))
103.     Movers.Add(new StrategyAdapter(mover));
104.  
105.   foreach (IDrawer drawer in AddInTree.BuildItems<IDrawer>("/Balls/Drawers", null))
106.     Drawers.Add(new StrategyAdapter(drawer));
107. }

This extensibility mechanism allows great flexibility and it is simple enough to cover many useful scenarios. In the worst case you can always take a look at the source code to see how things work under the hood. If you are looking for something simple yet powerful to extend your application you should definitely consider the Addin Tree.

Thank you for reading. You can get the new sources from my SkyDrive here:

 

Boris

Task Parallel Library (TPL)–The lambda strikes back

 

Hi All,

I would like to share an interesting insight I got when solving some problems at Project Euler.  I was trying to make my program run a little faster (because it was using only one CPU core) so I decided to use the TPL. I will spare you the details of the actual problem and instead present a simple piece of code which demonstrates the problem:

12. public static void Run()
13.     {
14.       Task[] tasks = new Task[10];
15.       for (int i = 0; i < 10; i++)
16.       {
17.         tasks[i] = Task.Factory.StartNew(() => { PrintNumber(i); });
18.       }
19.  
20.       Task.WaitAll(tasks);
21.     }
22.  
23.     private static void PrintNumber(int i)
24.     {
25.       Thread.Sleep(100);
26.       Console.Write(i);
27.       Console.Write(",");
28.     }

What do you think will be printed when I call Run?

 

If you think that this is not deterministic because the TPL may choose to run the tasks at any order you would be half right. Indeed, the TPL can run the tasks in any order but in this case we have a different problem. The evaluation of the lambda expression will be done only when the task is run and in the general case it would be after the loop is finished so the value of “i" would be 10 for all the tasks.

The correct answer is therefore that the program will print 10 times “10,” (in the general case because in some cases the task may start in the middle of the loop).

I remind you from a previous post on my blog that when you use a local variable in a lambda expression the compiler generates a “secret” class for you which holds a reference (for reference types) or a copy (for value types) of this variable until the lambda expression is run. Therefore to get the desired result we need a unique variable to be copied in each iteration. This can be achieved by adding a temp variable within the scope of the loop and use it in the lambda.

12. public static void Run()
13. {
14.   Task[] tasks = new Task[10];
15.   for (int i = 0; i < 10; i++)
16.   {
17.     int x = i;
18.     tasks[i] = Task.Factory.StartNew(() => { PrintNumber(x); });
19.   }
20.  
21.   Task.WaitAll(tasks);
22. }
23.  
24. private static void PrintNumber(int i)
25. {
26.   Thread.Sleep(100);
27.   Console.Write(i);
28.   Console.Write(",");
29. }

Now we get the correct results, the numbers 0 though 9 are printed (in some order).

My conclusion is (again): One should be extra careful when using local variables in lambda expressions.

 

Thanks for reading,

Boris.

Persisting a GridSplitter

Hi All,

If you are using WPF then you probably use the Grid container and if you are using that then at times you surely need the assistance of the GridSplitter. The GridSplitter is a sub element of the Grid and it allows the user to conveniently resize the grid columns or rows. Those of you who worked with the GridSplitter know that it is quite challenging to work with correctly.

I will start with a small example. In my application I need a vertical splitter between two buttons (conveniently named Left and Right). The initial size of the Left button should be twice the size of the Right button. Here is the XAML:

5. <Grid>
6.     <Grid.ColumnDefinitions>
7.         <ColumnDefinition Width="2*"></ColumnDefinition>
8.         <ColumnDefinition Width="Auto"></ColumnDefinition>
9.         <ColumnDefinition Width="*"></ColumnDefinition>
10.     </Grid.ColumnDefinitions>
11.     <GridSplitter Width="5" Background="Red" VerticalAlignment="Stretch" HorizontalAlignment="Center" Grid.Column="1"></GridSplitter>
12.     <Button Grid.Column="0">Left</Button>
13.     <Button Grid.Column="2">Right</Button>
14. </Grid>

And this is the result:

I am using a technique where the GridSplitter sits in its own column. I find this approach better since then you don’t need to think how it should be position within the column or within the XAML file.

The problem with the GridSplitter becomes apparent when you try to use fixed sizes in the grid column width (the same applies for grid row height but I will continue the discussion with the grid columns). What if we want the left column to start with a fixed size of 5cm on the screen. The logical thing to do would be to set the width of the first column to 5cm. If you do that and run the application everything would seem normal until you start dragging the GridSplitter. Try dragging it to the right… way right… past the window border right… now let go and try to drag it back. That’s right. The GridSplitter is gone! I read somewhere on the Internet that the grid splitter does exactly what I told it to do. If you believe that then try to do the same with the right column and dragging the GridSplitter left. The phenomenon here is even stranger.

5. <Grid>
6.      <Grid>
7.          <Grid.ColumnDefinitions>
8.              <ColumnDefinition Width="*" ></ColumnDefinition>
9.              <ColumnDefinition Width="Auto"></ColumnDefinition>
10.              <ColumnDefinition Width="5cm" ></ColumnDefinition>
11.          </Grid.ColumnDefinitions>
12.  
13.          <GridSplitter Width="5" Background="Red" VerticalAlignment="Stretch"
14.     HorizontalAlignment="Center" Grid.Column="1"></GridSplitter>
15.          <Button Grid.Column="0">Left</Button>
16.          <Button Grid.Column="2" >Right</Button>
17.      </Grid>
18.  </Grid>

Don’t do that… Its crazy!

The point I am trying to make here is that the GridSplitter is best used when the widths of the column are star based. You can have some control using the MinWidth and MaxWidth properties applied on the columns, but sometimes this behavior is not the desired one.

Now for the main challenge. I want my application to restore the state of the GridSplitter position next time it is run. For example if I move the GridSplitter such that only the Right button is visible and close the application. When I start the application I expect only the Right button to be visible. Actually doing this is quite simple. I add x:Name attributes to the grid columns and handle the DragCompleted event of the GridSplitter. In the handler I serialize the width properties of both columns into a file. The problem here is that the Width is not a simple double value but a struct (GridLength). Fortunately, the framework provides us with a small helper class to serialize and deserialize this struct called GridLengthConverter. The serialization code looks like this:

50. Assembly assembly = Assembly.GetExecutingAssembly();
51. String directory = System.IO.Path.GetDirectoryName(assembly.Location);
52. using (StreamWriter writer = new StreamWriter(Path.Combine(directory, "width.txt")))
53. {
54.   GridLengthConverter converter = new GridLengthConverter();
55.   writer.WriteLine(converter.ConvertToString(LeftColumn.Width));
56.   writer.WriteLine(converter.ConvertToString(RightColumn.Width));
57. }

and the deserialization code is therefore like this:

28. Assembly assembly = Assembly.GetExecutingAssembly();
29. String directory = System.IO.Path.GetDirectoryName(assembly.Location);
30. if (File.Exists(Path.Combine(directory, "width.txt")))
31. {
32.   using (StreamReader reader = new StreamReader(Path.Combine(directory, "width.txt")))
33.   {
34.     GridLengthConverter converter = new GridLengthConverter();
35.     LeftColumn.Width = (GridLength)converter.ConvertFromString(reader.ReadLine());
36.     RightColumn.Width = (GridLength)converter.ConvertFromString(reader.ReadLine());
37.   }
38. }

(it is run after InitializeComponents).

The important thing to notice here is that you must serialize both column width because they are relative to each other.

That’s it for today. Thank you for reading.

Boris.

Writing an Extensible Application – Part 2: Extensibility by Reflection

 

Hi,

This time I will present a very primitive (yet somehow effective) extensibility method: Extensibility by Reflection. This method is good when you don’t want to over complicate things and all you need is a simple way to extend some specific types. This method is based on the Reflection mechanism of .Net (as the name suggests).

Let’s make a short recap of the previous post. I have made a small application that simulates balls within an enclosed rectangular area. Each ball has three “properties”: The Collider, the Mover, and the Drawer. The UI allows the user to select each of the aforementioned properties from a list and create a ball using these properties. The most important thing I did was to design the application in an extensible way. The main application uses all the data through interfaces which are defined in an external DLL (BallsInterfaces.dll).

I have created an additional project which represents the extensibility client (a dll your user would write). For coherence, I have moved all the basic types to that dll and now all of our colliders, drawers, and movers will be loaded through extensibility. I changed the build target path of the new project to be inside <Main project dir>/Extensibility. In the main project I have added the following key to the application settings:

3. <appSettings>
4.   <add key="ExtensibilityPath" value="Extensibility"/>
5. </appSettings>

From this point things are quite simple. All we have to do is to load all the DLLs from the defined path and in each such DLL find and instanciate any class that inherits from ICollider, IMover, or IDrawer interfaces. The following code does just that:

92. private void LoadExtensibility()
93. {
94.   Assembly applicationAssembly =  Assembly.GetAssembly(GetType());
95.   string extensibilityPath = System.IO.Path.Combine(System.IO.Path.GetDirectoryName(applicationAssembly.Location), ConfigurationManager.AppSettings["ExtensibilityPath"]);
96.   string[] dllFiles = System.IO.Directory.GetFiles(extensibilityPath, "*.dll");
97.   foreach (string fileName in dllFiles)
98.   {
99.     Assembly currentAssembly =  Assembly.LoadFile(fileName);
100.     Type[] innerTypes = currentAssembly.GetTypes();
101.     foreach (Type t in innerTypes)
102.     {
103.       if (t.IsClass && t.IsPublic)
104.       {
105.         if (t.GetInterfaces().Contains(typeof(ICollider)))
106.         {
107.           Colliders.Add(new StrategyAdapter(t));
108.         }
109.  
110.         if (t.GetInterfaces().Contains(typeof(IMover)))
111.         {
112.           Movers.Add(new StrategyAdapter(t));
113.         }
114.  
115.  
116.         if (t.GetInterfaces().Contains(typeof(IDrawer)))
117.         {
118.           Drawers.Add(new StrategyAdapter(t));
119.         }
120.  
121.       }
122.     }
123.   }
124. }

A few things worth mentioning:

1. I have added three ObservableCollections named – Colliders, Movers, and Drawers and hooked them up with the ComboBoxes in the application.
2. Each observable collection contains an adapter class (StrategyAdapter) which mitigates the extensible type with the instance creation. It also provides the Name property for display within the ComboBoxes. The StrategyAdapter code is as follows:

9. public class StrategyAdapter
10.   {
11.     
12.     protected Type _innerItemType;
13.     public string Name
14.     {
15.       get
16.       {
17.         if (_innerItemType != null)
18.         {
19.           return _innerItemType.Name;
20.         }
21.         return "Null";
22.  
23.       }
24.       
25.     }
26.     public StrategyAdapter(Type itemType)
27.     {
28.       _innerItemType = itemType;
29.     }
30.  
31.     public T CreateInstance<T>() where T:class
32.     {
33.       return Activator.CreateInstance(_innerItemType) as T;
34.     }
35.   }

And from this code you may infer that the ball creation code becomes:

211. Ball ball = new Ball(SelectedMover.CreateInstance<IMover>(), SelectedCollider.CreateInstance<ICollider>(), SelectedDrawer.CreateInstance<IDrawer>(), _environment);

To extend this example I have added three new implementations of the extensibility interfaces:

1. The Parabolic Mover – It moves the ball as if there was gravity (i.e. with acceleration).
2. The Blinker Drawer – It creates a slightly bigger red ball that slowly disappears and then instantly reappears.
3. The Stopper Collider – It stops the other ball on the spot after collision.

As usual, you can download the sources from my SkyDrive -

I want to take this opportunity to say שנה טובה וחג שמח to all my Jewish friends. Nice and fun 国庆节 to all my Chinese friends, rest and spend time with your families. Happy Friday to all my Pastafarian friends (since every Friday is a holyday!).

Thanks for reading,

Boris.

Yet Another Blog Post About Windows 8 – YABPAW8

 [Edit: You can find a more in depth information on Shasha Goldshtein blog who actually attends the convention. See the links on the right.]

Hi All,
Well, this is somewhat unexpected but even I cannot ignore the recent arrival of Windows 8 preview. Microsoft has created so much hype and rumors about their new OS that even I had to go against my rule – “Never come near Microsoft beta products” – and check it out. Before this release there were many speculations about which direction Microsoft is going to take. Most of those were based on a 4 minute video and various presentation shown in conventions (and a certain leaked build that could be found on the torrents). I heard ludicrous things like “Microsoft has rewritten the entire OS in JS and HTML 5” and somewhat worrying assumptions that .Net will no longer be supported. From looking at the preview version of Windows 8, the vast majority of these rumors and speculations is not at all close to reality.
Here is a summary of my very brief experience with Windows 8. Note that I might missed important things so you can always mention them in the comments.


Installation
The installation was quite simple. I installed Windows 7 on another machine just a couple of days ago and I must say that the Windows 8 installation is much shorter and doesn’t require restarts. Nevertheless, it looks exactly like the installation of Windows 7 (at least until the post installation steps). At the beginning the installation asked if I want to upgrade my existing installation which was interesting since I was installing on a clean machine. In the post installation I was asked to enter my Live ID and after I did everything was connected and my Windows user was my Live ID. I think it is safe to guess that in the real version they will have a way to create a regular user and connect to domains (at least for the Enterprise versions).


The new UI
Once you log on to the new Windows you are immediately thrown into the new Metro UI.


It looks and feels very nice and it is easy to find and activate each application. Although there was one thing that bothered me. It seems that it wasn’t designed for a mouse control because you cannot drag it left and right (I hope this will be added in the release). Instead you can use a small scrollbar on the bottom of the screen or the mouse wheel to scroll. As you can see in the screenshot, Metro style applications may use the new Tiles API while other application get a default tile that shows the application name and title. I tried to run some Metro applications and found nothing really special about them. They run on full screen without windows and have a common menu style that is similar to Windows Phone and can be activated by a right-click. There was one annoying thing that I experienced. It seems that Microsoft designed the applications for tablets or something because for the hell of me I couldn’t find an “Exit” button anywhere! Eventually I had to close each application using the Task Manager since Alt+F4 didn’t close them either (and trust me I know how to exit VI). Good thing that Windows button works during these applications and you can easily go back to the desktop.





The Old UI
The nice surprise comes when you click the Desktop tile (or Windows button or Windows + D that still works). You are flung into the familiar Windows desktop (using a strange Skew effect from the 90’s which, I hope, can be somehow modified) and there you can see some subtle changes that I feel will make working with Windows somewhat simpler. As published, the Ribbon has spread into the Windows Explorer and all the important functions were externalized. This makes work somewhat simpler since you don’t need to rely on the context menus or the hidden main menu so much.

There is still a strange Start button which, when clicked, throws you back into the Metro UI. Sometimes it shows this (see screenshot) ugly black menu and huge time display when you hover over it (sometimes it shows the very important tooltip “Start”).
An even nicer surprise was the new Task Manager (which I had to use quite a lot, see previous section) which has a brand new UI that shows all the important information in a nice colorful way. You can now easily see all the significant counters and have easy access to the Performance UI (which was hidden in Windows 7) and the graphs. Other than that the UI felt unchanged from Windows 7 in both the look and feel and the behavior.

Visual Studio Express (Preview Edition)
I tried out the new Visual Studio (a.k.a. vNext) and didn’t find any surprises there (although this is the Express version and I didn’t want to install the Ultimate version, yet). It looks exactly like VS2010 with no apparent significant changes. I think the most important change is that they finally cleaned out the default toolbars and left only the most important commands there. Other than that, from what I could find from my short experience with vNext, the major changes are:

• Moved the Quick Access window (Control+3 in VS2010) to a static toolbar item.
• Renamed Solution Navigator to Solution Explorer (I think the original Solution Explorer was removed).
• Removed Quick Find.

(And no, they didn’t fix the most annoying bug ever where you can’t “Find In Files” if the editor is not open!)
In the short time I tested vNext I tried to create a small Metro application in WPF. Couldn’t see anything new here. There were some strange things (a project that has no references but still compiles with no problems) but everything seems to work as I am used to. By the way, I couldn’t find an “Exit” button on the default template of the Metro application either. Which makes me believe that there is some key I can click to close the applications.


Conclusion
From my very brief experience with the new Windows 8 I can say that there are quite many new things and concepts but it is certainly not a revolution. The Metro UI looks promising for the average user but it seems to target mostly tablets and not regular PCs that still use keyboard and mouse to interact with the interface. Once you go back to the Desktop the experience is not much different than Windows 7 except for the many UX improvements and additions. As a developer I didn’t find anything interesting in vNext but I checked only this Express Preview version and there are probably some surprises hiding inside (at least I hope so). I am looking forward to see what Microsoft has in its sleeve for the release.

Have a nice day,
Boris.

P.S.
This blog post was written on my Windows 7 PC.

Writing an Extensible Application - Part 1

Hi All,


In the next posts I will try to examine some simple ways to make your application extensible. Most of the applications we use in our daily life have some form of extensibility. For example the Visual Studio has add ins, extensions, packages and other forms of extensibility which allow you integrate your own functionality to an existing application. For the purpose of our discussion I will define extensibility of an application simply as adding new application functionality without having to recompile any part of the application.

I will demonstrate briefly several simple ways to make your application extensible. To this end I have prepared a demo project (in fact, this post will discuss only this demo project).

The Balls Simulation

The demo project might be familiar to some of my readers since I take it from the new employee training program of my previous job. The application contains a rectangular area called "field". The user adds entities to that field called "balls" and they move inside the field. The balls may collide with each other during the movement within the field and they have to react accordingly. The balls may also collide with the walls and react accordingly.

A screenshot from my demo application

The most important part of writing an extensible application is to decide how the user will be able to extend it. In the case of my application the user will be able to extend the ball behavior using three aspects:

• Movement - Determines how the ball is going to move around the field.
• Drawing - Determines how the ball is going to be drawn on the filed.
• Collision - Determines how the ball will react to a collision with another ball.

Now that I decided that these three items are my extensibility points I need to decide on the design of the application. I chose to implement it using the strategy design pattern. Each of the three elements mentioned above will have a strategy object which will be assigned to a ball. (The ball will be composed of the three element.) Now that this is decided I can define a dll that will be given to the extension writers, clients, which will contain the required interfaces. You don't want to give your clients a bulky dll that will contain all the classes and the logic but a thin layer which will not confuse them but will allow to write a complete extension set.

The interfaces I defined are:

5. public interface IMover
6. {
7.   void Tick(IBall ball);
8.   void Initialize(IBall ball);
9.   void AtWalls(IBall ball, HashSet<WallType> wallTypes);
10. }

 

4. public interface IColider
5. {
6.   void AfterCollision(IBall ball, IBall other);
7.   void BeforeCollision(IBall ball, IBall other);
8.   void Collision(IBall ball, IBall other);
9. }

 

4. public interface IDrawer
5. {
6.   void Tick(IBall ball);
7.   void Initialize(IBall ball);
8. }

 

At this point I want to dedicate a short passage on coding games. The basic design of a game contains a game timer that paces the game. The game timer activates as fast as possible but sometimes it is limited to a specific frame rate - FPS (Frames Per Second). Each time the timer activates is called a game "tick". In each tick the game manager iterates on all the entities within the game (called "sprites") and calls a method that updates their inner parameters. Then the game manager iterates on all the sprites again and draws them on the screen.

As you can see I am using a 3 method collision handling. This method will not cover all the collision cases but it is good enough for many basic games including this demo application. The rules are simple: When two balls collide then the three collision methods are called one by one on each ball with an alternating order (see the code snippet next). On the BeforeCollision method the current ball can gather and data it needs from the other ball but it is not allowed to change its own data. On the Collision method the ball may change any of its parameters based on the data collected in the BeforeCollision method. On the AfterCollision method each ball may set any parameters on the other ball but not on itself.

Putting every thing mention above into code, results in the following Tick method of the timer:

65. #region Handle Movement
    
66. foreach (Ball ball in _balls)
    
67. {
    
68.   ball.Move();
    
69.  
70.   HashSet<WallType> hitWalls = new HashSet<WallType>();
    
71.  
72.   if (ball.Left <= 0)
    
73.     hitWalls.Add(WallType.Left);
    
74.  
75.   if (ball.Top <= 0)
    
76.     hitWalls.Add(WallType.Top);
    
77.  
78.   if (ball.Right >= MainCanvas.ActualWidth)
    
79.     hitWalls.Add(WallType.Right);
    
80.  
81.   if (ball.Bottom >= MainCanvas.ActualHeight)
    
82.     hitWalls.Add(WallType.Bottom);
    
83.  
84.   if (hitWalls.Count > 0)
    
85.     ball.AtWalls(hitWalls);
    
86. }
    
87.  
88. #endregion
    
89.  
90. #region Handle Collision
    
91. for (int i = 0; i < _balls.Count; i++)
    
92. {
    
93.   for (int j = i + 1; j < _balls.Count; j++)
    
94.   {
    
95.     if (IsColliding(_balls[i], _balls[j]))
    
96.     {
    
97.       _balls[i].BeforeCollision(_balls[j]);
    
98.       _balls[j].BeforeCollision(_balls[i]);
    
99.       _balls[i].Collision(_balls[j]);
    
100.       _balls[j].Collision(_balls[i]);
     
101.       _balls[i].AfterCollision(_balls[j]);
     
102.       _balls[j].AfterCollision(_balls[i]);
     
103.     }
     
104.   }
     
105. }
     
106. #endregion

(Note that in this first version the Drawer is not used but you will see it in play in the next post)

The main object of the game is the Ball class. It is exposed to the client as an interface and the client may interact with this class through the interface. All the Ball logic is managed within the class itself, feel free to browse the code there after downloading the demo application.

The application UI is quite simple. The field is on the left side. On the right side there are three combo boxes which will allow you to select the relevant strategy objects and a create button that generates a ball with the selected strategy objects. Both the Mover and the Drawer have Initialize methods that are called once the ball is created to allow the client position and draw the ball for the first time. Note that for this initial stage of the application the combo boxes are not used (since there is no extensibility yet) and the create button creates a small blue ball that just moves around and bounces off walls and other balls.

I encourage you to try out the code to get the feel of it before diving into the extensibility part in the next posts.

You can download the code from my SkyDrive here:

 

Thank you for reading,

Boris.

 

P.S.

Thanks to David Elentok you can see that the formatting is improved a little. I hope to improve it even more in future posts.

Writing an Extensible Application - Part 1

Hi All,


In the next posts I will try to examine some simple ways to make your application extensible. Most of the applications we use in our daily life have some form of extensibility. For example the Visual Studio has add ins, extensions, packages and other forms of extensibility which allow you integrate your own functionality to an existing application. For the purpose of our discussion I will define extensibility of an application simply as adding new application functionality without having to recompile any part of the application.


I will demonstrate briefly several simple ways to make your application extensible. To this end I have prepared a demo project (in fact, this post will discuss only this demo project).


The Balls Simulation


The demo project might be familiar to some of my readers since I take it from the new employee training program of my previous job. The application contains a rectangular area called "field". The user adds entities to that field called "balls" and they move inside the field. The balls may collide with each other during the movement within the field and they have to react accordingly. The balls may also collide with the walls and react accordingly.

A screenshot from my demo application

The most important part of writing an extensible application is to decide how the user will be able to extend it. In the case of my application the user will be able to extend the ball behavior using three aspects:

• Movement - Determins how the ball is going to move around the field.
• Drawing - Determins how the ball is going to be drawn on the filed.
• Collision - Determines how the ball will react to a collision with another ball.

Now that I decided that these three items are my extensibility points I need to decide on the design of the application. I chose to implement it using the strategy design pattern. Each of the three elements mentioned above will have a strategy object which will be assigned to a ball. (The ball will be composed of the three element.) Now that this is decided I can define a dll that will be given to the extension writers, clients, which will contain the required interfaces. You don't want to give your clients a bulky dll that will contain all the classes and the logic but a thin layer which will not confuse them but will allow to write a complete extension set.

The interfaces I defined are:

  public interface IMover
  {
    void Tick(IBall ball);
    void Initialize(IBall ball);
    void AtWalls(IBall ball, HashSet<WallType> wallTypes);
  }

  public interface IDrawer

  {
    void Tick(IBall ball);
    void Initialize(IBall ball);
  }

  public interface IColider
  {
    void AfterCollision(IBall ball, IBall other);
    void BeforeCollision(IBall ball, IBall other);
    void Collision(IBall ball, IBall other);
  }

At this point I want to dedicate a short passage on coding games. The basic design of a game contains a game timer that paces the game. The game timer activates as fast as possible but sometimes it is limited to a specific frame rate - FPS (Frames Per Second). Each time the timer activates is called a game "tick". In each tick the game manager iterates on all the entities within the game (called "sprites") and calls a method that updates their inner parameters. Then the game manager iterates on all the sprites again and draws them on the screen.