Manning published my white paper — or green paper as they call it — on IronRuby.
You can find it here: http://manning.com/free/green_carrero.html
This paper tries to give you an introduction on what the ruby language is and how it could work for you. If you want to know more than what’s on those pages there is always the book: http://manning.com/carrero
I thought it might be a good idea to update you guys on how IronNails is progressing. I think I’ve got it so that you aren’t exposed to writing many of the boring boilerplate code that comes with taking this approach (M – V – VM- C). Also to execute an action on a controller asynchronously you can by just adding :mode => :asynchronous to your view_action declaration.
A lot is still left to do but this proves that it is possible to use IronRuby today to do some pretty cool stuff. From the top of my head here are some things that still need to be done:
But the core of the framework is working. Now it’s a matter of extending the functionality. Some of the features the framework does support
I will be developing my sample for my chapter against this framework and will add the pieces I’m missing as I get on.
Some of the things I foresee that might need to be added are:
So after all these lists how would an application look like when you are developing it?
The controller:
# file name: demo_controller.rb
class DemoController < IronNails::Controller::Base
view_object :status_bar_message, "The status bar message"
view_action :change_message
def change_message
@status_bar_message = "#@status_bar_message appended"
end
end
The ViewModel:
# file name: DemoViewModel.cs
public class DemoViewModel : IronNails.View.ViewModel { }
The View:
<Window
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:behaviors="clr-namespace:IronNails.Library.Behaviors;assembly=IronNails.Library"
Title="Window1" Height="300" Width="300">
<StackPanel>
<TextBlock Text="{Binding Objects[StatusBarMessage].Value}" ></TextBlock>
<Button Content="Click me" behaviors:ClickBehavior.LeftClick="{Binding Commands[ChangeMessage]}" />
</StackPanel>
</Window>
There are currently 2 dictionaries available to the view. One that contains the models (Objects) and one that contains the commands (Commands). The value of an entry in the Objects needs to be observable by implementing INotifyPropertyChanged and that is what’s responsible for the binding syntax Objects[ModelName].Value
At this moment there are only a couple of behaviors implemented: LeftClick, RightClick, DoubleClick and Hover.
The framework expects that you follow the basic naming conventions of the technology you’re programming in. So in ruby you underscore names but in C# and xaml you camelcase them.
By defining an object with view_object 
bject_name, default value you define it with a default value that you can change afterwards in the controller actions. By defining an action with view_action :action_name, :mode => :asynchronous you tell that framework that you want to link a method or a block as a controller action and execute it asynchronously.
I finally managed to figure out what the insert key is on my macbook pro. I missed it a lot because in Resharper the standard command to generate code is Alt+Ins. This key combination seems to be engraved in my brain because it was really hard for me to use it with a different key combination. Anyway the winning combinations are:
Insert: fn+return
Alt+Insert: fn + alt/option + return
For my book IronRuby I’m working on chapter 4. That chapter is about doing WPF development with IronRuby. I started out with a straight port of Witty to IronRuby. As I was doing that the cogs started turning and I came up with a way to bring the rails style of development to WPF. I decided to investigate that route a little bit further and now I have a small framework that enables you to write WPF applications with the MVC paradigm. I decided to open that code up as open source and host it on github.
At first I used the name Sails for my framework but it turns out there is java clone of rails that is called opensails. So to avoid confusion David M. Peterson proposed the name IronNails.
On Sat, 02 Aug 2008 08:00:44 -0600, Charles Oliver Nutter wrote:
FYI, there’s already a framework named "Sails" for Java:
http://www.opensails.org/For the sake of sticking to the "Iron" theme, why not replace the ‘S’ with an ‘N’ and go with IronNails.
Maybed it’s just me, but if given the choice, I’d much rather nail it than sail it any day of the week.
–
/M:DM. David Peterson
You can find the project here: http://github.com/casualjim/ironnails
At this moment it’s definitely not finished at all, but it does work. The remainder of the week I’ll move my previous demo code onto this framework, update the code samples in my chapter and finish the content. I hope I will have all of this done by the end of next week.
Back to the IronNails project:
Because DLR objects cannot be used to bind to in WPF you have to define a skeleton of the ViewModel in C#, but this will change in the future. When that changes I’ll look at extending the framework to make use of some other WPF patterns like defining a DependencyObject and Behaviors. Once those are defined you get a very clean separation between design and behavior.
This is abstracted away from you but in the background the framework works with the View – ViewModel – Model – Controller pattern although I’ve tried to keep your exposure to the view model to a minimum. The framework follows naming conventions per language. So in C# and XAML you camel case stuff and in IronRuby you underscore stuff.
The very core of the framework is defined in C# but most of the code is IronRuby, depending on how hard it will be after the DLR RTM’s I may look at adding support for all the DLR languages.
IronNails
=========IronNails is a framework inspired by the Rails and rucola frameworks. It offers a rails-like way of developing
applications with IronRuby and Windows Presentation Foundation (WPF).
This framework uses the pattern Model – ViewModel – View – Controller (M-VM-V-C). It should be able to run on both WPF
and Silverlight.
The idea is that the views can be created using a design tool like Blend for example and just save that xaml as is. The
designer should not need to use anything else than drag and drop to create a GUI design. The behaviors are then added to
the view by using predefined behaviors in the framework or by defining your own behavior.
The framework then generates a proxy for the view which will be used to transparently wire up the commands in the
behaviors to controller actions.
You are now able to write the following code for a controller:
class MyController < IronNails::Controller::Base
view_action :show_message, :triggers => :my_button do
MessageBox.show "This is the great message from a block"
end
view_action :change_color, :triggers => { :element => :my_text_block, :event => :mouse_enter }
view_action :reset_color, :triggers => { :element => :my_text_block, :event => :mouse_leave } do |view|
view.my_text_block.foreground = :black.to_brush
end
view_object :people, Person.find_all
def change_color(view)
view.my_text_block.foreground = :red.to_brush
end
end
At this moment the project has 0 unit tests, it has below minimal documentation and it still needs a work like defining the behaviors. I have to move on with my book but intend to continue developing this framework after my book is finished and IronRuby RTM’s. There are some more workarounds in the project that will all disappear as IronRuby progresses.
You are currently browsing the Ivan Porto Carrero weblog archives for the month August, 2008.
Longer entries are truncated. Click the headline of an entry to read it in its entirety.
