This is a preview of a new language for Reflector that outputs to Refly (Refly is wraps up and simplifies the use of CodeDom).

What does the language do ?

The language creates Refly code. If the Refly code is executed it will generate the original code. This is particularly usefull to rapidely design CodeDom template: write the expected output, Reflectorize-it and get the Refly code. In the figure below, we see the code "cycle of life" with a decompiler and how it is modified if we add the "Refly" language.

A preview example

There is still a lot of work to do on the language but it can already generate the outline of classes. Let's see that on a simple class:

public class Original
{
    private string name;
    public Original()
    {}
    public string Name
    {
        get { return this.name;}
        set { this.name = value;}
    }
    public void Run(string someParamter)
    {
        Console.WriteLine("{0}: someParameter");
    }
    public event EventHandler Click;
    protected virtual void OnClick(EventArgs e)
    {
        if (this.Click != null)
            this.Click(this, e);
    }
}

After compiling and  loading in Reflector, the Refly language is outputting:

NamespaceDeclaration _dragAndDropUnitTesting = new NamespaceDeclaration("Original");
 
ClassDeclaration _original = _dragAndDropUnitTesting.AddClass("Original");
 
// Fields
FieldDeclaration name = _original.AddField(typeof(System.String), "name");
FieldDeclaration Click = _original.AddField(typeof(System.EventHandler), "Click");
 
// Events
EventDeclaration _click = _original.AddEvent(typeof(System.EventHandler), "Click");
 
// Constructor and Methods
ConstructorDeclaration ctor0 = _original.AddConstructor();
ctor0.Attributes |= System.CodeDom.MemberAttributes.Assembly;
ctor0.Attributes |= System.CodeDom.MemberAttributes.Family;
MethodDeclaration _run = _original.AddMethod("Run");
_run.Attributes |= System.CodeDom.MemberAttributes.Assembly;
_run.Attributes |= System.CodeDom.MemberAttributes.Family;
ParameterDeclaration _runsomeParamter = _run.Signature.Parameters.Add(typeof(System.String), "someParamter");
MethodDeclaration _onClick = _original.AddMethod("OnClick");
_onClick.Attributes |= System.CodeDom.MemberAttributes.Family;
ParameterDeclaration _onClicke = _onClick.Signature.Parameters.Add(typeof(System.EventArgs), "e");
 
// Properties
PropertyDeclaration _name = _original.AddProperty(typeof(System.String), "Name");
 

That's pretty ugly but not as much if you had to write CodeDom for that. We can compile and generate the code using the following instruction:

CodeGenerator gen = new CodeGenerator();
gen.GenerateCode(".", _dragAndDropUnitTesting);

Finally, the output of the execution is as follows:

using System;
/// <summary />
/// <remarks />
public class Original
{
    /// <summary />
    /// <remarks />
    private string _name;
    /// <summary />
    /// <remarks />
    private System.EventHandler _click;
    /// <summary />
    /// <remarks />
    Original()
    {
    }
    /// <summary />
    /// <remarks />
    public virtual string Name
    {
    }
    /// <summary />
    /// <remarks />
    public event System.EventHandler Click;
    /// <summary />
    /// <remarks />
    void Run(string someParamter)
    {
    }
    /// <summary />
    /// <remarks />
    void OnClick(System.EventArgs e)
    {
    }
}

Of course, the result is far from behing perfect. Visibility handling sucks, statements are not reflected, etc... But sounds very promising to me :)