Cross-Platform Network Applications with Mono

Curious about .NET? Try out this useful sample app that exercises the GUI and XML-RPC features of Mono.

Mono is Ximian's open-source implementation of Microsoft's .NET
development framework. .NET contains several different technologies: a set of
compilers for many different languages (including Microsoft's new
language, C#) that generates platform-independent bytecode; a virtual
machine known as the Common Language Runtime (CLR) that runs these
bytecodes; and a class library full of useful programs for performing
actions ranging from file I/O to GUI creation and operation.

The Mono
implementation includes a CLR that runs on Linux, BSD-based systems
(including Mac OS X) and Windows, plus compilers for C# and Basic. Mono
is a work-in-progress, and many parts of the .NET class library have
yet to be implemented, specifically the Windows.Forms group that
contains classes for working with the Windows GUI. However, the Mono
developers have released bindings for the GTK user-interface toolkit,
so cross-platform graphical applications can be constructed even
without 100% .NET compatibility. This article describes how to use
C#, Mono and Linux to write a useful program, MonoBlog, that can run
on any system that runs Mono and GTK. Some familiarity with Glade and
C# is assumed, but only at a basic level. Helpful tutorials can be
found in the on-line Resources section.

Obtaining Mono

The Mono Web site
has instructions for
installing the system on Linux, Mac OS X and Windows platforms (see
Resources). You
also need two additional C# libraries, GTK#
and XmlRpcCS.
The systems that MonoBlog
runs on require the base GTK libraries, which are available on
most Linux systems. They probably need to be installed on Windows
and Mac OS X systems, however; packages can be found on the GTK Web site
(see Resources).
Instructions for installing these libraries can be found on their
respective Web pages.

MonoBlog, a Weblog Editor

MonoBlog is a Weblog editor that can add new posts to a Weblog and edit
old ones, as well as provide a way for a user to change
configuration settings. Most Weblog systems implement
a common base of functionality known as the MetaWeblog API. MonoBlog
uses this to communicate with a variety of different Weblog programs,
rather than write a separate back end for Movable Type, LiveJournal
or Radio Userland systems. The complete C# code for this example
is available on the Linux Journal FTP site (see
Resources).

Figures 1 and 2 show the user interface of MonoBlog, created using
Glade on Linux. The main window in Figure 1 has text controls for
entering Weblog titles and the content, plus a series of buttons for
updating the Weblog, clearing the forms and quitting the program. The
expanse of white on the left-hand side is a GTKTreeView control, which
displays a list of older posts the user can click on in order to
update. The window shown in Figure 2 is a simple preferences panel
where users enter the information that allows MonoBlog to
communicate with their Weblogs.

Figure 1. The Main Window

Figure 2. The Preferences Window

Creating the GUI with libglade

One of GTK's useful features is libglade, a library that allows us to
construct a program's GUI by reading in the XML files created by Glade,
specifying the layout of the widgets in the code
itself. The GTK# binding includes this functionality, so building the
GUI is quite easy. At the start of MonoBlog, we import the GTK and
Glade namespaces with the using statement. Then, in the
constructor, we have:

The calls to the Application class are required in all GTK programs.
Application.Init() performs GTK initialization, and Application.Run()
passes control of the program to the GTK main loop, which watches for
events and reports signals back when they occur. The standard Glade.XML
constructor takes three arguments: a string containing the filename of
the Glade file, a string that tells the object the node in the Glade
tree where it should start building the interface and, finally, a string
that can be used to specify a translation domain for the Glade file in
question.

MonoBlog needs to have access to all the nodes in the XML
file, both the main window and the preferences panel. No
translation is required, so the second and third arguments are null.
The Autoconnect() method binds the object given as an argument with the
signal handlers and objects defined in the Glade file, allowing that
object to respond to events and manipulate widgets. As MonoBlog is a
small program, I have contained all the signal handling within the
main class. In larger, more complex systems, it might be advisable to
separate signal handling out into another class.

To access the widgets,
a special declaration is required. The widget must be declared as an
instance variable, using a custom attribute:

Trending Topics

Upcoming Webinar

Getting Started with DevOps - Including New Data on IT Performance from Puppet Labs 2015 State of DevOps Report

August 27, 2015
12:00 PM CDT

DevOps represents a profound change from the way most IT departments have traditionally worked: from siloed teams and high-anxiety releases to everyone collaborating on uneventful and more frequent releases of higher-quality code. It doesn't matter how large or small an organization is, or even whether it's historically slow moving or risk averse — there are ways to adopt DevOps sanely, and get measurable results in just weeks.