Release Notes Mono 2.10

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

Mono 2.10 is an update to Mono 2.8 based on the master branch of github, it is not a minor upgrade to 2.8. Mono 2.10 was released on February 15th.

For more information on changes since Mono 2.10, you can also read the release notes for Mono 2.10.1, Mono 2.10.2 and Mono 2.10.3, Mono 2.10.4 and Mono 2.10.5.

Table of contents

Important Information About Mono 2.10

As of September of 2011, Mono 2.10 became the new stable release of Mono. Please make sure that you use the latest version of the Mono 2.10.xx series.

Major Highlights

Changes Since Mono 2.8

Mono.Options

The Mono.Options library now

    • Low-level argument pre-processing now available via Mono.Options.ArgumentSource.
    • CSC-style @response-file handling now available (opt-in) by adding a Mono.Options.ResponseFileSource to the Mono.Options.OptionSet initializer block.

New C# Compiler Backend

We are now test-driving a new code generation back-end for the C# compiler. We continue to support the System.Reflection.Emit backend that we have used since the start of the project in 2001, but now also provide a new backend based on Jeroen Frijters' IKVM.Reflection API.

This new backend allows developers to reference a third-party mscorlib.dll library, either based on Mono's mscorlib.dll, or a custom mscorlib.dll that you built for a special purpose, or obtained from another project (like Microsoft's MicroFramework).

To use the new compiler, use the mcs command. The following table shows the current compiler setup in Mono:

Tool/Library Purpose Profile Backend
gmcs C# Compiler 2.0 System.Reflection 2.0
dmcs C# compiler 4.0 System.Reflection 4.0
smcs C# Compiler 2.1 (Silverlight, MonoTouch, MonoDroid) System.Reflection 2.0
mcs C# Compiler Any profile, any mscorlib IKVM.Reflection
csharp Interactive C# Shell/REPL 4.0 System.Reflection 4.0
Mono.CSharp C# Compiler as a Service 2.0, 2.1 and 4.0. System.Reflection

In the next Mono release (after 2.10) the batch compilers (gmcs, smcs and dmcs) will be switched over entirely to IKVM.Reflection. The commands will continue to exist as a shortcut to quickly select an API profile, but they will be merely front-ends to the mcs command with the proper mscorlib profile. The compiler as a service, and the interactive shell will continue to be powered by the System.Reflection backend, as this is the only way of supporting dynamic code generation.

To test drive the new compiler back-end, just use the mcs command. If you want to specify a specific SDK use the -sdk:PROFILE option. Where profile is one of the profile directories (2.0, 2.1, 4.0 or any other that lives under $prefix/lib/mono). Alternatively, pass the -libdir option to the compiler to specify a full path to your base assemblies.

Mono's C# compiler has historically used System.Reflection.Emit as its API to generate executables. This has worked great in Mono for years, but poses one difficult challenge: it is not easy to make the compiler use an arbitrary mscorlib.dll and build against it. Historically the "mcs" command created executables that referenced the 1.0 profile, the "gmcs" command created executables that references the 2.0 profile and "dmcs" command created executables that references the 4.0 profile as each compiler was built against those profiles. Additionally, we had to extend System.Reflection to support creating mscorlib libraries, as Microsoft's implementation is not complete enough. So the Reflection.Emit API turned out to be useful for many situations but had various problems that we could not work around easily.

Jeroen's IKVM.Reflection allowed us to keep most of the C# compiler codebase intact, while being able to use a new code generation library, one that we could easily fix, and would work the same in Mono and Microsoft's .NET.

C# Interactive Shell

The C# REPL now can be used as a program to run C# scripts in Unix. Your Unix scripts can now contain as their first line the #!/usr/bin/csharp line which allows you to create C# scripts that can be treated like programs:

$ echo '#!/usr/bin/csharp' > demo
$ echo 'System.Console.WriteLine (10+2);' >> demo
$ chmod +x demo
$ ./demo
12
$ 

The C# REPL now also supports evaluating a single expression from the command line:

$ csharp -e 'Math.Sin(0.1);'
0.0998334166468282
$ csharp -e 'from l in System.IO.Directory.GetFiles ("/bin") where l.Length > 18 select l;'
{ "/bin/dbus-cleanup-sockets", "/bin/showconsolefont" }
$

Google Native Client Support

This release adds support for Google's Native Client, a technology that allows native code to be executed as a web application in a secure fashion. Google's Native Client contains a native code verifier that enforces a set of programming patterns in the native code and enforces what the code can and can not do. This allows developers to use native code while giving users of those technologies a peace of mind, knowing that the code will be executed in a security sandbox that wont let malicious code get access to confidential data, or compromise your system.

The support for Native Client allows Mono's virtual machine, garbage collector and Just-in-Time compiler to be used inside a Native Client sandbox.

Google added JIT support to their Native Client engine to give users greater flexibility while using Native Client. In the past, Native Client was limited to running statically compiled code (Mono on AOT mode), but this would prevent interesting scenarios, prevent System.Reflection.Emit, scripting languages and other dynamic cases from working. We are incredibly excited about Google's work and Elijah's contributions on this area.

For the full details, see the announcement.

SGen Garbage Collector

New technical information on how SGen works has been posted by Mark Probst in a series of blog posts:

Some new features:

  • SGen now supports the card-table optimization on x86-64, in addition to the x86 platform supported in Mono 2.8. Card scanning has also been fine tuned in this release and should reduce garbage collection times on both x86 and x86-64.
  • SGen now supports concurrent mark and sweeping.
  • SGen now supports scanning thread stacks in a mostly precise fashion. This can be enabled using the MONO_GC_PARAMS=stack-mark=precise env variable. The default is still conservative scanning.

Precise stack scanning will improve how roots are determined in the managed stack, but still scans the unmanaged stack (for example, when you P/Invoke into a C library) conservatively.

New Mono Profiler

Mono has a new Profiler that obsoletes the old heap-shot, heap-buddy and logging profilers that were available in previous versions of Mono and provides a reliable, new alternative.

This new profiler fixes many of the problems that older profilers had with multi-threaded applications, multi-appdomain applications and large volumes of data.

In addition, new GC events are now raised, allowing developers to write more advance profiling tools and GC tracking tools for their own applications. For an example, see Alan McGovern's Moonlight object profiler.

VB Compiler

The VB Compiler (vbnc) has been upgraded to use cecil/light instead of Reflection, which makes it possible to create assemblies with different runtime versions using only 1 compiler. That is very similar to the changes that we did to the Mono C# Compiler detailed above.

By default vbnc will now compile to the 4.0 profile, and a new script (vbnc2) has been added to compile to the 2.0 profile.

GetFolderPath Changes

Calling GetFolderPath on OSX now returns now OSX-specific directories when previously it returned XDG-values, or the empty string.

The following variables have changed their meaning:

GetFolderPath changes on OSX
Variable Old Value New Value
MyMusic $XDG_MUSIC_DIR, fallback to ~/Music ~/Music
MyPictures $XDG_PICTURES_DIR, fallback to ~/Pictures ~/Pictures
Fonts ~/.fonts ~/Library/Fonts
Favorites "" ~/Library/Favorites
ProgramFiles "" /Applications
InternetCache "" ~/Library/Caches

In addition the SpecialFolderOptions mode is now used on Unix. The DoNotVerify option is a no-op as historically Mono has not thrown exception on directories that did not exist.


Mono.Simd Changes

We have added a few extra methods to Mono.Simd, new Shuffle methods on all vector classes allowing you to use SIMD to swap elements in your vectors:

public static Vector4f Shuffle (this Vector4f v1, Vector4f v2, ShuffleSel sel)
public static Vector4i Shuffle (this Vector4i v1, Vector4i v2, ShuffleSel sel)
public static Vector4ui Shuffle (this Vector4ui v1, Vector4ui v2, ShuffleSel sel)
public static Vector2d Shuffle (this Vector2d v1, Vector2d v2, int sel)
public static Vector2l Shuffle (this Vector2l v1, Vector2l v2, int sel)
public static Vector2ul Shuffle (this Vector2ul v1, Vector2ul v2, int sel)

There are new SIMD-powered methods for doing Vector data type conversions:

public static Vector4f ConvertToFloat (this Vector4i v0);
public static Vector2d ConvertToDouble (this Vector4i v0);
public static Vector4i ConvertToInt (this Vector2d v0);
public static Vector4i ConvertToIntTruncated (this Vector2d v0);
public static Vector4f ConvertToFloat (this Vector2d v0);
public static Vector4i ConvertToInt (this Vector4f v0);
public static Vector4i ConvertToIntTruncated (this Vector4f v0);
public static Vector2d ConvertToDouble (this Vector4f v0);

Some of these operators were created in response the efforts to create a cross-platform vector math library that is accelerated on Mono, safe in Silverlight and unsafe/pointer-based on .NET or systems without SIMD support. You can check Mono.GameMath from GitHub.


Runtime

  • Added support for Assembly Remapping.
  • Added a public API for accessing the GC.
  • Added RuntimeWrappedException support.
  • Fast stelemref, 2-3% perf boost on pystones (this is the operation used for array access).
  • Runtime will no longer load assemblies from the current directory
  • Add support for --debug=casts to ArrayTypeMismatchException.
  • Improved tail-call support for the F# compiler.
  • We now support direct thread local storage with LLVM's code generator on ARM platforms that support it.
  • Added support for the short-hand "supportedRuntime" feature of .NET 4.0 to our runtime. In addition to the old X.Y.Z format, we also support the short forms ("v4.0") in our config files.
  • Removed the arbitrary limit of 1024 processes in GetProcesses.
  • Full ahead of time compilation now knows about EqualityComparer<T> enabling many more LINQ scenarios to work on devices that do not have JIT support.
  • Added the new Monitor.TryEnter overloads from the 4.0 profile.
  • Improved the Mono runtime's sandbox: better verifier checks, more fixes from fuzzing.
  • Many class library and runtime fixes to improve our compatibility with Microsoft's CLR derives from the Silverlight test suite that we received from Microsoft to improve Moonlight.
  • Mono has better support for out-of-memory conditions.
  • ARM backends supports frame pointer elimination.

New GC heap walk API

The new GC heap walk API can be used by users embedding Mono or writing custom Mono profilers:

/**
 * mono_gc_walk_heap:
 * @flags: flags for future use
 * @callback: a function pointer called for each object in the heap
 * @data: a user data pointer that is passed to callback
 *
 * This function can be used to iterate over all the live objects in the heap:
 * for each object, @callback is invoked, providing info about the object's
 * location in memory, its class, its size and the objects it references.
 * The object references may be buffered, so the callback may be invoked
 * multiple times for the same object: in all but the first call, the size
 * argument will be zero.
 * Note that this function can be only called in the #MONO_GC_EVENT_PRE_START_WORLD
 * profiler event handler.
 *
 * Returns: a non-zero value if the GC doesn't support heap walking
 */
typedef int (*MonoGCReferences) (MonoObject *obj, MonoClass *klass, 
                                 uintptr_t size, uintptr_t num, 
                                 MonoObject **refs, void *data);
 
int mono_gc_walk_heap        (int flags, MonoGCReferences callback, void *data);

New Hooks for Assembly Resolution

New API to hook into the DllImport library and function resolution that can be used by users embedding Mono on their application, or using it on embedded system or platforms that do not support dynamic libraries:

/* mono-dl-fallback.h */
enum {
	MONO_DL_LAZY  = 1,
	MONO_DL_LOCAL = 2,
	MONO_DL_MASK  = 3
};
 
/*
 * This is the dynamic loader fallback API
 */
typedef struct MonoDlFallbackHandler MonoDlFallbackHandler;
 
/*
 * The "err" variable contents must be allocated using g_malloc or g_strdup
 */
typedef void* (*MonoDlFallbackLoad) (const char *name, int flags, char **err, void *user_data);
typedef void* (*MonoDlFallbackSymbol) (void *handle, const char *name, char **err, void *user_data);
typedef void* (*MonoDlFallbackClose) (void *handle, void *user_data);
 
MonoDlFallbackHandler *
mono_dl_fallback_register (MonoDlFallbackLoad load_func, 
                           MonoDlFallbackSymbol symbol_func,
                           MonoDlFallbackClose close_func, 
                           void *user_data);
 
void    
mono_dl_fallback_unregister (MonoDlFallbackHandler *handler);

Android Specific Updates

Several updates to Mono's runtime to support Android:

  • Add TLS and HTTPS support for Android by calling back into Java to fetch the system certificates.
  • Add support for bundling symbol files on embedded images.
  • Add support for Android's TimeZone "ye" file format.

OSX Updates

There were various updates specifically for MacOS X in this release of Mono, bringing Mono on OSX closer to the Linux port:

  • The Mono_LLVM backend for the JIT is now enabled in our OSX builds
  • Added support for 32 bit PIDs in OSX.
  • Process lookup by ID now works on OSX.
  • Added support for --debug=casts to OSX.
  • Added AOT support to OSX.
  • Fixes guard interrupt protection on OSX (test finally_guard.exe now works)
  • DriveInfo.GetDrives returns correct values now on OSX.
  • Add support for symlinked frameworks (to support embedding Mono)

Improved Socket and Async Stack

Socket asynchronous operations were ultimately a Delegate.BeginInvoke call which ran a lot of remoting-related code. Now those asynchronous operations are sent directly to the IO pool, saving memory and CPU time.

Until this version of Mono, SocketAsyncEventArgs support was using one thread per operation. The code has been rewritten to take full advantage of this model for doing asynchronous IO on sockets.

Cecil/Light

The Cecil API has been made lighter and faster, at the expense of breaking source code compatibility. This is not a problem for users as Cecil was never a stable API, and as such, users were encouraged to use their own copies of the Cecil library, instead of depending on the GAC, following our own Guidelines:Application_Deployment.

All of the tools in Mono that used Cecil have been updated to Cecil/light, and can be used as a reference to understand what changes are necessary to your own source code.

Gendarme 2.10

  • Faster than ever thanks to Cecil/light update;
  • 33 new rules (total 253), 30 from students participating in Google Code In 2010;
  • New rule categories:
    • Interoperability.Com (10 rules)
    • NUnit : rules for unit tests (4 rules)
    • Gendarme : rules on rules (4 rules); and
    • Globalization (2 rules)
  • available in mono-tools package;
  • more details in NEWS file.


ASP.NET MVC3 Support

See below for notes on Razor and WebPages.

Although ASP.NET MVC3 is open source and licensed under the terms of the MS-PL license, it takes a few dependencies on new libraries that are not open source nor are they part of the Microsoft.NET Framework.

At this point we do not have open source implementations of those libraries, so we can not ship the full ASP.NET MVC3 stack with Mono (We still ship ASP.NET MVC 1 and MVC 2 with Mono for your deployment enjoyment).

This Mono release however has enough bug fixes and patches that you will be able to run ASP.NET MVC3 sites with it.

Since these new dependencies were not part of Microsoft.NET, they typically are referenced in your project and deployed in the bin/ directory of your ASP.NET site. Make sure that you remove the Microsoft.Web.Infrastructure.dll library from your site when deploying to Mono, to allow Mono to use its own implementation that integrates ASP.NET MVC3 with Mono.

To run your web sites, use our 4.0 profile programs:

  • xsp4 for quick testing
  • mod-mono-server4.exe for Apache hosting
  • fastcgi-mono-server4.exe for FastCGI servers

Razor and WebPages

If you downloaded the Microsoft binaries for ASP.NET MVC3, you will have a few new libraries, the WebPages framework that allows simple web sites to be built and the Razor template engine.

You can use both of those binaries with Mono 2.10.

It is possible to get up and running with Razor and cshtml just by installing this release and running xsp4 on any directory that contains the bin/ assemblies and creating a .cshtml file.

Running Razor, MVC3 and WebPages

To get this stack running, you will need to copy Microsoft's MVC3 libraries into your bin directory:

  • System.Web.Mvc.dll
  • System.Web.Razor.dll
  • System.Web.WebPages.Deployment.dll
  • System.Web.WebPages.dll

It is very important that you remove the Microsoft.Web.Infrastructure.dll from the bin directory for the above to work. System.Web.WebPages.Razor.dll

WebMatrix.Data

An implementation of WebMatrix.Data is now available in Mono. This is a crazy delicious API for accessing databases from your managed code that takes advantage of C# 4.0's dynamic features.

For a sample, see Jeremie's blog on WebMatrix.Data on Mono, but this allows code to access databases to be written like this:

using System;
using WebMatrix.Data;
 
class WebMatrixSample
{
    public static void Main ()
    {
        var db = Database.OpenConnectionString ("Data Source=sqlite.db;Version=3;", "Mono.Data.Sqlite");
 
        var result = db.Query ("select * from Phonebook where Number glob '0*'");
        foreach (dynamic row in result)
            Console.WriteLine ("({0:D2}) {1}: [{2}]", row.Id, row.Name, row.Number);
 
        var entry = db.QuerySingle ("select * from Phonebook where Name = @0", "Rupert");
        Console.WriteLine ("Rupert number is {0} with id {1}", entry.Number, entry.Id);
 
        Console.WriteLine ("but really his number is just {0}",
                           db.QueryValue ("select Number from Phonebook where Name = @0", "Rupert"));
 
        // And let's add my bank number
        db.Execute ("insert into Phonebook(Name, Number) values (@0, @1)", "Bank", "01xxxxxxx");
    }
}

This is a different style of programming than the ones provided by LINQ to SQL or Sqlite-net (with deep C# integration) or object relationship mappers like NHibernate and Entity Frameworks. This a more bare-bones approach to database access, but also with some convenience methods like the use of C# dynamic to access column results ("row.Name" for example) and params values (the safe call to db.Execute escaping the values inserted).

For a terse introduction see David Fowler's re-introducing WebMatrix.Data.

Languages

Starting with Mono 2.10, we are bundling the open source F# compilers and tools, and the IronRuby and IronPython systems in our Linux packages as well as in our Mac installer.

For F# we ship the fsc command line compiler and the fsi interactive shell.

For IronPython and IronRuby look for the ipy and irb commands in your installation.

note: as of RC2 we have not published IronPython, it will be on the final release.

Other Changes

  • Winforms bug fixes
  • Updates to msbuild
  • Improved Moonlight support, and faster build times for Moonlight
  • Unified MonoTouch/Monodroid runtime support
  • WCF:
    • System.ServiceModel.Discovery
    • WCF 4.0-style configuration
  • ASP.NET 4.0:
    • BaseMenuRenderer
  • Sytem.Xaml: significant improvements on serialization of complex types and properties in .NET compatible format. Now it can be built on mobile profiles.
  • More 4.0 APIs implemented
  • Version tolerant serialization
  • C# 4.0 significantly improved based on the Microsoft test suites for Silverlight

Installing Mono 2.10

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.10.tar.gz
    $ cd libgdiplus-2.10
    $ ./configure
    $ make
    $ make install

Then compile Mono itself:

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

Bug Fixes

  • 317488 problem passing abstract methods to delegates
  • 318677 remove_block_if_useless trips on valid IL
  • 318750 Setting thread's current culture to non-serializable CultureInfo causes SerializationException
  • 324144 [2.0] deserialization interop issue with missing members
  • 384127 MethodBuilder.GetGenericArguments must return null if method is not generic
  • 456234 ODBC utf8: incorrect OdbcDataReader.GetValue() result for VARCHAR if byte size >=255
  • 467221 [PATCH] asp.net security trimming / authorization not working
  • 479061 DateTime.TryParse fails for ISO8601 format with IFormatProvider and flags specified
  • 504085 MCS produces invalid images for modules
  • 515938 [SRE] Mono crashes instead of NRE when emitting wrong attribute arguments
  • 516960 [PATCH] DataGridView MoveCurrentCell can attempt to access Column index -1
  • 541815 Unmanaged exception when compiling and not finding a reference
  • 549807 WaitHandle.WaitAny returns WAIT_IO_COMPLETION (an impossible return value for .NET)
  • 557277 [PATCH] WM_SETFOCUS is sent before Keyboard Focus is changed.
  • 560200 [verifier] abort in type_to_eval_stack_type while JITting a verified method
  • 560327 [verifier] abort in mono_class_inflate_generic_class on bad assembly
  • 560334 [verifier] abort in mono_method_get_signature_full on bad assembly
  • 560346 [verifier] SIGSEGV in mono_class_inflate_generic_method_full on a bad assembly
  • 560359 [verifier] abort in mono_metadata_decode_row on bad assembly
  • 560834 [verifier] SIGSEGV in method_from_methodspec on a bad assembly
  • 561667 Disposing a SqlCommand should dispose associated SqlDataReaders
  • 561728 [verifier] SIGSEGV in find_method_in_metadata on a bad assembly
  • 562009 [verifier] SIGSEGV in mono_method_signature on a bad assembly
  • 562150 abort in compute_class_bitmap while JITting a verified method
  • 562156 abort in mono_method_get_vtable_slot while JITting a verified method
  • 562771 abort in mono_method_to_ir (mono_method_check_context_used) while JITting a verified method
  • 563956 abort in mono_metadata_decode_row_col while JITting a verified method
  • 568004 [verifier] abort in mono_marshal_get_remoting_invoke_with_check while JITting a verified method
  • 568025 [verifier] sigsegv/infinite recursion in mono_class_implement_interface_slow
  • 569542 [verifier] SIGSEGV in find_method_in_class on a bad assembly
  • 569543 SqlClient using Guid in parameter
  • 572223 sigsegv in mono_class_get_virtual_methods while JITting a verified method
  • 579837 System.Configuration.Save() method throws an exception when trying to add an authorization section to an existing Web.config
  • 582732 DataSet method WriteXml fails when DataColumn has extended properties and MaxLength property is set. ReadXml does not read extended properties also.
  • 584833 SqlCommandBuilder.DeriveParameters() does not find the correct stored procedure
  • 592981 UnixSignal.WaitAny not interrupted when exiting
  • 595044 ERROR:method-to-ir.c:8063:mono_method_to_ir: assertion failed: (!(field->type->attrs & FIELD_ATTRIBUTE_LITERAL))
  • 597072 abort in create_jit_info while JITting a verified method
  • 598228 [verifier] SIGSEGV in mono_stringify_assembly_name
  • 604218 SIGABRT in ERROR:class.c:6134:mono_class_get_field_default_value
  • 604486 JIT shows no respect for DebuggableAttribute
  • 605033 program crashes if the App.conf contains the <sharedListeners> section.
  • 605092 System.Timers.Timer.TimerComparer fails to compare arguments
  • 605340 Unexpected exception on calling String.LastIndexOf on empty strings with startIndex=-1
  • 605936 System.InvalidProgramException: Invalid IL code in (wrapper delegate-invoke)
  • 606809 Soft debugger immediately disconnects
  • 613087 Unable to convert SqlInt64 to SqlDecimal
  • 620099 insert_breakpoint error on unreachable code
  • 621475 [PATCH] TextBox and RichTextBox crash on click when text value will be set to null
  • 624849 BlockingCollection<T> takes 100% cpu when blocking for an element
  • 624915 [PATCH] calling ExpandAll() on a TreeView contain in a small panel can throw ArgumentOutOfRangeException.
  • 627889 IOMAP profiler: undefined symbol: monoeg_g_hash_table_new
  • 631315 NTLM authentication problem with multiple simultaneous requests
  • 631810 [PATCH] Modal Form closing event raised by button cannot be canceled
  • 632224 MD deadlocks when debugging
  • 633248 [verifier] SIGABRT in mono_local_regalloc
  • 635335 Missing method System.Data.Common.DbConnection::EnlistTransaction(Transaction) when using a .NET 2.0 library and compiling with dmcs
  • 636219 WebRequest fails because it sends a Content-Length header for a GET after a redirect
  • 636475 webcontrols/web_adrotator.aspx test fails
  • 636500 [Moonlight] Web Service Reference doesn't work
  • 636517 System.Net.Dns doesn't resolve any IPv6 addresses
  • 636709 [Regression] xsp2 IDs are not created correctly. Not unique in webcontrols/web_checkboxlist.aspx
  • 636794 Crash in mono runtime
  • 636841 [Regression] System.InvalidOperationException when accessing webservice/TestService.asmx
  • 636966 cannot P/Invoke with ordinal EntryPoint on Windows
  • 637078 DriveInfo.GetDrives() returns paths with escaped octal characters in them
  • 637680 Running console or GTK apps remotely results in stack trace
  • 639098 Application project that references library projects does not build
  • 639656 [Regression] Blogengine hangs when accessing certain pages
  • 639939 [PATCH] X11 keyboarding - XLookupString can sometimes return corrupt buffer.
  • 640288 Missing ReflectionTypeLoadException
  • 640377 Cannot do coverage analysis using monocov
  • 640687 Runtime should wrap non System.Exception derived exceptions in RuntimeWrappedException
  • 640688 Serialization shouldn't call Equals/GetHashCode on objects
  • 640702 MethodBase.GetCurrentMethod doesn't work inside a DynamicMethod
  • 640749 Socket.LocalEndPoint returns null after non-blocking connect
  • 640780 TypeLoadException when implementing interface with static method in dynamic assembly
  • 641449 Admin links missing in BlogEngine (both xsp and mod_mono)
  • 641535 Wrong Marshal.SizeOf() for structs with explicity layout
  • 641590 Calling FieldInfo.GetValue of a void* field aborts mono
  • 642130 Activator.CreateInstance Method (Type, Object[]) does not work with compiler service (Mono.CSharp)
  • 642193 WebResponse::get_Headers not implemented
  • 642625 SIGSEGV when running gdb in a directory on which we have no write permission
  • 642780 Mono debugger thread crashes when app exits quickly
  • 642985 Deadlock in io-layer when accessing files from multiple threads
  • 643298 [Regression] AspNetForums crashes when adding a thread
  • 643475 Socket.ExclusiveAddressUse not working with UDP
  • 643763 [PATCH] BuildProvider.SetVirtualPath is not called when BuildProvider has no BuildProviderAppliesToAttribute
  • 643847 RequiredFieldValidator validator incorrectly prevents postback from RadToolBar
  • 643890 DeclaringType returns incorrect value for inflated types
  • 643910 DriveInfo.GetDrives returns incorrect values
  • 644648 CryptoStream does not call FlushFinalBlock when in CryptoStreamMode.Read
  • 644654 CryptoStream violates IDispose pattern
  • 644660 Stream.Dispose() does not call GC.SuppressFinalize
  • 644740 CryptoStream fails with CryptoTransform where the OutputBlockSize < InputBlockSize
  • 644816 enableSsl is not supported in system.net/mailSettings/smtp/network section of configuration
  • 644915 Mono ignores constraint load failures
  • 644933 Mono 2.6.4 fails to compile parallel
  • 644935 Missing constraints check
  • 645189 Assembly.LoadWithPartialName completely non-functional
  • 645193 BinaryWriter on Console standard output no longer works correctly
  • 645217 ObjectMirror vs ThreadStaticAttribute
  • 645675 Socket.Complete throws InvalidOperationException on Queue.Dequeue
  • 645765 Missing support for hoisted parameters in the Expression Tree interpreter
  • 645770 Expression Tree interpreter fails for custom delegate types
  • 646314 Unable to compile assembly with AOT
  • 646479 Dynamic control lifecycle inconsistency between Mono and MS.NET
  • 646505 BoundField databinding inconsistency between Mono and MS.NET
  • 646556 Binary serialization/deserialization do not work correctly if object contains nullable DateTime type.
  • 646744 [Flow-analysis] internal error when doing flow analysis for large structs
  • 646810 Method not found: 'System.Web.Security.FormsAuthentication.EnableFormsAuthentication'.
  • 646941 xbuild does not build dmcs.csproj
  • 646984 Stylesheet inclusion inconsistency between Mono and MS.NET
  • 647204 IPC implementation doesn't delete socket file
  • 647248 SIGSEGV when calling a managed handler
  • 647267 Wrong Size of a Struct with Marshal Sizeof
  • 647464 Debugger segfaults when hitting a breakpoint on sse4.2 enabled systems
  • 647918 Mono 2.8 on openSUSE 11.3 crashes (all applications)
  • 647948 null stream.BaseStream Close/Dispose not throwing exception (unlike MS .Net)
  • 648130 Calling Timer.Change(Infinite, Infinite) leaks timer objects on the scheduler
  • 648252 BinarySerialization: DateTime is off by the timezone offset between .NET and mono
  • 648391 TypeBuilder.GetConstructor does not check ctor argument
  • 648407 System.Web.HttpCachePolicy doesn't use contents of AppendCacheExtension(...)
  • 648432 HttpResponse.WriteFile should MapPath filename unless is absolute
  • 648439 HttpRequest.ServerVariables["QUERY_STRING"] should not be prefixed by ?
  • 648616 Nested generic type field type is emitted incorrectly
  • 648725 GetGenericArguments is loading to aggressively
  • 648828 Sorting arrays of unequal lengths causes unexpected exception
  • 648831 Thread.MemoryBarrier() needs to be implemented on x86 and x86-64
  • 648832 System.ArgumentException when inspecting exception strack trace text
  • 648833 GetArrayRank is loading to aggressively
  • 648838 [Regression?] error: 'SIGTRAP' undeclared when cross-compiling with mingw
  • 648901 Routing in MVC slightly broken.
  • 649014 Missing castclass type check
  • 649017 castclass emit does not work with nested types
  • 649034 UpdateProgress doesn't find UpdatePanel inside a userercontrol
  • 649159 System.Threading.Monitor does not contain TryEnter(*, ref bool) methods
  • 649198 [PATCH] Initial implementation of System.Web.UI.MasterPage.InstantiateInContentPlaceHolder
  • 649233 stfld does not work with TypeBuilderOn* instances
  • 649237 Missing The specified field must be declared on the generic type definition
  • 649464 System.IO.File.ReadLines disposes the StreamReader in the middle of reading
  • 649522 GetField is loading to aggressively
  • 649527 MethodBase::Attributes is loading to aggressively
  • 649546 RadAjaxManagerProxy in WebUserControl problem
  • 649551 RadAsyncUpload does not work under mono; Possibly a Base64 serialization problem
  • 649889 System.ArithmeticException instead of OverflowException
  • 649994 PrinterSettings.InstalledPrinters throws an exception
  • 650050 ListItem does not render non-standard Attributes
  • 650407 AOT compile asserts when dependent assemblies are not available
  • 650439 poor performance (and wrong arithmetic result) of multi-thread code
  • 650779 File.Move with a symlink with wrong or non existing target fails
  • 650806 ./configure in ./mcs/ selects default profile
  • 650916 Incorrect Error: Could not decode method header
  • 650936 [verifier] SIGABRT in compute_class_bitmap
  • 650979 Wrong exit code returned from parent process
  • 651251 Assertion: should not be reached at debugger-agent.c:4328
  • 651287 [verifier] SIGSEGV in mono_class_is_assignable_from
  • 651546 Monitor.Enter leaves orphaned locks when threads are aborted
  • 651593 Mono differs significantly from .NET FX when processing URL routes in System.Web.Routing
  • 651647 XmlSerializer is too picky
  • 651682 [verifier] SIGABRT in mono_metadata_decode_row
  • 652188 init_type_builder_generics is inside of DISABLE_REFLECTION_EMIT, but is needed even when emit is disabled.
  • 652590 * Assertion at debugger-agent.c:4087, condition `sp' not met
  • 652807 [Regression] Asp.Net app run locally throws Type does not match the valueKind error
  • 652952 MakeGenericMethod does not work on generic type definitions
  • 653013 Ajax request problem from controls within RadGrid
  • 653192 Using a relative path for the MasterPageFile throws an exception
  • 653211 * Assertion at class.c:5583, condition `!klass->parent->exception_type' not met
  • 653564 Erroneous value returned by Environment.UserName when running as root with su
  • 653842 A case that runtime crashed if startup --llvm --gc=sgen, using generic and struct.
  • 653928 From thread-pool thread, QueueUserWorkItem schedules onto the same thread
  • 654058 FixedBufferAttribute.Length has wrong value in fixed fields.
  • 654136 Insufficient validation of generic type arguments during reflection allows violation of the type system
  • 654322 Crash when throwing too many exception
  • 654433 XPathSelectElements not running correct results for simple XPath.
  • 654460 Overflowing prolog buffer causing crash
  • 654476 HttpRuntime::Validate incorrectly thinks ',' is an invalid char
  • 654694 [SDB] Assertion at debugger-agent.c:4087, condition `sp' not met
  • 654850 AOT code loader fails to load AOT code for a .exe file which references other assemblies in the same directory
  • 655089 XmlConvert.ToDateTime with simple date and XmlDateTimeSerializationMode.Local throws FormatException
  • 655096 processorArchitecture is not parsed for AssemblyName
  • 655159 Verifier blocks getting custom attributes with types
  • 655439 Delegate.CreateDelegate is less strict than MS, but invocation is incorrect
  • 655497 Reflection.Emit usage causes SIGBUS from ves_icall_System_Delegate_CreateDelegate_internal
  • 655637 UnixEndPoint not deserializing correctly
  • 655669 Weak GCHandle does not work and crashes in multi-AppDomain scenario
  • 655741 'System.InvalidProgramException: Missing or incorrect header for method Call'
  • 655896 System.Diagnostics.Process discards escaped spaces in arguments
  • 656021 Cannot pass null to named GET parameter in code
  • 656058 * Assertion at debugger-agent.c:3553, condition `ji' not met on invalid custom attributes
  • 656262 System.Reflection.Emit.TypeBuilder.create_runtime_class crash as of git rev c66e414be18a5da230a1988ba572d2889f3d5548
  • 656353 ReaderWriterLockSlim don't lock if EnterWriteLock was called
  • 656787 type 0x20 not handled in do_mono_metadata_parse_type
  • 656850 [Regression] Deadlock on WebServiceHost.Open
  • 656913 [verifier] SIGABRT -> condition `!mono_method_check_context_used (cmethod)' not met
  • 656914 [verifier] g_assert_not_reached hit in mono_metadata_token_from_dor
  • 657516 Verifier rejects AssemblyFlagsAttribute
  • 657593 Socket.AcceptAsync causes ObjectDisposedException at the time the socket closes.
  • 657609 System.TimeZoneNotFoundException when accessing TimeZoneInfo.Local in Emulator and on Device
  • 657694 Verifier rejects valid constructor access
  • 657745 [verifier] SIGSEGV in mono_is_regsize_var
  • 657746 [verifier] SIGSEGV in mono_delegate_type_equal
  • 658244 CountdownEvent.Reset Method (Int32) behaviour incorrect.
  • 658278 Ajaxified control nested in another ajaxified control does not update
  • 658645 * Assertion: should not be reached at debugger-agent.c:4475
  • 658945 [PATCH] ContextMenuStrip vertical position can be wrong.
  • 659056 Socket.EndSend and EndReceive methods with out SocketError parameter should not throw SocketException
  • 659061 NumberFormatter should adjust the leftmost group size width to the number of remaining characters
  • 659064 RadAjaxManager ajaxified buttons trigger postback instead of AJAX request
  • 659123 Parameter names in CodeDomProvider.CompileAssemblyFromSource Method
  • 659791 Client Access Policy fails when multiple domains are in the allow from (e.g. http + https)
  • 660117 Replacing g_free with mono_free in samples
  • 660508 xbuild 2.6.7 fails to create a correct project file from a solution if project names contain dots
  • 660570 AssemblyName cannot be constructed (blocks mcs)
  • 660907 System.IO.DriveInfo.GetDrives is unimplemented on Windows
  • 660911 System.IO.DriveInfo(string) should not require an exact match
  • 660928 Creating a GZipStream causes a crash
  • 661356 DllImport errors preceding DllNotFoundException printing "(null)" instead of actual loader error
  • 661462 Queryable.AsQueryable(IEnumerable) breaks on Dictionary<T,V>.ValueCollection if T!=V
  • 661787 Inconsitency of XmlConvert.ToDateTime() between Mono/MS.Net when parsing UTC dates
  • 661917 UnmanagedType.VBByRefStr marshalling is unimplemented
  • 662238 [verifier] SIGABRT condition `!sig->has_type_parameters' not met in mono_method_to_ir
  • 662355 xbuild doesn't understand Reference Aliases
  • 662741 Random SIGSEGV in signal handlers (mono_install_handler_block_guard)
  • 662918 Setting Page.Title on an ASPX page does nothing.
  • 663159 No location information for condition parsing errors
  • 663180 MSBuildExtensionsPath should include Mac external directory
  • 663182 MonoDoc should include Mac external directory