In addition, Visual Studio 11 supports continuous testing – automatically running your tests every time you compile your code.  However, as shown in Figure 1, the option to enable continuous testing doesn’t appear from the Run dropdown (and probably shouldn’t because you are not likely to be changing the option back and forth that often).  To enable continuous testing, select the Unit Test->Unit Test Settings->Run Tests After Build menu as shown in Figure 2.

Note the static public void Write(string message, [CallerLineNumber] int lineNumber = 0, [CallerMemberName] string memberName = null, [CallerFilePath] string fileName = null) method signature and how it uses the parameter attributes CallerLineNumber,CallerMemberName, and CallerFilePath from the System.Runtime.CompilerServices namespace.  By [...]]]> There is a new set of .NET attributes in .NET 4.5 to help with gathering trace information.  Before .NET 4.5, tracing the line number, member name, and source file name required using the stack trace in combination with the PDB files.  In .NET 4.5, however, there is a new mechanism for doing this using attributes on optional parameters.  Consider the code below:

using System;
using System.IO;
using System.Runtime.CompilerServices;
using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace IntelliTrace.Runtime.CompilerServices
{
    public class Tracer
    {
        static public void Write(string message, [CallerLineNumber] int lineNumer = 0, 
            [CallerMemberName] string memberName = null, [CallerFilePath] string fileName = null)
        {
            Assert.AreEqual<int>(CallerInfoTests.LineNumber, lineNumer);
            Assert.AreEqual<string>("CallWrite_WithNoParameters_DefaultAreSetToCallerInfo", memberName);
            Assert.AreEqual<string>("CallerInfoTests.cs", Path.GetFileName(fileName));
        }
    }
    
    [TestClass]
    public class CallerInfoTests
    {
        public const int LineNumber = 27;

        [TestMethod]
        public void CallWrite_WithNoParameters_DefaultAreSetToCallerInfo()
        {
            Tracer.Write("Test message");
        }

        [TestMethod]
        public void CallWrite_WithNoParameters_DefaultsAreSetToCallerInfoExceptForSpecifiedLineNuber()
        {
            Tracer.Write("Test message", LineNumber, "CallWrite_WithNoParameters_DefaultAreSetToCallerInfo");
        }
    }
}

Note the static public void Write(string message, [CallerLineNumber] int lineNumber = 0, [CallerMemberName] string memberName = null, [CallerFilePath] string fileName = null) method signature and how it uses the parameter attributes CallerLineNumber,CallerMemberName, and CallerFilePath from the System.Runtime.CompilerServices namespace.  By placing the “CallerInfo” attributes on the parameters – which must also be set as default parameters, the parameters are set with corresponding values automatically (ignoring the default attributes specified in the method signature). As a result, the Tracer.Write() method then has access to “stack” information at compile time, rather than having to iterate over the stack at runtime (possibly a significant performance hit depending on the frequency).

The data associated with the CallerInfo attributes is injected into the IL code at compile time. Decompiling the IL code reveals the caller invocation sets the optional paramters as follows:

Tracer.Write("Test message", 0x1b,
     "CallWrite_WithNoParameters_DefaultAreSetToCallerInfo",
     @"c:\Data\SCC\CallerInfoTracing\CallerInfoTests.cs");

As a result, if no parameter is specified explicitly in the code by the programmer, the compiler injects a default value corresponding to the attribute specified – at the callee (embedding the full file name for the fileName parameter.

#BrilliantlySimple

In Visual Studio 11 Solution Explorer has been revamped significantly.  No longer is it just a location to navigate files, it now supports navigation over the object model of constructs within the solution, full-text identifier search, and more.  For example, you can now expand a CSS [...]]]> In Visual Studio 11, there is a set of IDE productivity improvements that developers across all platforms and languages already be familiar with because earlier versions of them were available in an update for Visual Studio 2010 under the name Productivity Power Tools.  In post we review several of these enhancements.

In Visual Studio 11 Solution Explorer has been revamped significantly.  No longer is it just a location to navigate files, it now supports navigation over the object model of constructs within the solution, full-text identifier search, and more.  For example, you can now expand a CSS file to see nodes corresponding to the classes within the file and then expand the class further to view its members (see Figure 1) – similar to what is available in the Visual Studio 2010 object explorer.

Figure 1: Visual Studio 11 Solution Explorer

Right-clicking on class member displays a context menu for browsing the call hierarchy of the member (see context menu in Figure 1).  Similarly, right-clicking on a class displays a Contains, Base Types, Derived Types, and Is Used By context menu for additional call structure exploration.  In both cases, the New View button () appears, allowing a new view focused on the selected item to open. In addition to the call hierarchy context menu, and as one would expect, double-clicking on the node will launch you to the definition of that construct or open up the file corresponding to it.
With this enhanced solution explorer comes an additional Windows Preview option as well.  Single-clicking on a node in Solution Explorer opens up a document in preview mode. This option reserves a reusable document tab in the IDE such that each time a file is opened, it appears in the same document tab as the previously opened documents.  The result is that you can preview files without opening a myriad of unneeded document tabs.  The document tab can then be Promoted through a button glyph (see Figure 2) on the tab itself or automatically when the file is edited.

I must have my build set up with compiling, testing, packaging, and deployment. I have some xunit, nunit, nuget, msbuild helpers in the project to get projects up quickly. The lack of a xunit [...]]]> I have use psake a few times, and I wanted to see what I extract to be more productive. With the rate at which I spin off OSS and side projects, I need something that just works out of the box and is fast to set up. Borne of this need, I created Toji, and it is available as a NuGet package.

I must have my build set up with compiling, testing, packaging, and deployment. I have some xunit, nunit, nuget, msbuild helpers in the project to get projects up quickly. The lack of a xunit NuGet package, with test runner, is unfortunate as I can’t just use a script to quickly find the package.

To really give you a feel for what Toji does, here is a video showing off a little.

Getting started with Toji from Ian Davis on Vimeo.

Demonstrates the creation of a project and bootstrapping the build system with Toji.

Sponsored by the Spokane .Net Programming User Group and Presented by Mark Michaelis

I tried the following but none of them was successful: