A new release of the Mono runtime and SDK is available for UNIX and Windows. Packages for various distributions are also available from our download page.
This is a delicious release of Mono: so many new things have been improved, implemented, fixed, and tuned from the last release that it is hard to not be excited about it.
Our contract with SourceGear has had a big impact in Mono. The team at Ximian has been working on three areas to pass the rigorous tests provided by the SourceGear team:
SOAP Web Services client implementation.
This includes both the SOAP support classes as well as a complete rewrite of the XmlSerializer by Lluis.
The SourceGear Vault software and its regression test suite require a much better implementation of our HTTP client so we have rewritten it completely for scalability.
Plenty of changes for robustness and tests for stability were added. The new io-layer changes from Dick remove the handle limits that we had in the past.
With this release we are able to run their Vault command line software out of the box.
The MonoDoc tool which includes API documentation for both .NET classes, Gtk# has been updated to include the contents of the Mono tutorial (thanks to Lee and Johannes for their work on the provider).
Binaries for various platforms is available from our web site from the download section:
Source code for Mono, MCS, and XSP is also available from our web site
- MCS package (Class Libraries, C# and VB.NET compiler and managed tools): http://www.go-mono.com/archive/mcs-0.25.tar.gz
- Mono package (Runtime engine, JIT compiler, pre-compiled compiler and class libraries): http://www.go-mono.com/archive/mono-0.25.tar.gz
- Mono Documentation Browser (GUI and command line), which includes also the Mono tutorial: http://www.go-mono.com/archive/monodoc-0.5.tar.gz
Carlos Alberto Cortes, Jean-Marc André, Jaime Anguiano, Joel Basson, Martin Baulig, Tim Coleman, Mark Crichton, Miguel de Icaza, Nick Drochak, Hector E. Gomez Morales, Atsushi Enomoto, Francisco Figueiredo, Piers Haken, Jackson Harper, Dennis Hayes, Rachel Hestilow, Mike Kestner, John Luke, Duncan Mak, Lee Mallabone, Pedro Martinez, Ben Maurer, Dietmar Maurer, Paolo Molaro, Daniel Morgan, Cesar Octavio Lopez Natare, Ville Palo, Gonzalo Paniagua, Alexandre Pigolkine, Dick Porter, Sebastien Pouliot, Ravi Pratap, Marco Ridoni, Johannes Roith, Aleksey Ryabchuk, Lluis Sanchez, Joshua Tauberer, Rafael Teixeira, Gaurav Vaish, Philip Van Hoof, Zoltan Varga Martin Willemoes Hanse, Peter Williams.
This summary does not make justice to the hard work that has gone into this release, so this is just a high-level overview.
Jackson has made a tremendous amount of work on the Mono IL assembler. All the major features in the assembler are now complete.
The big missing pieces now are: debugging support, marshalling support, better error messages and generics support and of course bug fixing.
Sebastien Pouliot reports the following changes since 0.24
- Changed System.Random to use a better implementation (algorithm from Knuth) (Ben).
- Updated most class definitions for framework 1.1 compatibility.
- Fixed PKCS1MaskGenerationMethod to implement PKCS#1 MGF1 (MS implementation is broken) which corrected our support for OAEP padding.
- More generic PKCS#1 handling so RSA can sign any hash algorithm (defined in machine.config) which is far more flexible than the current .NET (limited to SHA1 and MD5).
- Implemented CRT (Chinese Remainder Theorem) for MUCH faster use of the RSA private key (decryption and signature) with Ben’s help.
- X509Certificate supports for CryptoAPI handles in constructor.
- Released GUI certificate viewer for both SWF and GTK# (not yet part of the normal build).
System.Drawing has support for multiple-backends; Alexandre Pigolkine has added a new backend based on Xr (http://xr.xwin.org) to the repository.
This backend is particularly interesting, because Xr implements the PDF imaging system, which is exactly what is required to implement all the features in System.Drawing on multiple platforms.
Today we have three implementations of System.Drawing: XrImpl, Win32Impl and GTKImpl. XrImpl being the one we will use on UNIX systems on the long run.
Codecs for BMP and JPEG were added (they use directly the underlying system libraries).
Aleksey Ryabchuk continues to implement plenty of controls on the Win32/WineLib based implementation of it as well as improving focus, keyboard navigation, common dialog boxes and layout computation.
Joel Basson and Philip Van Hoof continued to improve the Gtk-based port of Windows.Forms.
Lluis worked on a new implementation of the XmlSerialization classes in record time. The XmlSerializer is the foundation for the Soap web services and is also one of the neatest features in the .NET Framework.
It is possibly the best way of dealing with XML documents that I have found so far, and I am kept wondering, why did I bother processing XML in any other way before.
The Web services classes support both RPC and Document, processing as well as Literal and Encoded mechanisms. We have only implemented the client side so far, but most of the infrastructure is in place for authoring the server-side web services.
Erik has written the beginning of our WSDL compiler, but this compiler has not been checked into the repository yet, so today you need to compile your WSDL files using the Microsoft framework tools.
Gonzalo rewrote our Http client to conform to HTTP 1.1, and support all the features in the .NET class library.
Remoting: Soap Formatter
The .NET Framework supports also a Remoting-based SOAP implementation. Jean-Marc ANDRE has contributed a new implementation of System.Runtime.Serialization.Formatters.Soap
XSLT Extension Objects
Joshua Tauberer has written extension object support for XSLT; these are used extensively by the new Monodoc (which will be released shortly after Mono 0.25).
Atsushi Eno continued to improve our XML support and was joined by Ben Maurer in optimizing the XML class libraries. We now allocate about one fifth as much memory while having a 20% speed gain.
Pluggable Profiling Interface
Paolo has made the profiling code modular.
The user can provide new modules to perform profiling-like operations on methods at runtime (see documentation).
The existing profiler has been turned into a module on its own, and we are also shipping a sample code-coverage instrumentation tool.
This interface will be of particular interest to anyone building advanced tool, or who needs special tracing and debugging facilities in the runtime.
We now support Custom Marshallers. This allows fine-grained control over the marshalling and de-marshalling of values during P/Invoke. If the default marshalling schemes provided by Mono are not exactly what you need, you can now manually tune the marshalling to be anything you can think of.
JIT Performance and Runtime Enhancements
Plenty of exciting low-level development, but the high level overview is: faster JITing and faster code generated.
Paolo and Dietmar added support for tail calls and thread-static variables and faster type checking.
Many performance enhancements have been added to the JIT: faster handling of valuetypes, faster calls to some internal helper functions, faster access to two-dimensional arrays.
Dick reworked chunks of the IO-layer to remove the hardcoded limits, and fixed multiple bugs on it.
Our head of testing, Nick Drochak reports that we have managed to get our regression test suite to run fully with .NET 1.1; Ville was responsible for getting many of our System.IO tests running on .NET, those were previously failing.
Patrik Kalkman responded brilliantly to the teams’ call for more unit tests. He contributed some very nice SingleFormatter and DoubleFormatter tests.
The good news in summary: we are down to 50 tests failing down from 200+ just a few weeks ago. There are plenty of tests, but we need even more, here is the current state:
corlib: 1855 tests Microsoft.VisualBasic: 41 tests Mono.Security.Win32: 25 tests Mono.Security: 27 tests System: 134 tests System.Configuration.Install: 1 tests System.Data: 503 tests System.Security: 101 tests System.Web.Services: 5 tests System.XML: 423 tests
It would be nice to use Paolo’s new profiling code together with NUnit tests to find out how much of the API we are currently exercising.
Nick Drochak, who typically is a C# developer has now gone into the low-level code optimization world, and implemented the optimization to improve the following pattern:
(long) uinta * (long) uintb
That pattern is used all over our cryptography classes, and has increased the speed of them, and got a 20% performance increase on the regression test suite for the integer code.
Mono Basic Compiler
Marco has been very busy with the compiler: Plenty of bug fixes in the compiler: methods without arguments do not need parentheses; Various operators fixed; Endregion fixes; Late binding support; Multi-line statements; Redim.
Rafael fixed the Mono.GetOptions and improved some bits of the compiler.
Cesar has checked in the initial code to perform semantic analysis on the JScript compiler
System.Data and System.Web Updates
ADO.NET and ASP.NET got fixes from Ville Palo and Gonzalo: many more regression tests, many fixes, and many improvements. These benefit XSP directly.
This release from Ximian includes Gtk# packages for a couple of distributions.
This release also ships with MonoDoc. MonoDoc has a few new features: Joshua has redone our ECMA provider, so the documentation is nicer, it has more features, and all the links finally work.
Lee and Johannes worked to get us a new provider for MonoDoc: this new provider integrates the Mono Tutorial into the documentation browser.
We need help continuing our Gtk# documentation effort, the .NET documentation effort, and finally improving our tutorial effort as well. If you are interested, check the email@example.com mailing list.
And of course, plenty of bug fixes everywhere: class libraries, compilers, tools, documentation, runtime, and assembler.