eWEEK content and product recommendations are editorially independent. We may make money when you click on links to our partners. Learn More.
When I first reviewed MonoDevelop in June of 2009, I focused on the IDE running under Ubuntu Linux. At the time, some developers had been working on porting MonoDevelop to Windows, but the project wasn’t complete.
But now it is. With the release of Version 2.2, MonoDevelop is now officially supported on Windows. And it looks and works great.
For a look at MonoDevelop 2.2 in action, click here.
The GUI is tight. It’s fast and easy to get around in. The code editor is excellent, including everything you’d expect in a modern code editor, such as full syntax highlighting and a code completion menu that pops up. The code completion pop-up includes functions, variables and members from your own code (which means the code completion is accurately parsing your code).
There’s a Solution window that shows all the files in your project, as well as a complete debugger that features all the usual suspects: breakpoints, inspectors and so on. (The debugger even lets you put expressions in the watch window, which can result in side effects, as the expressions in your code actually get called if you use them in the watch window. In other words, if you write a property accessor, for example, and use the accessor in the watch window and if your accessor has side effects, such side effects will happen as a result of the watch window calling the accessor code. But used carefully with well-written code that avoids side effects, this can be a powerful feature in a debugger such as this one.)
Does It Match Visual Studio?
Certainly, different people reading this review will have different expectations of a product like MonoDevelop. Some might be looking for a complete replacement for Visual Studio. Those people might be disappointed; Visual Studio has some fantastic features that aren’t yet available in MonoDevelop, such as direct access to SQL Server, including the ability to edit table schemas, table data and stored procedures right within the IDE. So in this regard, if you’re looking for a free drop-in replacement for Visual Studio, you won’t find it. (In that case, you’ll want to instead explore the Visual Studio Express editions, which are free-but are also limited and don’t have the full Visual Studio features.)
But if, instead, what you’re looking for is a pretty sweet IDE for developing .NET software that can target the GTK framework, Mono, and from there port to other operating systems, then you’ll be pleased. And while at it, you can target the .NET framework itself without requiring your end users to install Mono. That’s not so bad either. If that’s what you’re looking for, MonoDevelop will certainly deliver.
Targeting Both .NET and Mono
Targeting Both .NET and Mono
In order to run MonoDevelop 2.2 on Windows, you need to first download and install GTK#, which is a set of .NET bindings for GTK+, the cross-platform open-source GUI tool popular on Linux and several other platforms. That installation is quick and painless, and once done, you then download and install MonoDevelop 2.2, which is also quick and painless. (You don’t have to install Mono itself if you don’t want to, in which case you’ll be developing for .NET instead of Mono. Yup, you read that right.)
And with MonoDevelop, you can target both Mono and the built-in Microsoft .NET framework. When you run your compiled program, there’s a menu option that lets you choose which platform to run it under. To make this work, though, you need to download and install the complete Mono runtime, which is a separate download from MonoDevelop. (Otherwise you won’t see multiple choices in the menu; you’ll only see one for Microsoft .NET.)
However, technically, you’re not exactly “targeting” different platforms; your executable file doesn’t change based on the target you choose. The only difference is that your executable either runs by itself (which puts it under the Microsoft .NET platform) or it runs as a parameter to the Mono.exe program, which runs it under the Mono platform. The executable itself isn’t built or compiled differently based on the two platforms. The reason that works is the executable is actually a .NET assembly that contains compiled bytecode stored as data. When you run a .NET executable, there’s some startup code that’s also present in the executable file that executes, launches the .NET runtime and then runs the bytecode stored in the data.
If instead you run the Mono.exe program, passing your executable as a parameter, the startup code isn’t run-Mono.exe launches the Mono runtime, which then reads the exact same bytecode and runs it under Mono. Voila! (In fact, you can take most .NET executables and run them under Mono by simply passing the executable name as a parameter to the Mono.exe program.)
Nice Window Designer
The window designer is quite nice. Similar to Visual Studio and other RAD (rapid application development) tools such as Delphi, you have a window and a toolbox, and you can drag controls from the toolbox onto the window, and then set their properties. At the bottom of the source code window for window classes are two tabs, Source Code and Designer. Technically, these don’t give you two different views of the same thing; rather, Designer is for layout, and Source Code is for accompanying code such as button event handlers.
For some reason, by default, the Toolbox and Properties windows weren’t present when I opened Designer. But they were easy to find under the View menu. And if you’re coming from a Visual Studio background, you might be a little startled to be working in GTK# instead of the usual WinForms world of Visual Studio. With MonoDevelop, by default your windowing applications target GTK#, and so the toolbox is arranged accordingly.
The layout mechanism works as per GTK# rules. You can’t just drop a button on the form; first you have to drop a layout and then drop your controls. And similarly, when you want to create, for example, a button handler, you don’t double-click the button on the form (nothing happens). Instead, you go to the Properties window and click the Signals tab. (In the GTK world, you use signals, which are effectively the same as events.) But this is easy: You just double-click the event-er, I mean signal-name, and Designer will switch to your code view and automatically insert a handler function for you that you can fill in with your own code.
But if you’re watching closely, you might wonder something regarding GTK# and the .NET framework. I mentioned that ultimately you’re building a .NET executable that contains .NET startup code and compiled bytecode. But what if you’re using GTK#? That’s not automatically part of .NET, right? Correct, but you’re fine. GTK# can run under .NET as well as Mono. And that means your compiled GTK# GUI application can run under either .NET or Mono. Of course, that does introduce a caveat: If you plan to deploy your GUI application, the target machine needs to have GTK# installed. (I’d like to petition Microsoft to ship GTK# with all Windows machines. One can dream.)
Different Project Types
Different Project Types
The early days of Mono left a lot to be desired. But in the past couple of years, Mono has really plowed forward with support for many things .NET developers wanted, including ASP.NET and LINQ. And with MonoDevelop, you have access to such features. This makes MonoDevelop compelling indeed.
For example, I was able to quickly create an ASP.NET application using the ASP.NET project template. Although MonoDevelop on Windows doesn’t at this time support a toolbox for ASP.NET (but one is likely to be present in a future version, as there is one for Linux), you can, nevertheless, make use of all the usual ASP.NET server-side controls in your code.
And truth be told, as an ASP.NET developer, I very rarely touch the toolbox in Microsoft Visual Studio. Much of my coding takes place in the C# files, so I don’t even miss the toolbox. However, I’m well aware that many ASP.NET developers would disagree with my sentiments and would like to see a toolbox.
Still, what you do get is a nice code completion feature. If you’re editing an .aspx file, you can type “<asp” and you’ll see a list box appear showing you all the server-side tags at your disposal that are all in the “asp” namespace.
Here’s the full list of what comes built into the Windows version of MonoDevelop at the time of this writing: C# (console application and GTK# 2.0 GUI application), ASP.NET (Web application or ASP.NET MVC), Moonlight (still in beta, but it’s already pretty nice), NUnit, so-called samples (for Glade# and Gnome# projects), IL, packaging projects and a set of VB.NET projects similar to the C# ones (including ASP.NET but no MVC).