Automating the code writing process using macros

• Download macro and documentation (v2.5.1.0 for VS 2005) - 199 Kb
• Download macro and documentation (v2.0.0.0 for VS 2005) - 166 Kb
• Download macro and documentation (v1.4.0.0 for VS 2003) - 154 Kb

• Resharper v2.0.3
• Resharper 3.0 and some minor changes
• Resharper 2.5 (optional)
• Resharper 2 beta.
• http://www.jetbrains.com/resharper

Changes

See history for a full changelog. The documentation found in the zip contains an updated documentation in addition to the changelog of the macros.

Introduction

When writing code and documentation for source files, there is much manual work to complete the task. Often you follow a specific code standard and some code you write quite often with small changes. I have developed a set of macros for easing my daily work and thus making me more efficient as a developer. These macros employ our company's code standard, that hopefully are not so far from yours, and they can be fine-tuned to match your standards.

The macros focus on inline XML documentation, region blocks, automation and refactoring. They work with Visual Studio 2003 and primarily with C#, but some macros also support VB.NET.

Installation

Download the supplied files and follow the instructions given below:

For VS 2005

1. Open the Macro explorer (Alt+F8 or View -> Other windows -> Macro Explorer)
2. Rightclick "Macros" in the macro explorer and select "Load Macro Project"
3. Select the "Meridium.vsmacros" and click "Add"
4. Run the Macro Meridium.Documentator.FixKeyMapping to install the shortcuts
5. [Optional] If you have installed the Resharper add-in, run the Meridium.Documentator.FixKeyMappingsAfterResharperInstallation macro
6. Ready to go

For VS 2003

1. Create a new keyboard mapping scheme if you are using the Default settings (Tools -> Options -> Environment-> Keyboard-> Save as)
2. Load the macro project "Meridium.vsmacros" in Visual Studio (Tools -> Macros -> Load Macro project...)
3. Open the Macro explorer (Alt+F8 or Tools -> Macros -> Macro Explorer)
4. Run the Macro Meridium.Documentator.FixKeyMapping to install the shortcuts
5. Ready to go

Using the macros

The full explanation of the macros exists in the manual, but I will give some descriptions for the main features.

For instance, if you have written a method that looks like this:

public int MyMethod(string name, int maxNo, Font font) 
{
    //my code

}

and then invoke the Document and regionize macro (Ctrl+d), you'll end up as follows:

#region public int MyMethod(string name, int maxNo, Font font)
/// <summary>

///

/// </summary>

/// <param name="name"></param>

/// <param name="maxNo"></param>

/// <param name="font"></param>

/// <returns></returns>

public int MyMethod(string name, int maxNo, Font font) 
{
    //my code

}
#endregion

The cursor is then placed at the first XML doc tag (<summary>) and you are ready to start documenting. If you have also activated the EnableTabMapping, you can use Tab and Shift+Tab to move between the different tags in the XML doc section.

It also supports updates, so if you add a parameter or change the order of the parameters and then activate the macro again, the documentation and region will be updated.

Another major macro is the PasteTemplate macro that supports automation and refactoring by templates. For now, the templates are hard coded into the macros, but you can easily modify them to suit your own needs.

For example, if you want to create a try catch clause, enter the following text:

tryc

and activate the PasteTemplate macro (Ctrl+J), you'll end up as follows:

try 
{
} 
catch(Exception ex) 
{
}

More automation functions exists. Try fori, trycm, trycf, tryf, gp, sp and gsp.

A more complex automation is supported when creating events. If you define the following event:

public event EventHandler MyEvent;

and activate the PasteTemplate macro, you'll end up with the following code:

#region public event EventHandler MyEvent
/// <summary>

/// This event is fired when

/// </summary>

public event EventHandler MyEvent;
#endregion
#region protected virtual void OnMyEvent(EventArgs e)
/// <summary>

/// Notifies the listeners of the MyEvent event

/// </summary>

/// <param name="e">The argument to send to the

    listeners</param>
protected virtual void OnMyEvent(EventArgs e) 
{
    if(MyEvent != null) 
    {
        MyEvent(this,e);
    }
}
#endregion

This saves a lot of time.

The same macro also adds refactoring capabilities. For instance, if you want to convert a field to a property,

public string Name;

place the cursor at the end of the line and activate the PasteTemplate macro, you'll end up as follows:

public string Name;
    get { return _name; }
    set { _name = value; }
}
private string _name;

Then add the Document and regionize macro to that, and in a few seconds, you have refactored and documented your field.

The field refactoring method contains a few variants depending on the field initialization; look in the manual for a full description. I have added some more refactoring types, but you'll have to look in the manual for the complete specification.

Given below are some macros described in short, a full description exists in (yes, you are right) the manual.

Auto documentation

For properties, indexers and some methods, a default documentation is provided when the Document(AndRegionize) macro is invoked.

The following elements are auto documentated:

Points of Interest

I have to thank Roland Weigelt for his inspiring GhostDoc and some other macros (region expand). The Key mapping binder is also found on the net, I can't remember where though.

The upcoming Visual Studio 2005 will be a good update for the automation and refactoring with the introduction of code snippets.