Use IronRuby to develop a Windows Phone 7 app

A Windows Phone 7 application I was working on kept sitting on the shelf because I was too overwhelmed with a couple of contracts to finish it. Then several weeks ago I won a free Samsung Focus in a Microsoft-sponsored contest, and the application (currently called Lifting Calculator) went from a hobby to a valuable tool. It also seemed like the perfect opportunity for me to try out IronRuby in the Windows Phone 7 environment.

Note: This tip first published in TechRepublic’s Smartphones blog in February 2011.

Download IronRuby

I had IronRuby 1.1.1 installed, but I learned that IronRuby 1.1.2 was released in early February, and it includes Windows Phone 7 support. You need to download the binaries package (the MSI version is not fine — I learned that the hard way). Also, while you are in the directory, look at each DLL’s properties and click the Unblock button.

Write a Windows Phone 7 app in IronRuby

I read Shay Friedman’s MSDN article about writing Windows Phone 7 apps in IronRuby, and then I tweaked his directions to fit my needs. One reason for the tweaks is that I already completed quite a bit of work on my application, and I wanted to see how to use IronRuby for one piece of my app first. Another issue was that the article’s instructions were not entirely correct; I’m sure that this was primarily due to IronRuby changing since the article was written.

Here are the steps that I took:

1. I added a reference to the IronRuby binaries. I added all of the Windows Phone 7 binaries from the package.
2. I prepped my XAML and attached code behind for the functionality I wanted. (No, I haven’t moved to MVVM yet.)
3. In the C# code that I wanted to call Ruby from, I added the following using statements:
   using System.Reflection;
   using System.IO;
   using Microsoft.Scripting.Hosting;
   using IronRuby;
4. I created my Ruby file that contained the functionality I wanted. The Ruby script should manipulate global variables that will be passed into it by the Silverlight host, and return an output value.
5. I set the Build Action and Copy to Output Directory of the new Ruby file as Content and Copy if newer, respectively.
6. I added the code needed to call the IronRuby script, and received its output into a variable. I had to cast it to make sure I could use it nicely after I got it back.

For the full details, see Code sample A (the C# code calling the IronRuby script) and Code sample B (the IronRuby script). To get an idea of what this app does, this functionality is to determine how many weight plates of what size to put onto each side of a barbell to load it to the desired weight. This is a big help in the gym once you get past a certain point, and you end up taking forever to do the math and end up improperly loading the barbell. (This is part of a bigger project that I am working on, and I hope to release it in the near future.)

In Shay’s article, he passes in the entire application to the script; for my discrete functionality, that is overkill. Instead, I pass in an object that represents my input parameters and an object that will hold my output. After I run the script, I use the output information to put the results on the screen. If I really wanted to be picky, I could bind the controls to this object.

Code sample A: The C# code to call the IronRuby script and consume its output.

private void ShowBarbellLoadout(int barbellWeight, int desiredLoad)

{

var resourceStream = Application.GetResourceStream(new Uri("BarbellLoader.rb", UriKind.Relative));

var dataFile = new StreamReader(resourceStream.Stream);

var code = dataFile.ReadToEnd();

var engine = Ruby.CreateEngine();

engine.Runtime.Globals.SetVariable("BarbellWeight", barbellWeight);

engine.Runtime.Globals.SetVariable("DesiredLoad", desiredLoad);

var loadoutResults = (IronRuby.Builtins.Hash)engine.Execute(code);

var results = new List<BarbellLoadout>

{

{new BarbellLoadout{ PlateSize = 45, PlateCount = int.Parse(loadoutResults["45"].ToString()) }},

{new BarbellLoadout{ PlateSize = 25, PlateCount = int.Parse(loadoutResults["25"].ToString()) }},

{new BarbellLoadout{ PlateSize = 10, PlateCount = int.Parse(loadoutResults["10"].ToString()) }},

{new BarbellLoadout{ PlateSize = 5, PlateCount = int.Parse(loadoutResults["5"].ToString()) }},

{new BarbellLoadout{ PlateSize = 2.5M, PlateCount = int.Parse(loadoutResults["2.5"].ToString()) }}

};

loadingChart.ItemsSource = results;
mainPivotControl.SelectedItem = barbellLoading;
}

Code sample B: The IronRuby script.

currentTotal = DesiredLoad.to_i - BarbellWeight.to_i

output = {}
output["45"] = (currentTotal / 90).truncate
currentTotal -= output["45"] * 90
output["25"] = (currentTotal / 50).truncate
currentTotal -= output["25"] * 50

output["10"] = (currentTotal / 20).truncate
currentTotal -= output["10"] * 20

output["5"] = (currentTotal / 10).truncate
currentTotal -= output["5"] * 10

output["2.5"] = (currentTotal / 5).truncate
currentTotal -= output["2.5"] * 5

return output

I learned a very important lesson: All global variables set from the outside must have a capitalized variable name; otherwise, the variables will not work. Even more frustrating, in my script I prefaced the global variables with a dollar sign, and they didn’t balk — the variables auto initialized to the defaults, giving me no output. It took me a couple of hours to really get things working.

One alternative to my technique is to use the dynamic functions of C# 4. For example, a Ruby script could create classes, and you could use dynamic to instantiate them and run their methods from C#. I didn’t try this directly, but dynamic worked when I gave it a dry run in plain C#, and I have no reason to believe that it wouldn’t work to call IronRuby code.

Conclusion

This novel approach is not terribly practical, unless you prefer Ruby or have a deep investment in it. The big issue is that the already lean debugging options are nonexistent in the hosted DLR scenario. You can’t step into the Ruby code; for me to debug it, I copied it into another IronRuby project and set up global variables to replicate what my C# code was setting so I could step into the code. This might be enough for a Ruby pro, but as a Ruby novice, it’s not what I need. All the same, using IronRuby in Windows Phone 7 apps is of interest.

If you want more Ruby on Windows Phone 7, check out iron7, a Ruby interpreter for WP7.

J.Ja