Working with the View-engine you quickly get the feeling that this could be used for other things, such as generating stuff like SQL, MDX, HTML output for PDF conversion or other report generators.

Enter the CodePlex RazorEngine project, available right inside VS2010 via NuGet, which builds on MVC to deliver the same features for other .Net environments. Other people, like Rick Strahl, have made similar efforts to harness the power of Razor. This guy on CodeProject uses RazorEngine for CSS generation.

Having played with it for a couple of hours I discovered that the documentation and samples aren’t completely up to date, so here is my very simple code sample. I’m sure there’s a lot more to it, but this at least got me started:

using System;
using RazorEngine;
using System.Dynamic;

namespace BatchRazor
{
    public class Test
    {
        public string Name { get; set; }
    }

    class Program
    {
        public static void Main(string[] args)
        {
            string template =
                "@{var _v = \"Mr \" + Model.Name; }" +
                "Hello @_v, Welcome to Razor at @DateTime.Now.ToString()!";

            // Anonymous

            Console.WriteLine(Razor.Parse(template, new { Name = "World" }));

            // Dynamic

            dynamic d = new ExpandoObject();
            d.Name = "Expando1";

            Console.WriteLine(Razor.Parse(template, d));

            Razor.Compile(template, typeof(ExpandoObject), "complex");
            Console.WriteLine(Razor.Run("complex", d));

            dynamic e = new ExpandoObject();
            e.Name = "Expando2";
            Console.WriteLine(Razor.Run("complex", e));

            // Strongly typed

            var t = new Test() { Name = "Test" };
            Console.WriteLine(Razor.Parse(template, t));

            Razor.Compile(template, typeof(Test), "complex1");
            t.Name = "Test2";
            Console.WriteLine(Razor.Run("complex1", t));

            Console.ReadLine();
        }
    }
}

Without further ado, here is a method that will do exactly that:

public static IEnumerable<dynamic> GetExpandoFromXml(string file, string descendantid)
{
    var expandoFromXml = new List<dynamic>();

    var doc = XDocument.Load(file);
    var nodes = doc.Root.Descendants(descendantid);

    foreach (var element in doc.Root.Descendants(descendantid))
    {
        dynamic expandoObject = new ExpandoObject();
        var dictionary = expandoObject as IDictionary<string, object>;
        foreach (var child in element.Descendants())
        {
            if (child.Name.Namespace == "")
                dictionary[child.Name.ToString()] = child.Value.Trim();
        }
        yield return expandoObject;
    }
}

Note that I use a descendantid parameter to specify what part of my XML I want to fetch as dynamic objects.

In my example I was working with an RSS feed, and this is the reason why I ignore the elements that have an empty namespace, and BTW the file parameter can be an URL as well as you can see in the sample.

As I sample, I can get the “item” elements from the RSS feed of this blog like so:

var expandolist = GetExpandoFromXml("http://phejndorf.wordpress.com/feed/", "item");

expandolist.ToList().ForEach(element => Console.WriteLine(element.title));

Or perhaps, a bit more exotically, to list all the properties of each dynamic element:

expandolist.ToList().ForEach(element =>
{
    var dictionary = element as IDictionary<string, object>;
    dictionary.ToList().ForEach(d => Console.WriteLine("{0}: {1}",d.Key,d.Value));
});

And that’s all there is to it!

To think that for little more than 350 USD you can get a small PC that will run this beauty and more – back in its day the Texas Instruments TI-59 was 300 USD!

The Microsoft Mathematics even features a Word plugin, that will actually let you do part of your Math (and other) homework directly within Word.

On the left hand side of the Mathematics screen is a calculator like device, that is really just a shortcut to the various formulas that are supported.

It is the worksheet window where the real lifting is done. Here you can see how the system explains how a simple equation is solved:

It sounds like a cliché, but there are just too many features to easily explain, so you really have to have a go yourself and download it!

If you happen to run Mac or Linux there is of course the (also free) option of GeoGebra

For instance when accessing data via SqlDataReader in a dynamic fashion. To that end I suggest wrapping the data reader in a construct that will allow you to return a dynamic class where the columns are accessible by name and not a string reference. This can be done via an ExpandoObject that makes it possible to work with the dynamic class as if it was a dictionary:

private dynamic SqlDataReaderToExpando(SqlDataReader reader)
{
    var expandoObject = new ExpandoObject() as IDictionary<string, object>;

    for (var i = 0; i < reader.FieldCount; i++)
        expandoObject.Add(reader.GetName(i), reader[i]);

    return expandoObject;
}

To create a method for returning the elements of a Sql query in a dynamic fashion can then be implemented like so:

private IEnumerable<dynamic> GetDynamicSqlData(string connectionstring, string sql)
{
    using (var conn = new SqlConnection(connectionstring))
    {
        using (var comm = new SqlCommand(sql, conn))
        {
            conn.Open();
            using (var reader = comm.ExecuteReader())
            {
                while (reader.Read())
                {
                    yield return SqlDataReaderToExpando(reader);
                }
            }
            conn.Close();
        }
    }
}

There are of course all the usual problems with late binding that misspelling and erroneous datatypes won’t be caught until you run the code, but still I find it more elegant than accessing the SqlDataReader’s columns with column-name strings as indexers. And in case you later on decide to make the IEnumerable use an actual class, it will not break the code. This can be done as shown here, where you have a class of T that maps to your database-request:

private static IEnumerable<T> GetSqlData<T>(string connectionstring, string sql)
{
    var properties = typeof (T).GetProperties();

    using (var conn = new SqlConnection(connectionstring))
    {
        using (var comm = new SqlCommand(sql, conn))
        {
            conn.Open();
            using (var reader = comm.ExecuteReader())
            {
                while (reader.Read())
                {
                    // http://blog.benhall.me.uk/2006/08/creating-objects-dynamically-with-c-20.html
                    var element = Activator.CreateInstance<T>();

                    foreach (var f in properties)
                    {
                        var o = reader[f.Name];
                        if (o.GetType() != typeof(DBNull)) f.SetValue(element, o, null);
                    }
                    yield return element;
                }
            }
            conn.Close();
        }
    }
}

Actually the little Activator.CreateInstance<T> trick can nowadays also be coded with a new T() if you add a type-constraint on the method (where T : new()), but internally it’s still Activator.CreateInstance<T> so this version is basically just sugar-coating:

private static IEnumerable<T> GetSqlData<T>(string connectionstring, string sql) where T : new()
{
    var properties = typeof (T).GetProperties();

    using (var conn = new SqlConnection(connectionstring))
    {
        using (var comm = new SqlCommand(sql, conn))
        {
            conn.Open();
            using (var reader = comm.ExecuteReader())
            {
                while (reader.Read())
                {
                    var element = new T();

                    foreach (var f in properties)
                    {
                        var o = reader[f.Name];
                        if (o.GetType() != typeof(DBNull)) f.SetValue(element, o, null);
                    }
                    yield return element;
                }
            }
            conn.Close();
        }
    }
}

As the documentation states: “A new database inherits its recovery model from the model database.”

In my case, working mostly with test-servers in VMware, it means that I generally change the installed defaults like this:

USE [master]
GO
ALTER DATABASE [model] SET AUTO_SHRINK ON WITH NO_WAIT
GO
ALTER DATABASE [model] SET RECOVERY SIMPLE WITH NO_WAIT
GO

However, you can’t just install it as Windows 7 as there is no serial available, but the installation is still pretty simple.

I found a good introduction to the steps here: http://www.eightforums.com/tutorials/2899-vmware-player-install-windows-8-developer-preview.html

Note that there is an issue with the VMware tools in 64 bit mode.

Apparently virtualizing the Windows 8 Developer Preview isn’t so easy, however – at least it doesn’t seem work  in Virtual PC 2007 and VMware Player 3.0.1, but quickly stops with this message:

I’m currently trying with VirtualBox, and at least it’s now brought me to the “Installing Windows” screen – I’ll report back if that works any better. Currently it’s been “pining for the fiords” or whatever for a good while:

Update. I think it was disk formatting that took a while, but here is Windows 8 Developer Preview 32bit in all its glory running in VirtualBox :

I only just got it running, so no testing so far. It seems that VirtualBox is the way to go for the time being.

I know there are quite of overviews out there like Scott Guthrie’s and DoFactory’s, but I wanted my own structured data to be able as filter, group and search as I please.

Much googling took me here at MSDN where Kevin Buchs has added a nice VS 2010 macro for extracting the data.

I’ve modified Kevin’s implementation a bit, in order to be able to import it more easily into an Excel sheet (download sample here with the default bindings), so here’s my version of the macro:

Sub GetAllCommands3()
        ' http://msdn.microsoft.com/en-us/library/ms247076.aspx#1

        Dim new_window = DTE.ItemOperations.NewFile("General\Text File")
        Dim doc = new_window.Document
        Dim textDoc = CType(doc.Object("TextDocument"), TextDocument)
        textDoc.StartPoint.CreateEditPoint() ' Creates an "edit point" at the beginning of the document

        ' Tab-separated per command / binding
        For Each cmd In DTE.Commands
            If Not cmd.Name.Trim().Equals("") Then
                Dim line1 = cmd.Name.ToString().Split(".")(0) + vbTab + cmd.Name.ToString()

                For Each binding In cmd.Bindings
                    Dim split = binding.ToString().Split("::")
                    Dim line2 = line1 + vbTab + split(0) + vbTab + split(2) + vbCrLf
                    textDoc.Selection.Insert(line2)
                Next
            End If
        Next
    End Sub

The problem is, that .Net doesn’t have an interface that facilitates this, and that you have to have knowledge about the inner workings of the Linq join/equals.

Here is how it works:

1. Linq will call the two compared classes GetHashCode() method to determine if they have the same hash-code.

2. If they don’t they are assumed to be unequal.

3. If the hashcodes are equal, Linq goes on to the class’s Equals(object o) method to determine equality.

This is implemented by reasons of performance. The hash-metod only confirms – as a truly unique hash-code doesn’t exist in reality – that the two classes might be equal, and not until then is the presumably costlier Equals executed to determine acutal equality.

So because of this you need to implement both a GetHashCode() and an Equals() method. By implementing the IEquatable<T>() interface you get the Equals() method, but then you must implement GetHashCode() by overriding it, otherwise your Equals() method may not ever be called as the base GetHashCode() method will be different for all (most) instances, and to Linq all classes will be different!

You can do several things in your GetHashTable() method – the simplest of which is to return a constant, in which case Linq will always quickly move on to the Equals() method. You can also select one or more fields of the class to hash on, I guess it is a design choice based on your knowledge of the actual data that will get the best performance.

Stackoverflow has a good posting here on how to do the hash generation. I personally think this one looked pretty neat:

return new { A = PropA, B = PropB, C = PropC, D = PropD }.GetHashCode(); 

But, as mentioned, it’s all about speed (and memory), and a question whether most elements are actually unequal or equal, so some testing will be in place in each case.

Recently I’ve been playing a bit with the WCF Web Api, however, and it seems like a really easy way to get some REST-ful data over the wire. When you return a collection of data from Web Api, you can elect to return it  as an IQueryable in which case you will, as it says,  be “Enabling OData query support” .

Mark that phrasing carefully: You are not enabling OData as such – it’s just that you can now use the OData URI syntax when you retrieve data. So don’t fall into the same hole that I did and think that you have full blown OData!

Other than that misconception on my part, it’s all thumbs up for this initiative to focus (and tame) the WCF monster into something more immediately  useful. The WCF Data Services (OData) effort is the same story. Now I just have to convince the rest of my fellow devs and customers that the days of heavyweight WCF/SOAP are coming to a an end in a lot (most) scenarios…

With that said, do go check out Glenn Block’s speech at Mix 11: "There’s a URI for that".

PS. I just discovered that we have one SOAP implementation where all data is exchanged with a mobile client as delimited strings, in order to conserve bandwith by eliminating a lot of XML tags!