From now on, all announcements will be posted in the devblog, so you won’t have to keep your eye for updates from two different feeds.

The new website is a lot more concise and clear, in my opinion. Do you like it?

It took me about 4 months to commit the patch, sorry guys

You can now choose between tabs or spaces as your indentation character. This should be available in the next release (v0.7.3.0), but is already available in the trunk and nightly build.

Did I mention I really love the fact that now, whenever code is committed, it can be immediately downloaded and installed?

Now you can use multiple tags in the OrderBy statements, for example:

   1:  <PutMethods>

   2:      <OrderBy>

   3:          <Name />

   4:          <ParametersCount />

   5:      </OrderBy>

   6:  </PutMethods>

will place all methods, will order them by name and then will sub-order them by the number of parameters in the method.

Meaning that this piece of code:

   1:      interface IGateway

   2:      {

   3:          void Initialize(Configuration configuration);

   4:          void Finalize(string connectionString, string username, string password);

   5:          void Initialize(string connectionString, string username, string password);

   6:          void Finalize();

   7:          void Initialize();

   8:      }

will turn into:

   1:      interface IGateway

   2:      {

   3:   

   4:          #region Operations (5) 

   5:   

   6:          void Finalize();

   7:   

   8:          void Finalize(string connectionString, string username, string password);

   9:   

  10:          void Initialize();

  11:   

  12:          void Initialize(Configuration configuration);

  13:   

  14:          void Initialize(string connectionString, string username, string password);

  15:   

  16:          #endregion Operations 

  17:   

  18:      }

The good ol’ ForEachClass statement had to be modified a bit (yes, that means you must change your Code Layouts) to allow this.

From now on, use the new ForEach statement and specify the type you want to apply layout to.

For example:

   1:  <ForEach Type="Class">

   2:  ...

   3:  </ForEach>

   4:  <ForEach Type="Struct">

   5:  ...

   6:  </ForEach>

   7:  <ForEach Type="Interface">

   8:  ...

   9:  </ForEach>

This will be available on v0.7, but you can grab the code, compile and use it right now.

When you hit Ctrl+R (or whatever you had your shortcut set to), the active document is Regionerated. But if you hit Ctrl+R and keep the Ctrl button down, you will be presented with the Code Layout Browser.

The Code Layout Browser is similar to the Alt+Tab window browser in Microsoft Windows. It allows you to choose which Code Layout to apply on your code.

You can browse through the different Code Layouts using the shortcut key (typically “R”) while holding down the modifier key (typically Ctrl), similar to Alt-Tab.

The first item is always the Primary Code Layout (the one you chose in the settings form, be it the standard Code Layout or your own custom Code Layout). The first item is the most accessible item and is the one selected when hitting Ctrl+R without browsing.

The rest of the items are gathered from the “My Code Layouts” directory under your installation folder.

I’m pretty sure no-one really liked having “[rgn]” in front of Regionerated region declarations. Most users hated it but kept it, some users hated it and changed it to something minimal such as “*” while other users hated it and changed it to an empty string. (which caused trouble with comments and existing regions)

So I’ve decided to put a stop to it and kill the region symbol and allow Regionerate to operate without it. I wouldn’t have been able to do so if I wouldn’t have found this cheap trick: I just use ASCII character #255 instead of spaces.

ASCII character #255 (a.k.a. “The Hidden Dragon”) looks exactly like space and allows Regionerate to differentiate Regionerated regions from existing regions.
You can think of this as a hard-coded invisible symbol.

Take a look at this example:

   1:          #region Fields

   2:   

   3:          ... 

   4:   

   5:          #endregion

   6:   

   7:          #region My Stuff

   8:   

   9:          ... 

  10:   

  11:          #endregion

Even though these regions look the same, the first region is a Regionerated region and the latter is an existing region. How can I tell? The first one has the hidden dragon right after “#region” and “#endregion” (” “) and the second one has space (” “).

Crazy workaround, but it works. Anyway, this should be available on v0.6.6.5.

Regarding migration: New users will enjoy this the first time they Regionerate their code. However, users of versions prior to v0.6.6.5 might find this a bit annoying as Regionerate will treat symbolized regions as existing regions, causing code not to be Regionerated.

I can add some functionality to allow easier migration in v0.6.6.5 (something like a definition for “dead symbols” in the Code Layout document which will allow users to enter their old symbols, so Regionerate will automatically kill those), However this might take me some time and will delay this version.

The faster option will be to get rid of symbolized regions by a simple regular expression search & replace throughout the code. This will be a one-time task and should complete in a minute or two.

What do you think? Should I postpone this version for this one-time migration function or will you guys survive the regular expression search & replace? (I’ll post a short guide for you folks who aren’t familiar with regular expressions)

Please gimme your opinions on this before I continue. Thanks!

To do so, just specify “true” in the new IsOperator element under PutMethods. Exactly like filtering constructors.

   1:      <CreateRegion Title="Operators">

   2:        <PutMethods>

   3:          <Where>

   4:            <IsOperator Equals="true"/>

   5:          </Where>

   6:        </PutMethods>

   7:      </CreateRegion>

Not much to elaborate on, choose any combination of Ctrl/Alt/Shift with a single character and go wild.

At the moment, this is only available to Visual Studio users, #develop users, hang on, its coming.

Up until now, running Regionerate on entire projects & solutions was only available via the command line utility or NAnt task, but now it is available through your IDE as well.

Right-clicking a solution and clicking “Regionerate This” will parse the .sln file and process every C# project inside. In the same way, right-clicking a project and clicking “Regionerate This” will parse the .csproj file and process every .cs file inside.

At the moment, there is no way to set ignored projects & files (as in the console application & NAnt task) and all C# projects & C# code files within the selection will be Regionerated.

#develop users – stay tuned, hopefully this feature will be shortly available to you as well.

By the way, you can read more about this extensibility experience in my personal blog: Tapping Into The Solution Explorer & Tapping Into The “Projects” Pad.

I was thinking of creating an “IsOperator” filter (similar to the “IsConstructor“) in the PutMethods statement. This will allow you to create regions for your operators.

However, since most people do not overload operators, I decided to hold on this, until I see that it is actually needed.

So if you want to be able to create regions for your overloaded operators, let me know by commenting this post.