It’s very common for applications to have a way to extend them. Extensibility comes in various ways and have multiple names too – plug-ins, add-ins, addons, etc. It seems, though, that one kind of extensibility was left to the very few – application macros.
The concept is very simple – You don’t need to create a special Dll, implement a specific interface and register it somehow, you don’t even have to install an IDE. All you have to do is to open the relevant window, write some code and voila – you’ve extended the application.
What is this post about?
I’ll start with the result.
I built a simple application – it has a textbox, a “Send” button and a larger textbox for the application output. The flow is very simple – the user writes text in the textbox, hits “Send” and a “Hello” message appears in the larger textbox:
The power lies in the button on the bottom of the form - “Extensions”. Clicking there will open the extensions dialog, where you can write a macro which will be run after the user clicks “Send”. The users can choose the language for their macro, which will be one of the DLR’s languages – IronRuby or IronPython. After the user writes the code and hits “Save”, the application is extended!
Now when the user clicks send, look what happens:
This sample is very simple but it took me about 20 minutes to get it done. It’s just magic!
How was it done?
Well, all the credit goes to the DLR. This amazing little thing, makes it soooo easy to integrate dynamic languages into the .Net environment, that it’s a shame not to do so.
The heart of this application is the ExtensionRunner class and its Run method:
public static bool Run(Form1 frm, string code, bool rubyCode)
The method receives 3 parameters – the form object to pass to the executed code, the code that the user has written and a boolean value indicating whether it’s ruby or python code.
Firstly, I declare a ScriptScope and a ScriptEngine variables and fill them with the chosen language implementation. Because all DLR languages implement the same interfaces and classes, this is the only language-related code here. After that, the code will fit every DLR language. This means that adding IronScheme and Nua here, for instance, will be a matter of seconds:
ScriptScope scope = null;
ScriptEngine engine = null;
engine = Ruby.CreateEngine();
scope = Ruby.CreateRuntime().CreateScope();
engine = Python.CreateEngine();
scope = Python.CreateRuntime().CreateScope();
Now we declare variables that the macro code will be able to use. We declare 2 variables:
- frm – which is the form object. you wouldn’t want to do that in your application, the right way will be to pass a class with targeted functionality for the extensions.
- return_value – the extension will put a value here. It’s a boolean value which indicates whether we should continue with the regular flow of the application after the extension has been executed or stop.
The rest of the code is pretty straight forward – I create a ScriptSource object from the given code and execute it. Then I get the return_value value and return it to my main application.
// Run the code!
ScriptSource source =
// Get the return value
bool retVal = scope.GetVariable<bool>("return_value");
This is it. The other code of the application is just a regular WinForms code so I won’t deep dive into it.
In conclusion, the DLR makes it very simple to run dynamic languages from your .Net code. I showed you here only one of the possibilities that are made available with this kind of integration.
Go ahead and try!
Download the source code
All the best,
Like it? Share it: Loves soccer? Kick it | Angry? Shout it | In DA ZONE? DZone it