Release Notes Mono 2.6.7

Release date: 14 Jul 2010

Mono 2.6.7 is a portable and open source implementation of the .NET framework for Unix, Windows, MacOS and other operating systems.

Table of contents

Major Highlights

Mono 2.6.7 is a bug fix release for Mono 2.6.

These are some of the major features in this release:

  • MVC2 is now included
  • Latest versions of:
    • Soft Debugger
    • Mono’s xbuild tool
    • LINQ to SQL binding
  • WCF client and server, the subset exposed by Silverlight 2.0
  • LLVM support, to improve performance on server/computational loads
  • Co-routine framework Mono.Tasklets
  • Latest version of LINQ to SQL using DbLinq
  • New Soft Debugger, integrated with MonoDevelop 2.2
  • Joint release with MonoDevelop 2.2.2
  • System.IO.Packaging
  • csharp shell now supports auto-completion
  • xbuild can now build most msbuild projects
  • Support for CoreCLR security:
    • Mono debuts a full metadata and IL verifier
    • Security system used by Silverlight applications, reusable for other cases.

These new features are described below in detail.

Changes since Mono 2.6

Specific bug fixes include:

  • 621599 - Verifier incorrectly rejects this code snippet
  • 620860 - Number Overflow inserting into sqlserver
  • 619300 - [verifier] fails to validate deeply nested generator accessing sibling nested private class
  • 616739 - [PATCH] Context menu items activated by key shortcut when menu not visible
  • 615952 - Assertion: should not be reached at marshal.c:584
  • 615940 - [PATCH] NullReferenceException in context menu
  • 615320 - Can’t serialize relative System.Uri objects
  • 615315 - DataPager goes to the wrong page
  • 614909 - Process.Exited Event Fires Only Once for Individual Process Object
  • 614483 - WebClient UploadData does not allow method DELETE
  • 613845 - Decimal Parameter stored wrong in Money-attribute in database
  • 613087 - Unable to convert SqlInt64 to SqlDecimal
  • 612780 - SIGABRT: unknown type 0x16 in mono_class_array_element_size
  • 612702 - compiler infinitely loops when trying to AOT compile Mono.C5
  • 612206 - Variable value corruption when assigning from exception-throwing overriding method/property
  • 612135 - System.Net.IPAddress.Parse doesn’t throw exception for certain invalid ip addresses
  • 610625 - Incorrect Incompatible type ‘U ([boxed] Complex)’ on stack cannot be stored to local 1
  • 610587 - Long perform a regular expression.
  • 609935 - Insert into Sqlserver nvarchar(max) fields truncates data > 4000 characters
  • 609478 - Validating control inside Repeater prevents ItemCommand to fire
  • 609109 - [Regression] Incoming tablular data stream (TDS) remote procedure call (RPC) protocal stream is incorrect.
  • 609023 - Interlocked.Exchange(ref int, int) raises a “System.ExecutionEngineException: SIGILL” exception on a S390X platform
  • 608271 - Windows: Mono/SDB crash on exit
  • 608073 - exception in cctor is not caught by mono_runtime_invoke
  • 607766 - Problem with local resources
  • 607722 - ObjectDataSource’s update paramaters fail
  • 607502 - File.* functions not handling network drivesp roperly
  • 606353 - [verifier] abort in inflate_generic_signature
  • 605698 - Error on server side when debugging BlogEngine remotely
  • 605295 - Memory leak with DynamicMethod and –debug
  • 604911 - Unable to debug blogengine locally in mono
  • 604502 - HttpServerUtility.Execute() fails with ASP.Net MVC 2
  • 604054 - Crash: Can’t handle methods of type System.Reflection:MonoGenericMethod
  • 604053 - Invalid TotalRowCount for data sources which cannot page
  • 603541 - Server control fails to load
  • 603532 - Resource expressions in the the page directive attributes don’t work
  • 603083 - Cacheduration in objectdatasource causes notimplementedexception
  • 602411 - Uri composition is buggy
  • 601772 - String.Split() can return too many substrings
  • 601727 - Cannot use Web Forms MD5 authentications
  • 601290 - System.Web.UI.CollectionBuilder error parsing collections with multiple indexers
  • 600740 - Setting domain on <forms> tag doesn’t change auth cookie
  • 600691 - Localized resources cause a compilation error
  • 600508 - Verifier rejects valid assembly
  • 600415 - CheckBoxList doesn’t retain unchecked items after postback
  • 599469 - Generic class with nested class causes mono crash (with test case)
  • 598908 - Error in FTP EnableSsl
  • 598467 - TimeSpan.TryParse() method crashes if I pass for example this “12::4”
  • 597604 - String.IndexOf(String.Empty,index,StringComparison.CurrentCultureIgnoreCase) returns 0 instead of index
  • 597556 - HttpWebRequest doesn’t ignore chunk-extension in chunked encoding
  • 596975 - [verifier] g_error/abort in mono_class_inflate_generic_method_full on a bad assembly
  • 596779 - InvalidOperationException in Process.GetProcessesByName
  • 594559 - DateTime.TryParse fails to parse “0009-05-02 20:00:00.00” because of the .00 for ms
  • 594035 - Problem with culture - Culture name en-tt is not supported
  • 593596 - HttpWebRequest.Abort Does Not Properly Abort Request
  • 592244 - Mono.Debugger.Soft.VMDisconnectedException when inspecting any List<T>
  • 591136 - System.Net.NetworkInformation.Ping unreliable when running as a user other than root.
  • 583934 - WebRequest.get_CachePolicy throws NIEX
  • 582162 - XSP2 crashes serving static images
  • 581956 - Mono prints “NOT IMPLEMENTED: ResetToDefault()”
  • 581679 - System.InvalidCastException: Cannot cast from source type to destination type.
  • 576342 - Code involving type instantiation in attributes throws at runtime
  • 569543 - SqlClient using Guid in parameter
  • 567884 - [verifier] abort in mono_class_get_method_by_index while JITting a verified method
  • 564253 - [verifier] SIGSEGV in set_stack_value (2) on a bad assembly
  • 560839 - [verifier] SIGSEGV in mono_class_is_open_constructed_type on a bad assembly
  • 560336 - [verifier] abort in mono_class_inflate_generic_type_no_copy on bad assembly
  • 531613 - System.Diagnostics.Process StandardInput stream doesn’t handle short writes properly
  • 484246 - Type.GetInterface(string) fails to search by generic type definition
  • 464464 - [PATCH] Text box does not paint underscores on MacOS
  • 456723 - System.Net.GetHostByName throwing SocketException
  • 422113 - Segfault in Activator.CreateInstance with incomplete SRE-created type
  • 596339 - Converting double.NaN to int doesn’t generate OverflowException
  • 595918 - Decimal parameter stored incorrectly from sql stored procedure
  • 595863 - Crash when using nhibernate with bidirectional many-to-many relation
  • 594464 - SIGSEGV in ToObject
  • 594110 - SSL X.509 SubjectAltNameExtension does not work with more than 1 value (breaks HttpWebRequest)
  • 592981 - UnixSignal.WaitAny not interrupted when exiting
  • 592711 - –debug=casts does not work for arrays
  • 592215 - **ERROR**: overrwritting old token 3
  • 591800 - SIGSEGV in CustomAttributeBuilder
  • 591733 - [sdb] Cannot automatically break on NullReferenceExceptions
  • 591633 - Basic WebAuth fails.
  • 591443 - Cloning a DataColumn with Expression result in a DataColumn in an invalid state
  • 591397 - System.Data.DataTableExtensions.CopyToDataTable(Of T) returns 0 Rows
  • 591000 - SUSE debuginfo script crashes on Mono AOT .so
  • 590503 - GdipCloneImage does not clone PropertyItem.value
  • 590488 - Not an exception when connecting to the socket.
  • 590232 - DataColumn.Clone doesn’t clone the extended properties
  • 589482 - DataTable.Clone loses the AutoIncrement of Columns of type Decimal
  • 589305 - FtpWebRequest with keepalive=false doesn’t work correctly
  • 589236 - StreamReader class raise IndexOutOfRangeException
  • 588356 - NullReferenceException thrown System.Convert.ChangeType
  • 588165 - CultureInfo for da-DK dosen’t have the right format.
  • 587849 - IL: Missing expected ref ‘test.ThisClass`2[T,O]’
  • 582667 - DirectoryInfo’s property exists doesn’t get updated when folder is deleted.
  • 576520 - DataTable.WriteXml has a wrong behavior when using a column of type “object”.
  • 575941 - Mono crashes (assert) when compiling generic code in F# Interactive
  • 574713 - crash if System.IO.Compression.DeflateStream.ReadZStream is called
  • 567882 - abort in mono_try_assembly_resolve while JITting a verified method
  • 567040 - abort in mini_emit_memcpy while JITting a verified method
  • 566296 - abort in mono_local_regalloc while JITting a verified method
  • 565765 - After crash, 100% cpu spin on Mac
  • 565598 - abort in mono_spill_global_vars (load_opcode != OP_LOADV_MEMBASE) while JITting a verified method
  • 565149 - ORACLE StoredProcedure with OracleParameter type NUMBER OutPut throw ORA-06502
  • 547675 - [PATCH] DateTimeOffset fails to parse timezone fragment when its value has no separator
  • 531767 - Cross compiling mono on Linux to Windows fails on Ubuntu
  • 515884 - call on virtual/final property gives runtime error while callvirt works fine
  • 473298 - MonoReflectionGenericParam unmanaged shadow object is not kept in sync with GenericParameterBuilder
  • 440924 - Large arrays cause “mini-ppc.c:2070:ppc_patch: code should not be reached “ errors
  • 564408 - Worse Performance reading items selected with Linq 2 Obj
  • 580736 - [Regression] System.Data failure on ClubWebSite when running on mono-2.6.3
  • 567904 - RadioButton.Appearance = Appearance.Button does not work
  • 575731 - Invalid RichTextBox paste behavior
  • 574991 - Respect pragma warning disable on partial definitions
  • 564833 - DataAdapter’s fill method throws exception in connection with DbProviderFactories
  • 564987 - Make check fails with compile error
  • 480152 - string.Normalize() frequently produces incorrect output
  • 567676 - abort in mono_class_inflate_generic_method_full while JITting a verified method
  • 562155 - XML parsing fails when executing on iPhone
  • 560327 - [verifier] abort in mono_class_inflate_generic_class on bad assembly
  • 574434 - segment fault on System.MonoCustomAttrs.IsDefinedInternal
  • 325489 - backcolor strange behaviour
  • 322957 - AppDomain.TypeResolve event raised for System.Int32
  • 571336 - XmlDocument XmlElement creation is broken.
  • 573329 - csharp shell multi-line continuation inoperable
  • 475815 - int.TryParse fails with very large numeric values.
  • 489339 - ComboBox popup suggestion box does not appear on linux
  • 562043 - HttpWebRequest returns ‘invalid length’ if kernel-mode auth is not enabled on IIS 7.0
  • 566311 - Unable to open project in Xcode
  • 567351 - Cannot SetValue of Nullable Property
  • 574842 - DomainUnload debug events have wrong id during Domain Unload.
  • 577984 - Mono AOT can not handle reference to parameter type return values.
  • 385497 - Process Start doesn’t handle spaces in paths
  • 566057 - SetMaxThreads does not allow you to set a limit lower than its default
  • 577818 - WebClient.UploadStringAsync always throws NotImplementedException
  • 577891 - HttpListener incorrect headers parsing under moderate load
  • 578271 - System.Net.Mail.SmtpClient ReplyTo header is incorrect
  • 579146 - Disk Full Error doesn’t release handle on files
  • 584050 - ServerCertificateValidationCallback receives wrong certificate chain
  • 586870 - Exception when serializing empty byte array generated from empty string
  • 542464 - Int32.Parse doesn’t respect NumberStyles.AllowExponent
  • 547753 - ItemGroups seem to get corrupted/truncated after using the CallTarget task within a target
  • 558739 - Invalid ResX input. at System.Resources.ResXResourceReader.LoadData ()
  • 562056 - xbuild does not accept properties containing ‘:’ passed by CLI..
  • 565849 - CreateItem transformation returns wrong results
  • 566087 - NoWarn ignored when TreatWarningsAsErrors is true
  • 576579 - xbuild does not use default namespace as part of resource id for embedded resources
  • 576589 - xbuild conditional statement ‘Exists’ does not seem to work
  • 568989 - linq expression code causes mono_method_to_ir assertion
  • 576810 - Cannot run VS packaged BlogEngine 1.5 on SLES 11 w/mono-2.6.2
  • 548988 - Cannot bind Web Service Type from return XML on Monotouch
  • 561962 - Cannot inspect nullable values
  • 564538 - Stepping doesn’t walk to previous frame
  • 582460 - Multi-threaded app crashed using soft debugger
  • 550968 - Inlining causes exceptions if assembly isn’t available
  • 560196 - [verifier] abort in get_call_info (both x86 and x86_64) while JITting a verified method
  • 564695 - LLVM support: this sample generates very slow code.
  • 566294 - abort in mono_type_generic_inst_is_valuetype while JITting a verified method
  • 566295 - sigsegv in mono_save_args while JITting a verified method
  • 566689 - Ahead of time-compiled multithreaded app fails under Mono 2.6.1
  • 567084 - sigsegv in mono_method_to_ir while JITting a verified method
  • 569390 - SIGSEGV Error with MarshalByRefObject implementing a generic interface
  • 574819 - CRITICAL **: mono_bitset_test: assertion `pos < set->size’ failed
  • 576341 - Modulus on Decimal values does not work as expected
  • 581950 - Using checked int64 op codes results in runtime crash
  • 582322 - SIGABRT when constructing java.text.DecimalFormat (through IKVM)
  • 583817 - SIGABRT (ERROR:mini-trampolines.c:183:mono_convert_imt_slot_to_vtable_slot: code should not be reached) using Saxon
  • 586664 - Incorrect values in array after very basic operations
  • 559990 - Microsoft.Build.BuildEngine.Engine.UnloadAllProjects() throws an exception when invoked with 1 or more projects
  • 423853 - monodoc crashes on search for “()”
  • 510995 - Cannot implicitly convert `string’ to `object’
  • 559045 - Printing an array of enum shows wrong garbage values
  • 567900 - Runtime Crash in ves_icall_System_Globalization_CultureInfo_construct_internal_locale_from_specific_name
  • 567944 - FirstDayOfWeek not parsed when creating culture-info-tables.h
  • 573988 - Soft debugger is broken on systems not supporting MMAP_32BIT flag (Solaris, probably *BSD)
  • 565547 - ObjectStateFormatter fails to convert collections from string
  • 566541 - Empty HtmlForm produces JavaScript Code
  • 568366 - NET_2_0 profile : BuildManagerDirectoryBuilder AddVirtualDir infinite loop
  • 568441 - Web.config <location>-><authorization> tag doesn’t work
  • 568631 - aspx/ascx files can not be compiled when an asp:Literal-tag is embedded in another tags attribute
  • 568843 - mod_mono sets max_memory on RLIMIT_DATA, which usually won’t do anything
  • 571365 - Incorrect JSON Responses
  • 572781 - OnInit event of SqlDataSource does not fire.
  • 578586 - Cannot compile ASP page using Microsoft Chart Control
  • 578880 - System.Web.Hosting.HostingEnvironment’s IsHosted, ApplicationID and SiteName properties not provided for a hosted environment
  • 579241 - System.Web.HttpFileCollectionWrapper (System.Web.Abstractions.dll) Get method and indexer by name throw exceptions for unfound name/index
  • 580086 - Running mod_mono from git on apache gives constant “Abnormal string size” exceptions
  • 580594 - System.Web.Mvc.Resources.MvcResources.resources: Could not find any resources appropriate for the specified culture or the neutral culture.
  • 580692 - Treeview nodes not applying font colour correctly using stylesheet class
  • 581459 - Process restarts by thread abort with AspNetForums and mono-2.6.3
  • 581594 - Plus sign, +, in URLs gets messed up during MVC request handling
  • 585933 - DropDownList items and GridView columns don’t translate.
  • 585968 - XmlDataSource does not update cache when DataFile property changes.
  • 585992 - HttpUtility.HtmlDecode does not decode hexadecimal coded HTML entities
  • 327053 - System.IO.MemoryStream is too eager in zeroing data
  • 473725 - MessageBox.Show() makes no sound
  • 505105 - Exception message uninformative (different from with MS .Net)
  • 536919 - Parallel.For doesn’t execute when number of iterations is fewer than number of processors
  • 561239 - Monitor.Pulse() Monitor.Wait() Thread.Abort() cause mono hang
  • 564095 - Construct of System.Collections.Generic.List<T>(IEnumerable<T> e) creates list with e.Count null-Elements
  • 564910 - The CultureInfo class does not support the Georgian culture
  • 565120 - Type.IsVisible might throw null reference exception
  • 565152 - Directory.Exist should not ever throw an exception
  • 565923 - runtime always SEGFAULT booc.exe upon exit and reports exit code 139
  • 566106 - String.IndexOf returns incorrect value
  • 567847 - Disabled GroupBox isn’t grayed out (ie: looks the same as enabled)
  • 567857 - DateTime.TryParseExact throws NullReferenceException on null string
  • 567872 - Missing public default constructor on System.Transactions.TransactionAbortedException
  • 568026 - TrackBar: Scroll event should occur BEFORE ValueChanged
  • 569530 - IndexOutOfRangeException when loading RTF into RichTextBox
  • 569806 - mono assumes c99 flexible array member syntax is available without testing
  • 569940 - Mono crashes when using System.Drawing.Image.FromFile with a special TIF-File
  • 569950 - RichTextBox Modified property not set when (Selected)Text changes
  • 571226 - Regression in System.Configuration Test Suite
  • 572643 - ForeColor for selected ToolStripComboBox item in ownerdraw mode should be set to highlighted text
  • 572660 - mono_metadata_decode_row assertion with System.Reflection.Emit circular array field type
  • 572738 - 13 Test Regressions in XmlDataDocumentTest
  • 572874 - ValueType.Equals fails on structs containing nullables
  • 573322 - Array.SetValue is very unreliable for arrays of Nullable types
  • 573682 - segtaults when encoding/decoding non-UTF8 strings
  • 575946 - Dynamically generated code doesn’t initialize static values as expected
  • 575955 - Accessing 2D array cells in dynamically generated code causes crash (assert)
  • 575986 - Linq Where extension method fails on typeof(T) for generic method parameter
  • 577029 - Can’t build ironruby on mono 2.6.1 or trunk
  • 579493 - System.NotSupportedException: Custom attributes on a ParamInfo with member System.Reflection.Emit.MethodOnTypeBuilderInst are not supported
  • 579791 - HashSet<T> does not handle null values when using a non-default comparer
  • 579984 - EMail (SmtpClient) with text and html mail with linked resources are not get generated correctly
  • 582440 - ResXResourceReader does not read resource comments.
  • 582691 - Return key works intermittently in TextBox
  • 585017 - Path.GetTempFileName () takes 100% CPU if /tmp is not writable
  • 585455 - HttpListener does not handle authentication completely
  • 577090 - Intermittent threading issue with Mono 2.6.1 and SmartThreadPool
  • 562320 - [verifier] SIGSEGV in set_stack_value on a bad assembly
  • 564897 - [verifier] abort in mono_method_get_signature_full (2) on bad assembly
  • 567548 - [verifier] SIGSEGV in mono_class_init (cmethod) on a bad assembly
  • 570648 - System.IO.Packaging ZipPackage does not work due to Uri issue
  • 582991 - Soft Debugger: Incorrect number or types of arguments error when calling int.Parse
  • 576618 - IndexOutOfRangeException on 12 Remoting test suite tests
  • 578587 - Global.asax’s issue
  • r148593 - Fixes the IPY+Chiron test case.
  • 556884 - Shadow copies of assemblies cannot be overwritten if originating assembly files are read only
  • 545417 - ListView + DataPager fails while trying to set up custom paging
  • 565117 - Crash in System.MonoCustomAttrs.IsDefinedInternal
  • 565127 - GetGenericParameterConstraints fails on methods in dynamic modules
  • 564379 - [REGRESSION] 2.6/git gmcs throws CS1501 on overload/explicit implementation resolution
  • 565602 - string.PadRight(int, char) returns empty string



It now consumes less memory while building the ECMA documentation


Merged the changes from the MonoTouch linker branch.


Updated to the latest version of xbuild from Mono 2.7



Upgraded the DbLINQ engine that powers our LINQ to SQL to the latest drop.


We now included MVC2


Support for Android

Soft Debugger

The Soft debugger now:

  • groups events received into an EventSet.
  • adds support for returning visible variables from the current stack frame
  • GetSourceFiles () can now return full filename paths
  • Made it simple to support remote debugging

Included the Soft Debugger test suite.

Many updates to the Soft Debugger

Changes since Mono 2.4

This documents the changes since Mono 2.4.

LINQ to SQL details

LINQ to SQL (in System.Data.Linq.dll) is now partially supported through the collaboration of the DbLinq team and the Mono teams. It is known to work for applications like NerdDinner, but it is not fully finished yet.

Mono’s LINQ to SQL is not limited to SQL server. While exposing the same API in System.Data.Linq.dll it is possible to use many other database providers by specifying the database provider on the connection string, the databases currently supported include:

However, the only providers regularly tested are the SQLite and SQL Server providers.

The default provider is Microsoft SQL Server; to specify an alternate provider provide the DbLinqProvider and DbLinqConnectionType parameters. DbLinqProvider specifies which “SQL dialect” to use, and DbLinqConnectionType is the fully qualified .NET type to use for the connection type (permitting late binding). For example, to load a SQLite file using System.Data.Linq.DataContext:

var db = new DataContext("DbLinqProvider=Sqlite; " +
    "DbLinqConnectionType=Mono.Data.Sqlite.SqliteConnection, Mono.Data.Sqlite, " +
        "Version=, Culture=neutral, PublicKeyToken=0738eb9f132ed756; " +
    "Data Source=Northwind.db3");

DbLinqConnectionType can be skipped if you provide your own IDbConnection instance, e.g.

var conn = new SqliteConnection (
    "DbLinqProvider=Sqlite;" +
    "Data Source=Northwind.db3"
var db = new DataContext (conn);

System.Data.Linq support is not complete. (At minimum, missing is improved support for databases, CompiledQuery support, support for some method calls within select expressions, and general Linq-to-SQL compatibility.) We would appreciate any feedback and/or bug requests at DbLinq’s bugzilla.

Soft Debugger details

Mono 2.6.1 features a new debugger engine, the Mono Soft Debugger.

This new debugger engine lives inside the Mono process and as opposed to hard debuggers it is more reliable at debugging, but does not allow developers to debug assembly-language when debugging their Mono applications.

This debugger can be used from MonoDevelop and can debug ASP.NET, Moonlight, Desktop, server and iPhone/MonoTouch applications.

Early 4.0 APIs

This release includes partial support for C# 4.0 and includes some of the upcoming .NET 4.0 APIs. Since these APIs have not officially been completed by Microsoft, they could change without notice.

If you want to try out C# 4.0 and the new .NET 4.0 APIs, you should configure Mono with: –with-profile4=yes.


This release includes some components of the ParallelFx framework that were developed as part of Google Summer Of Code 2008 & 2009. More precisely, it contains the Task Parallel Library and Data Structures For Coordination.

Using ParallelFx, you can easily develop software that can automatically take advantage of the parallel potential of today multicore machines. For that purpose, several new constructs like futures, parallel loops or concurrent collections are now available.

To use this code you have to manually enable the .NET 4 profile using the –with-profile4=yes switch at configure stage.

Dynamic Language Runtime

The dynamic language runtime (DLR) is now distributed as part .NET 4 profile. This includes a new System.Dynamic assembly and significantly expanded expression trees in System.Core.


The WindowsBase assembly which was previously part of the Olive module is now part of the standard Mono distribution. This assembly sole purpose is to provide the System.IO.Packaging API, a .NET API for ZIP files that has recently become popular.


176 bugs were fixed. Highlights:

  • DataGridView - major stability, functionality and performance improvements.
  • PropertyGrid - instability in MDI forms is fixed.
  • MaskedTextBox - improved masks handling.
  • Linux Clipboard - support added for custom data formats and IDataObject.
  • Others fixes: DataGrid, TabControl, TextBox, RichTextBox, WebBrowser, TreeView, ListView and more.

C# Language

The csharp command now supports auto-completion using the tab key.

If Mono 2.6.1 is configured with the preview mode, you will also get early access to Mono’s C# 4.0 implementation. This implementation is now available as part of the dmcs command.

C# 4.0 named arguments and optional parameters have been fully implemented.


xbuild, the Mono implementation of the msbuild build tool has advanced significantly. It now has support for ASP.NET projects, both WebApplication and WebSite projects.

It can now resolve references from pkg-config files, (for example gtk-sharp.pc)

To allow extending the build system, Before/After* hooks and *DependsOn properties have been added to various targets like Build/CoreCompile/Clean.

build now executes the Pre/PostBuildEvents in the project files.

Important bug fixes to the core, for property/item/metadata evaluation, which improves support for custom msbuild files.

The project file generated from a solution file (.sln), is written to disk only if the environment variable XBUILD_EMIT_SOLUTION is set.

  • Added Clean target
  • xbuild implicitly picks a .sln or *proj file from current directory, if nothing is specified on the command line

Lots of other bug fixes, besides these from bugzilla:

  • 484771 OutDir property is ignored
  • 530210 xbuild fails if an unmanaged library is located in a project reference path
  • 530368 xbuild enters infinite loop if a build target is named “Build”
  • 531276 Documentation missing
  • 531926 BeforeBuild/AfterBuild Targets missing
  • 532264 xbuild does not support .sln files as MSBuild Project targets
  • 533903 When building a .csproj directly, any ProjectReferences are not found
  • 534965 xbuild seems to execute tasks repeatedly when the tasks are dependencies of other tasks
  • 534992 xbuild is missing _CopyAppConfigFile targets
  • 542459 Rebuild target is not implemented

Runtime details


As part of our work on Moonlight, Mono now includes a sandbox and its verifier. There are various pieces to the puzzle:

  • IL verifier: to ensure that code fed to the JIT engine is valid.
  • Metadata verifier: to ensure that the assemblies processed are valid files and that the JIT will not crash when accessing it, or that the data is invalid.
  • Verifier integration with the [[Moonlight2CoreCLR|CoreCLR Security Sandbox]: the IL verifier can be integrated by those embedding Mono with the CoreCLR security system to prevent untrusted code from using dangerous operations (like pointer access) or access to restricted APIs (for example, file access).

Embedding users can control whether to turn the above on or off.


As part of the gsoc 2009, Jerry Maine ported Mono.Simd to AMD64. It supports mixing code with floating-point and use all available SSE registers.

Minor enhancements to the API were made, some missing operations were added and the documentation fixed to reflect the new extension-method style.

Embedding API

mono_metadata_interfaces_from_typedef now returns the interface array in g_malloc’d memory. It previously allocated it with mempool memory which could only be freed when the image was unloaded.

LLVM backend

This is a new and experimental feature in Mono. It is now possible to compile Mono to use the LLVM code generation engine as an optimizing compiler for Mono.

When enabled, LLVM will be used for most code instead of Mono’s Just in Time compiler (there are a few pieces that are not yet supported by LLVM and in those cases Mono will fallback to its internal engine).

Keep in mind that using LLVM has an impact on JIT performance, so this is not recommended for desktop scenarios where startup speed is important. LLVM should be used only for long-running applications or applications where long-term computational speed is more important than startup speed.

The SciMark score on Mono goes from 482 to 610.

The llvm backend requires llvm 2.6.1 or later and can be enabled by passing –enable-llvm=yes to configure.


Support for generics is greatly improved compared to 2.4.

Signal Chaining

When embedding the Mono runtime, Mono will now allow signal handlers that were set before the Mono runtime was initialized to be invoked when the signal is triggered from non-managed code:

The following signals are chained:

  • a SIGSEGV/SIGABRT signal received while executing native (i.e. not JITted) code.

To enable this functionality, embedders must call the mono_set_signal_chaining(gboolean chain_signals) method.

This closes the #318894 feature request. The patch was contributed by Simon Rowland at Linden Labs.

Bundled Executables

Users of mkbundle can now pass runtime options to the generated executable by setting the MONO_BUNDLED_OPTIONS environment variable.

Debugging support for GDB

The runtime can now generate debugging information for managed code and register it with gdb when using the –debug=gdb command line option. This only works on some platforms, currently amd64/x86/arm linux, and requires gdb 7.0, which has a JIT interface.

There is a mono support mode implemented in python which offers additional features, like pretty-printing C# objects. It is in the file which is installed alongside the mono executable, so gdb will load it automatically.


The Mono.Tasklets library (described in the blog entry Continuations in Mono: Embracing and Extending .NET) is a continuation library that can be used to construct various forms of continuation systems and light weight threads.

A simple way of picturing this is the Mono-version of C’s longjmp/setjmp.

Documentation Tools

The monodoc GUI has had several crash fixes #443699, #443508.

The mdoc(5) format has been extended to support embedding arbitrary XML nodes via a format element. This can be used to embed e.g. HTML that isn’t otherwise supported by the mdoc(5). It’s based loosely in concept on Perl’s =begin blocks. For example:

<format type="text/html">
  <a href="">Arbitrary URL</a>.

mdoc has had several bugfixes (#475814, #515030, #475746).

The mdoc update and mdoc export-html commands have been updated to honor file timestamps; specifically, if the contents of a file hasn’t changed then mdoc update won’t change the timestamp, and mdoc export-html won’t regenerate an HTML file if the output file is newer than the source file.

mdoc updates –exceptions option now has a added value so that <exception/> elements will only be generated for newly added members. This makes updating documentation easier (as mdoc update won’t re-insert <exception/> elements that you deliberately removed).

mdoc export-html now supports a –with-version parameter so that only types & members within a given version will be documented. This makes it possible to get documentation for a subset of types, instead of needing to manually read each type/member to see if it’s in the version you care about.

mdoc –version now uses Mono’s version.

mdoc export-html now behaves properly when multiple directories are provided as source parameters (e.g. mdoc export-html -o html source1 source2 source3), properly showing the union of all types within html/index.html.

A new mdoc export-html-webdoc tool has been added which “pre-renders” XML documentation into partial HTML content for subsequent use by the webdoc ASP.NET front-end. This can greatly reduce CPU load when displaying documentation.

Installing Mono 2.6.7

Binary Packages and Source Code Downloads:

Source code and pre-compiled packages for Linux, Solaris,
MacOS X and Windows is available from our web site from
the Downloads section.

Quick source code installation:

If we have no packages for your platform, installing from
source code is very simple.

Compile libgdiplus to support System.Drawing:

    $ tar xzf libgdiplus-2.6.7.tar.gz
    $ cd libgdiplus-2.6.7
    $ ./configure
    $ make
    $ make install

Then compile Mono itself:

    $ tar xzf mono-2.6.7.tar.gz
    $ cd mono-2.6.7
    $ ./configure
    $ make
    $ make install