C# Compiler-as-a-Service: Mono.CSharp vs Microsoft.CSharp

Question

I am looking to replace certain reflection-based parts of our code with ones that perform better using dynamic runtime compilation. Looking around I saw that both Mono and Microsoft have separate Compiler-as-a-Service solutions: Mono.CSharp and Microsoft.CSharp.

With the risk of asking an opinion-based question, I'm wondering how these two compare?

As far as I can tell from a very superficial initial investigation, they both generally provide CAAS capabilities. I was able to compile a "Hello World" class using Microsoft.CSharp and execute it. And although I didn't do the same thing with the Mono one yet, I'm assuming it could do the same.

Does anyone have any experience with either or both and can comment on the issue?

Edit: I am not asking about a comparison of Mono's C# and Microsoft's C# - we are already familiar with and using both. The question is specifically about the two CAAS (Compiler-as-a-Service) solutions.

CAAS isn't (yet anyway) a standard part of the .NET runtime, i.e there is no System.Compile namespace yet. The two solutions Mono.CSharp and Microsoft.CSharp are separate non-standard CAAS solutions for C#. Their interfaces are very different and hence the question.

Mono's compiler service

Microsoft's compiler service

Edit #2: Completely forgot about Roslyn (thanks to @Lex Li)

@nvoigt, I don't think it is a duplicate as the title of the link you provide is misleading and isn't really what the question is about. — David Arno, Oct 09 '13 at 12:40
It's not a duplicate, my bad about the title. See my update. — Amir Abiri, Oct 09 '13 at 12:48
`Microsoft.CSharp` is still CodeDom driven IMHO. `Mono.CSharp` is different. You might compare `Mono.CSharp` to Roslyn, but never to `Microsoft.CSharp`. The namespace similarity is by accident, and there is no close relationship. — Lex Li, Oct 10 '13 at 02:51
I completely forgot about Roslyn - I read about it briefly some time ago. I'll add it to my list of candidates. — Amir Abiri, Oct 11 '13 at 09:20

Marek Safar · Accepted Answer · 2013-10-10T12:04:07.310

4

Microsoft.CSharp as it's now (.net 4.5) is API used by C# compiler to emit bindings for C# dynamic expressions. Therefore it's C# compiler but very limited. The same API (dll) is implemented by both .NET and Mono so you can compile on .NET and run on Mono and vice-versa.

Mono.CSharp is evaluator style API to Mono C# compiler. It allows you to compile any C# text-like code (expressions, statement, type declarations, etc) and execute it. It relies on System.Reflection and System.Reflection.Emit heavily.

Neither of these have any relation to CodeDom.

edited Oct 10 '13 at 12:04

answered Oct 10 '13 at 11:50

Marek Safar

600
3
8

What about performance? My initial test shows that code compiled with `Microsoft.CSharp` performs identically to statically compiled code (which is to be expected now when I understand what's behind it). I am about to run the same tests on `Mono.CSharp` next. What is your experience in this regard? – Amir Abiri Oct 11 '13 at 09:18
Code produced by Microsoft.CSharp can be considered identical to output of batch compiler. It generates behind the scene IL which is JIT-ed as any other IL code – Marek Safar Oct 11 '13 at 11:05

Amir Abiri · Answer 2 · 2013-10-11T11:18:13.317

Well I have now compared Mono.CSharp with Microsoft.CSharp and the result is that Mono's version performs badly in comparison.

I compiled the following code with both dynamic compilers:

using System;
using CompilerServiceTest;

public class LalaDynamicImpl : ILala
{
    private static int _counter;

    public void DoLala()
    {
        _counter++;
    }
}

The main program looks something along the lines of:

public interface ILala
{
    void DoLala();
}

public class LalaStaticImpl : ILala
{
    private static int _counter;

    public void DoLala()
    {
        _counter++;
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        Message("Compiling dynamic lala...");
        var lala = BuildDynamicLala();

        Message("Testing dynamic lala...");
        Test(lala);

        Message("Sleeping for 1s...");
        GC.Collect();
        Thread.Sleep(1000);

        Message("Testing static lala...");
        Test(new LalaStaticImpl());
    }

    private static void Test(ILala lala)
    {
        var watch = Stopwatch.StartNew();
        for (var i = 0; i < 1000000000; i++)
            lala.DoLala();
        Console.WriteLine(watch.Elapsed);
    }
}

On my machine the results are:

Statically compiled class: 1.9s
Dynamically compiled class compiled with Microsoft.CSharp: 1.9s
Dynamically compiled class compiled with Mono.CSharp: 10s

The results correspond with what the Mono team mentions here and what Marek Safar mentions in his answser - the Microsoft.CSharp compiler service is a wrapper for the actual compiler and the code is compiled and optimized in the same way as normal code. The Mono.Csharp compiler service is separate from the Mono compiler and is more of an "eval" machine. It does not optimize the code in the same way as the standard compiler.

Basically it appears that the Mono compiler service isn't really intended for performance-critical scenarios, but for rich features, learning, testing, etc.

Tested on a Windows 7 64bit machine with .NET 4.0 (VS 2010) and Mono 3.2.3.

C# Compiler-as-a-Service: Mono.CSharp vs Microsoft.CSharp

2 Answers2