Shows a list of types, methods, fields, etc, depending on the editing context. Provides information about method overloads, and shows documentation if available from Monodoc.

When typing a method invocation shows the parameters that the method accepts.

Move the mouse over an identifier, and MonoDevelop will show a tooltip describing what the identifier is, together with full information about its type.

Syntax errors are highlighted on the fly in the editor, without the need for compilation.

The context menu in the code editor can be used to navigate quickly around a codebase by jumping to the definition, type, or base definition of an identifier. It can also be used to search for references and derived classes.

The text editor features a smart indent engine which attempts to keep state as you type and bases indent level on the entire state of the file and not just the indent level of the previous line.

The editor will enter documentation stubs automatically after typing "/" three times in a comment context. The generated stubs are context-sensitive which will produce the correct default of comments and for existing methods, it will also generate parameter names.

The Standard Header manager allows specifying the header to use when creating new files. You can write your own header, or choose one of the default headers provided.

Simple code templates can be activated by entering the template's keyword, such as 'scwl', and pressing the Tab key. Templates may be added and edited in the Editor Preferences.

The text editor has a class and member selector which allows quick navigation through the contents of the file.

The navigation toolbar allows developers to navigate backwards and forwards in their source file position history, either by using the quick Navigate Back/Navigate Forward toolbar buttons or by selecting a particular navigation point via the history dropdown menus in the toolbar.

The refactoring operations simplify changes like renaming types and type members, encapsulating fields, overriding methods, or implementing interfaces.

The GTK# visual designer is integrated in the IDE workbench. It provides a customizable widget toolbox, a property grid for editing wiget properties, and a widget tree for browsing the structure of a window. The designer generates the required code behind the scenes, using partial classes.

See screencast: Creating a simple user interface with MonoDevelop.

The menu and toolbar designers are based on the UIManager/Action/ActionGroup model. Building a menu is really easy and 'visual'. You only need to add a menu bar to the window and start writing options. The menu designer looks like a regular menu, but clicking on a menu item makes it selected, so that you can change its properties using the Properties pad. Clicking again on the menu item when it is selected will start the editing mode of the menu item, in which you can change the label or the icon.

When you are creating menu items in this way, the designer creates Actions for each menu item at the same time. Those actions are added to the window's ActionGroup.

MonoDevelop can manage icons to be included in a project. The idea is that you select some images, give them an ID, and MonoDevelop will generate a Gtk.IconFactory for you and will register the icons there. You can then use that ID when creating buttons or anything that requires a stock id.

The toolbar located on top of the designer shows some buttons for quickly setting some widget properties. Those buttons change depending on the selected widget.

MonoDevelop allows creating custom widget libraries. Widgets from widget libraries will be shown in the toolbox, and can be dropped to any window just like the stock widgets. Custom widgets can be created using the visual designer, or by just creating a subclass of a stock GTK# widget (in the latter case, the widget must be explicitly exported in the project options dialog).

See screencast: Creating custom widgets with MonoDevelop.

MonoDevelop supports targeting GTK# versions other than the ones installed in the system. For example, in a system running GTK# 2.10 it is possible to select GTK# 2.4 as target version, and the generated application will be linked against the 2.4 libraries.

Support for those additional GTK# versions must be installed using the add-in manager.

ASP.NET projects can be created, built and tested with xsp. These projects fully support the use of CodeBehind partial classes, auto-generating control references in CodeBehind classes and grouping CodeBehind classes with their parent page. They also feature several templates, support for assembly references in web.config, and type/member compatibility resolution.

ASP.NET projects can be deployed to local directories using the Web Deploy command. If the FUSE "sshfs" filesystem is available, it can be used to deploy projects to remote servers.

MonoDevelop provides an "Add Web reference" command, which can be used to create a reference to a web service. This command will generate the proxy classes needed to access the selected web service.

MonoDevelop can generate a complete set of makefile scripts for a solution. Two types of makefiles are supported: Autotools based makefiles, and simple makefiles. Simple Makefiles don't depend on Autotools, and are useful for projects which don't need all the features that Autotools provides, but still need to provide the most common targets such as build, install, dist and distcheck.

MonoDevelop supports integration with Makefiles for projects. This integration covers the following features:

• Delegating build, clean and/or execute operations to Makefiles

Support for the Publish and Checkout commands, which can be used to import projects into a version control repository, and to get a project from a repository. There is a repository selector which allows registering common repository locations.

Publishing a solution is as easy as selecting the solution, clicking on the Publish command, and selecting the target repository. MonoDevelop will create a new module and will import only the relevant project files.

The status view allows reviewing changes done in files, and allows entering commit comments for each file. Comments are stored on disk, so if you close MonoDevelop and start it again, the status window will show the comments you entered.

Version control is fully integrated in the solution pad, so operations like renaming, deleting or moving files or folders will be handled by the version control system.

The ChangeLog add-in can generate ChangeLog entries for the changes made in the committed files. It supports updating several ChangeLog files in a single commit. Every project can have a ChangeLog location policy (which can be for example: create a single ChangeLog in the root project directory, one in each first-level subdirectory, or one in every subdirectory). When committing a set of changes MonoDevelop will locate and add the comments to the correct ChangeLog for every change (creating a new one if necessary).

The integrated NUnit support can be seen in the Test Tree pad where all the libraries in the solution that contain unit tests, and the text fixture hierarchy for each of them is shown. The tree is automatically updated every time the libraries are built. The test tree makes it easy to run tests by just double-clicking on them, and it shows the result of the the last test run using status icons.

This kind of project is a collection of references to existing NUnit assemblies. This is useful if you have some tests in a dll you want to run, but the dll is generated by some other process outside of MonoDevelop. The tests are shown in the test tree just like any other tests in the solution.

The NUnit add-in keeps a history of test runs and the results, and you can easily browse them using the results chart and the test details window. The chart shows the progress of successful runs and failures graphically, and it is also used as a date selector. The list below the chart shows a summary of results for the test selected in the tree and at the date selected in the chart.

It shows a list of tests executed in a test session. Tests can be filtered by result. In case of failure it will show the failure cause and the stack trace.

The Create Package command allows creating packages for an existing project. It supports three kinds of packages:

• An archive of sources, which allows choosing the file format (e.g. MonoDevelop or VS2005).
• An archive of binaries.
• A tarball.

See screencast: Building packages with MonoDevelop

A packaging project can be added to a solution and can define several packages to be built for the solution. Each package can be of different kind (archives, tarballs) and can include different project selections.

The packaging system takes advantages of the extensible deployment model implemented in MonoDevelop, which allows specifying the target directory of project files. For example, it is possible to specify that a file needs to be copied to the libs directory, or to the shared directory.

MonoDevelop includes options to easily integrate applications in the Linux desktop. It can automatically:

• generate launch scripts
• create a .desktop file describing the application. Once installed the application will be shown in the desktop application menu.
• create .pc files for libraries.

The localization add-in simplifies the work of generating and maintaining translations of projects based on gettext.

The add-in provides a new type of project: a Translation Project. It can be added to a solution to provide localization support to all projects in the solution. Adding, compiling and updating the translations is done via the context menu of the translation project in the project browser. When running the Update command, all source files are scanned for translatable strings, and all language files are updated. The add-in also provides a simple .po file editor.

Documentation

Documentation about class libraries is provided by Monodoc. The F1 help key is context sensitive, and will show the documentation, for the type upon which the text cursor is positioned, in MonoDoc.

Command line tools

Several MonoDevelop features are available as command line tools. All tools can be executed using the command 'mdtool'.

• mdtool build: Project and solution build tool.
• mdtool project-export: Project conversion tool.
• mdtool generate-makefiles: Generates makefiles for a solution.
• mdtool setup: Add-in setup utility.
• mdtool gsetup: Graphical add-in setup utility.

MonoDevelop provides an add-in manager that can be used to download and install/uninstall add-ins.

The add-in manager can be started from the MonoDevelop IDE (Tools menu), from the command line (mdtool gsetup), or you can use the command-line version (mdtool setup).

With the add-in manager it is possible to install add-ins from on-line repositories, and keep track of updates. You only need to register the repository url (there is a button in the add-in manager for this), and select the add-ins you want to install. The manager will take care of dependencies between add-ins, or between add-ins and the core assemblies.

MonoDevelop will automatically check for add-in updates once a day (you can change this periodicity in the Add-ins options panel of the preferences dialog).