Jon Galloway : Mono

Getting Mono compiler output in a web application using StreamReportPrinter

Jon Galloway — Thu, 02 Jun 2011 23:06:47 GMT

I've been continuing my experiment with Mono's compiler as a service in an ASP.NET MVC application and making pretty good progress. One of the difficulties I ran into along the way was in troubleshooting compiler errors when I'd deployed the application. Almost all of the content and documentation on Mono.CSharp is in a console application / REPL scenario, which doesn't help in tracking down errors in a web application.

To recap from before, most of the samples you'll see for using Mono.CSharp look like this (undoubtedly copied from Miguel's blog):

var report = new Report(new ConsoleReportPrinter());
var evaluator = new Evaluator(new CompilerSettings(), report);
evaluator.Run("DateTime.Now");

The problem is that the ConsoleReportPrinter writes to Console output, which isn't doing me any good.

// Mono.CSharp.ConsoleReportPrinter
public override void Print(AbstractMessage msg)
{
    base.Print(msg);
    if (base.Stacktrace)
    {
        Console.WriteLine(ConsoleReportPrinter.FriendlyStackTrace(new StackTrace(true)));
    }
}

ConsoleReportPrinter's base is StreamReportPrinter, though, and that works just fine with a StringWriter, like this:

var reportWriter = new StringWriter();
try
{
    var report = new Report(new StreamReportPrinter(reportWriter));
    var evaluator = new Evaluator(new CompilerSettings(), report);

    evaluator.Run("using System.ComponentModel.DataAnnotations;");
    evaluator.Run(modelDefinition);

    object model = evaluator.Evaluate("new Monkey();");
    return View(model);
}
catch
{
    string result = reportWriter.ToString();
    return Content(result);
}

Running this gives some useful output, indicating the compilation results:

{interactive}(1,30): error CS0234: The type or namespace name `DataAnnotations' does not exist in the namespace `System.ComponentModel'. Are you missing an assembly reference? {interactive}(1,30): error CS0234: The type or namespace name `DataAnnotations' does not exist in the namespace `System.ComponentModel'. Are you missing an assembly reference? {interactive}(1,6): error CS0246: The type or namespace name `Monkey' could not be found. Are you missing a using directive or an assembly reference?

Now that we've got the results as a string, they can be logged or handled appropriately.

Dynamic ASP.NET MVC 3 models using Mono’s Compiler as a Service

Jon Galloway — Fri, 27 May 2011 00:50:52 GMT

I had an idea for an interactive MVC sample which will let you see the scaffolded editor and display for a model. I thought about a few ways to do this, the first being Mono’s compiler as a service. So far it’s a partial success – the model scaffolding works, but the attributes don’t (very possibly my mistake).

Getting the latest Mono Compiler

Miguel recommended that I grab the latest Mono build off Github, since there have been some improvements and bug fixes in the compiler. He wasn’t kidding, there’s a lot of active work going on in the compiler, and the Evaluator class (the main compiler service class) is no exception. Here’s the commit history just for the Evaluator (eval.cs):

https://github.com/mono/mono/commits/871ad48b98346cffc194b6ebe458a93d88dba009/mcs/mcs/eval.cs

A quick skim of the mcs (mono csharp compiler) commit messages in general shows a lot of work going on, including work on async: https://github.com/mono/mono/tree/master/mcs/mcs

The biggest change since the last Mono release, as Miguel blogged about in February, is the change from static API to an instance API:

…we turned the static API Evalutor.Eval (string expression), into an instance API. The instance API allows developers that are embedding the C# compiler-as-a-service in their application to have different contexts.

This required the entire compiler to be updated from being a giant set of static classes that could safely use global variables and state into a state that was properly encapsulated.

The API is now richer, we provide a way to configure the compiler settings using a settings class. This can be populated either manually, or by using the build-in command-line parser for compiler options.

This is good news – I find the new API easier to work with. The magical static stateful service API pattern works great for the REPL sample but causes problems if you’re doing anything much more complex. The downside, though, is that just about all the code samples and blog posts on the the Mono compiler service stuff don’t work as-is against the new compiler.

I didn’t want to set up a build environment for Mono. Fortunately, most established open source projects offer regular builds if you look around a bit. I grabbed the most recent MonoCharge package from http://mono.ximian.com/daily/, which includes all the precompiled binaries. They’re packaged as a .tar.gz, which opens up just fine in 7-zip. I just grabbed the Mono.CSharp.dll assembly.

Using the Mono Compiler Service in an application

It’s pretty easy to put use the compiler in an app:

Reference Mono.CSharp.dll
Add a using statement for Mono.CSharp
New up an Evaluator and get to work:

var report = new Report(new ConsoleReportPrinter());
var evaluator = new Evaluator(new CompilerSettings(), report);
evaluator.Run("DateTime.Now");

The evaluator constructor requires a ConsoleReportPrinter and CompilerSettings, neither of which we care about, so we’re just passing them in to make everyone happy. Are you happy? Me, too. Onward!

Using Mono Compiler in an ASP.NET MVC Application

ASP.NET MVC 3 views are typed as ViewPage<dynamic> and the Html.EditorForModel scaffolding stuff works via reflection, so theoretically we could create a new model on the fly and lob it over to the view and things should just work, right? Let’s see.

First, we’ll create the controller that builds a dynamic class. I’m throwing in a property with a dynamic name just to make it clear that this entire model is coming from a string.

using System.IO;
using System.Reflection;
using System.Web.Mvc;
using Mono.CSharp;
using System;

namespace DynamicModelCompilation.Controllers
{
    public class HomeController : Controller
    {
        public ActionResult Index()
        {
            string modelDefinition =
            @"
              public class Monkey
              {
                    public string Name { get; set; }
                    public string Password { get; set; }
                    public bool IsHappy { get; set; }
                    public bool GetsDownOn" 
                        + DateTime.Now.DayOfWeek + 
                    @" { get; set; }
                }
            ";

            var report = new Report(new ConsoleReportPrinter());
            var evaluator = new Evaluator(new CompilerSettings(), report);
            evaluator.Run(modelDefinition);
            dynamic model = evaluator.Evaluate("new Monkey();");

            return View(model);
        }
    }
}

The above code:

Builds a string which we’ll be passing to the compiler
Creates a compiler (as we saw earlier)
Calls Evaluator.Run, which executes the code string passed to it
Calls Evaluator.Evaluate on “new Monkey()” which news up an instance of our model and returns it

Next, we’ll set up a simple Index view that displays an editor template for based on whatever model object is passed to it:

@{
    ViewBag.Title = "Home Page";
}
<script src="@Url.Content("~/Scripts/jquery.validate.min.js")" type="text/javascript"></script>
<script src="@Url.Content("~/Scripts/jquery.validate.unobtrusive.min.js")" type="text/javascript"></script>
@using (Html.BeginForm())
{
    @Html.ValidationSummary(true, "Account creation was unsuccessful. Please correct the errors and try again.")

    <fieldset>
        @Html.EditorForModel()
    </fieldset>
    <input type="submit" value="Processinate Form" />
}

Running the application show that our nefarious plan has succeeded:

Pushing Our Luck – Trying Out Some Attributes

A lot of the goodness in the MVC templates comes from the way the helpers work with data annotations. You can set display names for properties (e.g. changing the display label for IsHappy to "Is this monkey happy?"), setting validation requirements for edit forms, etc. I took a shot at adding those in to the model class.

First off, I needed to include a reference to the System.ComponentModel.DataAnnotations assembly in my Mono Evaluator session. That's easy enough to do with a call to LoadAssembly, presuming you have the full path to the assembly. I copied System.ComponentModel.DataAnnotations to my /lib file and referenced it like this:

System.Uri uri = new System.Uri(Assembly.GetExecutingAssembly().CodeBase);
string path = Path.GetDirectoryName(uri.LocalPath).Replace("\\DynamicModelCompilation\\bin", "\\lib");
evaluator.LoadAssembly(Path.Combine(path, "System.ComponentModel.DataAnnotations.dll"));

That adds the reference to the compiler session, but you still need to run a using statement, like this:

evaluator.Run("using System.ComponentModel.DataAnnotations;");

Finally, I added some annotations to my model:

public class Monkey
{
	[Required]
	[StringLength(3, ErrorMessage = ""The {0} must be at least {2} characters long."", MinimumLength = 1)]
	public string Name { get; set; }

	[Required]
	[DataType(DataType.Password)]
	public string Password { get; set; }
	
	[Display(Name = ""Is this monkey happy?"")]
	public bool IsHappy { get; set; }
}

Note: if you get any of those things wrong, you get a slightly cryptic exception on your call to evaluator.Evaluate() - Argument Exception: The expression did not set a result.

Here's how the entire controller looks:

Unfortunately, the attributes didn't have any effect. It's not like anything broke, but the form looked the exact same:

I dug into the model properties using model.GetType().GetProperties() - it looks like they're present, but maybe there's something about them that ASP.NET MVC finds repugnant? Spelunking through the model properties' custom attributes shows that they are indeed present.

The end? We'll see - I'll ask / poke around and see why the attributes aren't being picked up.

References / more info on using the Mono compiler as a service:

http://docs.go-mono.com/Mono.CSharp.Evaluator.Compile%20(string)

http://docs.go-mono.com/Mono.CSharp.Evaluator.Evaluate%20(string)

http://docs.go-mono.com/Mono.CSharp.Evaluator.Run%20(string)

http://www.amazedsaint.com/2010/09/how-to-host-monos-csharp-compiler-in.html

http://tirania.org/blog/archive/2011/Feb-24.html

Running the Mono VMWare image in VirtualPC

Jon Galloway — Sun, 30 Mar 2008 09:22:42 GMT

A lot of people love VMWare, but it bugs me. I think the main reason is that it installs with a bunch of Windows services that run automatically, every second my computer is running, whether or not I use VMWare. Since I don't use virtual machines every day, that's annoying. So, after running the free VMWare Player for a few times times, I banished it from my computer.

The Mono team publishes a VMWare image which makes it really easy to check out Mono on Linux without installing or building anything. If you're happy with VMWare, you can grab their free player and run the image. If, like me, you'd rather run this on Virtual PC, follow along and I'll show you how.

If you don't use VirtualPC, or if you don't mind having several virtual machine hosts on your computer, this post obviously isn't for you. Thanks for stopping by, though!

Grabbing the VMWare Image

You can download the Mono VMWare image from the Mono Downloads page. They offer both are http and torrent download options.

Converting the Virtual Hard Disk image

I use Vmdk2Vhd from vmToolkit to convert the hard disk images. It's free, although there's an annoying registration step (which you can probably bypass with BugMeNot). The interface is really simple - browse for the vmdk file, enter the destination filename, and click the "convert" button.

Creating the new VirtualPC Machine

Start up the VirtualPC console and go through the following steps:

Select "Create A Virtual Machine"
Set the Operating System to "Other"
You'll have to decide how much memory you can allocate to the virtual machine; on my workstation with 2GB RAM, I allocated 768MB RAM.
Select "Use an Existing Virtual Hard Disk" and browse to the location of the VHD file you created earlier using Vmdk2Vhd. I left "Use undo disks" unchecked.
Hit "Finish" and you should have a new virtual machine shown in your VirtualPC console.

Setting up the Video Driver

VirtualPC and Linux have a long standing feud over video drivers. VirtualPC emulates an S3 Trio video card with 16 bit color depth, while the Linux X Server defaults to 24 bit color depth since that's what a real S3 Trio supports. The result is that Linux video under VirtualPC is always a pain in the neck. So keep with me as we jump through a few hoops to get Linux to recognize VirtualPC's video card.

When you start the virtual machine we created earlier, hit the down arrow to select failsafe defaults and hit enter.

Note: Previous openSUSE images required me to also fix the mouse by adding "i8042.noloop" to the failsafe boot parameters, but this appears to have been fixed for the 1.9 image.

After the boot process completes, you should be looking at a console window. You'll need to log in (root / mono) and enter "sax2 -m 0=fbdev" like so:

SaX2 churns for a bit, then comes up in graphics mode. You can change the configuration, but I just clicked on OK.

At this point, you'll need to reboot. You can do that in the VirtualPC menu (Action / Reset), or you can just type "shutdown -r 0" at the command prompt. When it comes back up, you can boot to Mono 1.9 / openSUSE 1.3 without using the Failsafe options.

We've got one more thing to set up - the network connection is disabled by default. You can connect by clicking on the network icon in the lower right-hand corner, then on "Wired".

Stay tuned - in the next post, we'll make use of this image to take a look at Moonlight, the open source implementation of Silverlight on Linux.