IntelliTect » Mark

GIST: Windows Server “8” Administrative Experience

Mark — Tue, 03 Apr 2012 18:12:09 +0000

There are several items that deserve highlighting from Erin Chapple’s post (via Jeffry Snover) titled, “Rocking the Windows Server “8” Administrative Experience”. Here’s my gist:

Administration designed for one a single-role centric view to a multi-server view of the environment. The result is that rather than administer a role on a particular server you will now be able to administer a role that may span multiple servers.
The PowerShell based Command-line Interface (CLI) for Windows administration is a both/and experience – both CLI and GUI.
CLI automation increases reliability, auditability, and predictability – across multiple servers none-the-less.
Server Core is the preferred deployment option but GUI still available both on server (as backward compatibility option) but more importantly on the server.
SQL Server 2012 supported on Server Core.
Remote Management (WinRM) and Windows PowerShell installed and enabled by default on all servers.
.NET installed and enabled by default on all servers (given that PowerShell is there by default).
A new Minimal User Experience option allows GUI applications to run on Server Core but without th desktop shell or Internet Explorer.
As a fallback, it is possible to enable a metro style Start Screen experience.
Gazillions (2,300) PowerShell cmdlets oriented at managing the server.
A host of PowerShell ISE improvements including IntelliSense©, snippet support for an enhanced scripting UI experience, a Show Command window that allows administrators to search the cmdlets available, learn the syntax, and run or script the cmdlet.

Call to Action:

PowerShell is in your future, embrace it now.

Turning on Continuous Testing in Visual Studio 11

Mark — Fri, 02 Mar 2012 09:47:16 +0000

The new unit testing explorer support has a new unit test explorer has a Run dropdown for selecting which text to execute (see Figure 1).

Figure 1: Unit Testing Run Selection

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.

Figure 2: Activating Continuous Unit Testing In Visual Studio 11

New Attributes for Trace/Logging Information in .NET 4.5

Mark — Fri, 02 Mar 2012 09:12:01 +0000

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");
        }
    }
}

            view raw
            CallerInfoTests.cs
            This Gist brought to you by GitHub.
          

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

Installing Windows 8 Consumer Preview on the Windows Build Samsung Galaxy Slate

Mark — Thu, 01 Mar 2012 08:43:53 +0000

If you copy the Windows 8 Consumer Preview directly to a USB key and run Setup.exe you are likely to see a dialog indicating you need 20 GB of disk space and, obviously, there is no such availability on the tablet given the previous Windows 8 Developer Preview install.

: Windows 8 20 GB Required

The work around it to use a command prompt boot from USB as follows:

Create a bootable USB key using the Windows 7 USB/DVD download tool and copy the ISO to a USB key (4 GB minimum).
Plug in the USB Key to the Samsung Tablet
Reboot the tablet holding down the Windows Button while pushing the Power Button.
Upon boot select Troubleshoot
Windows 8 Troubleshoot Boot Menu Option
Select Advanced Settings
Windows 8 Boot Menu Advanced Option
Select Command Prompt – this will reboot the computer with a command prompt after logging in.
Windows 8 Boot Menu Command Prompt
After rebooting and logging on…
Enter D:\Setup.exe at the command prompt to launch the Windows 8 Setup and follow the prompts.
Run Setup.exe from Command Line
When requested to select a drive, choose Drive Options and the delete all the partitions until you are down to one.

From there you can follow the prompts and finish the installation. Generally it takes around 20 minutes.

Storyboarding in Visual Studio 11 with Lorem Ipsum Auto-expand

Mark — Wed, 29 Feb 2012 22:15:35 +0000

One of the “easter egg” (meaning not intuitively discoverable) features in the Storyboarding for Visual Studio is the fact that text boxes (of any kind – Text Areas, Text Input, Text…) you can type “=Lorem()” followed by ENTER to fill the text box with Lorem Ipsum text as shown here:

Storyboading Lorem Autoexpand Text

Windows 8 Consumer Preview Download Site Suggests Silverlight Download

Mark — Wed, 29 Feb 2012 21:19:05 +0000

In the process of downloading Windows 8 Consumer Preview from a relatively clean windows install I noticed that it suggested I download Silverlight.

Windows 8 Consumer Preview Download Site Suggests Silverlight

Team Foundation Server 11 Support Advanced SMTP Settings

Mark — Wed, 29 Feb 2012 18:46:45 +0000

Visual Studio Team Foundation Server 11 supports SMTP Settings as shown in the following screen shot.

TFS 11 SMTP Advanced Settings

As shown in the screen capture, it even supports a Certificate Thumbprint.

As a result, you can configure gmail as your email server for Team Foundation Server: smtp.gmail.com, Port 465, Enable SSL.

Visual Studio 11 Search Everywhere

Mark — Wed, 29 Feb 2012 17:42:56 +0000

One feature new to Visual Studio 11 that you will wonder how you managed without (perhaps instead you wondered why it was missing from Visual Studio for so long) is the concept of “Search Everywhere.” In Visual Studio 11 search is now supported for the following:

Solution Explorer*
Add Reference*
Integrated Quick Find*
New Test Explorer
Error List
Parallel Watch
Toolbox
TFS Work Items
Visual Studio Commands

(* indicates where similar search functionality exists within the Productivity Power Tools – targeting Visual Studio 2010)

Below we take a look at each search location in a more detail.

Solution Explorer

Perhaps the most noticeable manifestation of Search Everywhere appears within the Solution Explorer. As shown both in Figure 1, there is a Search Solution Explorer text box with keyboard shortcut “Ctrl+;” (you will want to memorize that almost immediately) that searches the solution and produces a search results window of matching Solution Explorer available nodes.

Figure 1: Visual Studio 11 Solution Explorer

The results window displays such assets as projects, files, and identifiers – classes, and class member names. The result is similar in behavior to Visual Studio 2010’s Navigate To (Ctrl+,) functionality, but rather than a modal dialog, the Search Solution Explorer produces a search results window that is integrated into the IDE. Like Navigate To, the Search Solution Explorer supports “fuzzy search” – entering the first (uppercase) letters of each word within an identifier will still locate the corresponding node. For example, entering “MOCT” will display all instances of MockObjectContextTests but “moct” will not. Note that the keyboard shortcut (Ctrl+;) switches focus to the search box even when the Solution Explorer is not visible. This is a handy shortcut when the Solution is mistakenly closed.

Add Reference

Figure 2: Add Reference Dialog

As shown in Figure 2, the Add Reference Dialog, still places the target reference into categories – Assemblies, Solution, and COM – but the experience of looking for a particular reference is significantly improved. Possibly more noticeable than the Add Reference search is how quickly the Add Reference dialog opens. Rather than seemingly enumerating the Global Assembly Cache and every COM object installed on the computer, the new dialog uses an index (of the installed components) and displays almost instantly.
Double-clicking on any item selects it, and all referenced items are displayed with a checkmark next to the assembly name.

Integrated Quick Find

While on the topic of search, another significant productivity improvement is a streamlined Find UI design – Quick Find. Leveraging again the UI of the Productivity Power Tools, Visual Studio 11’s Find (Ctrl+F) and Find-Replace (Ctrl+H) functionality is integrated into the text editor window rather than a new pop-up window (see Figure 3). The result is that Find and Find-Replace functionality remains in context.

: Figure 3: Integrated Quick Find

Furthermore, the text entered in the Find box is immediately highlighted throughout all text editor windows – the currently active document, other open document windows, and any newly opened document windows. To change the search scope you can select from the dropdown available below the Replace text box. Figure 5 shows the advanced search options – available after clicking the “Expand” button directly to the left of the Find text box. For developers looking for the Use Regular Expression, Match Whole Words, and Match Case functionality in addition to the Find in Files capabilities (something no longer available in the toolbar as will be discussed shortly), there is a dropdown on the text box that not only displays recent search terms but also the additional search options.

New Test Explorer

Another manifestation of Search Everywhere is in the new Unit Test Explorer window. Unit testing in Visual Studio 11 was overhauled and includes support for third party testing frameworks along with a consolidation of the testing windows into the new Unit Test Explorer window (see Figure 3). The top of the new Unit Test Explorer window includes a search textbox, enabling search for a particular test.

Figure 4: Visual Studio 11 Test Explorer

In addition to search, the new Unit Test Explorer includes the following functionality:

Continuous Testing
Immediately following a compile, the unit testing is automatically triggered to run (in a separate process so as not to impact the IDE responsiveness). As a result, executing tests is no longer a separate action but rather something that is automatically part of the development process – in a similar way that syntax checking happens automatically as you write code. If there are failing tests, only the failing ones will be executed as part of the continuous testing. The idea behind this is to get the failing ones passing before executing any additional tests.
Execution within a different process
In Visual Studio 2010 the IDE was essentially blocked while unit tests executed. In contrast, unit test execution within Visual Studio 11 runs concurrently with any IDE activity the developer may be working on. This is due to the fact that in Visual Studio 11 the unit tests are asynchronously shelled out to a separate a process.
Support for different unit testing frameworks
As mentioned, Visual Studio 11’s unit testing framework support is extensible. As a result, unit tests from other frameworks also appear within the new Unit Test Explore window.
Sorting by relevance
Unit tests within the Unit Test Explorer windows are sorted by relevance. Failed tests bubble to the top. Tests executed more recently appear before tests that were not run in the previous test execution.
Execution time displayed
The time it took to execute a unit tests appears next to each unit test.
Mocks/stub support
In Visual Studio 11 there is support for the generation of mocks/stubs of a class and this is integrated not only into the framework but all the way into the IDE tooling via “right-click generate mock/stub” contextual menus.

Those committed to unit testing will find the revamped functionality within Visual Studio 11 to be compelling to the point that this feature set alone will make it difficult to return to Visual Studio 2010.

Error List

Yet another Search Everywhere location occurs in the Error List (see Figure 4).

Figure 4: Visual Studio 11 Error List

By using the Search Error List textbox you can search across columns and all errors within the error list to focus on the errors you wish to address first. Furthermore and again shown in Figure 4, Visual Studio 11 supports a filter so that developers are no longer overwhelmed by innocuous HTML warnings, for example, while they are investigating C# code. Instead, using the filter button, developers can select the scope of warnings to be displayed.

Parallel Watch

The Parallel Watch window is another area where search appears in Visual Studio 11. Although not really a textual search, these watch windows include a Filter by Boolean expression search box that enables filtering across different threads and evaluating the expression for each thread to determine which threads evaluate the expression to true.

TFS Work Items

An additional instance of Search Everywhere corresponds to TFS integration. The Visual Studio 11 Team Explorer window is completely redesigned, and now includes a Search Work Items text box to search across work items.

Visual Studio Commands

The last Search Everywhere feature discussed in this article appears in the Visual Studio 11 toolbar – enabling search over all the available commands and actions within Visual Studio 11 itself. We explore this feature as part of Toolbar Improvements.

Visual Studio 11 IDE Productivity Improvements

Mark — Wed, 29 Feb 2012 08:33:01 +0000

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.

: Figure 2: Visual Studio 11 Tab Promot Button

Where the preview tab really cleans up the IDE is during debugging or Go To Definition (F12), where a myriad of windows will otherwise proliferate. Instead, the same tab window is recycled for all the documents you preview while debugging or browsing through the code.
A similar feature to the preview tab is “tab pinning.” In place of the “Promote” button found on the Preview Tab (Figure 2), normal tabs have a pin icon ( ) that moves the tab to the left of the tab well. Any new documents that are opened will appear to the right of the last pinned tab – effectively holding the position of the pinned tabs unless they are moved deliberately
There are several additional Solution Explorer related features to be aware of. Firstly, it is no longer necessary to open up a graphics file (.JPG, .PNG, etc.) in order glimpse it. Instead, Visual Studio 11 supports hovering over the file within Solution Explorer, triggering a dynamic preview image of the graphic. Secondly, when renaming files in the solution explorer, it now behaves like Windows Explorer. The default selected text after issuing a rename action is the file name but not the extension.

Transitioning between Sprints/Iterations with TFS

Mark — Mon, 06 Feb 2012 20:27:43 +0000

When transitioning from one Sprint (or iteration) to another it is necessary to modify all “current sprint” queries and any additional custom queries that are sprint/iteration specific. This is not a one time activity per team project but rather something you have to do after every sprint.

One way to eliminate this step is by creating a “release” called “Current” and moving the specific current sprint (Sprint 1, Sprint 2, or 2012-02-06 for example) under this release. The current sprint is simply moved from its defined release into the Current release when the sprint starts. When the sprint ends, the sprint is moved back to its original release and a different sprint moved under the Current release. Then, by changing all the sprint specific queries to select item under Current release, it is no longer necessary to change the queries every release – they just work.

Here are the steps in more detail:

To create a new release for Current, use the Areas and Iterations dialog and add a new Child Node.

Once created, we position Current as first in the list. The dialog below shows Current and Sprint 1 as a member, indicating that Sprint 1 is the current sprint.
Next, all the queries defined under Current Sprint are modified to use the “under Current” clause. This modification only needs to be made one time when the project template is being configured. Below is a screen shot after modifying the Sprint Backlog query.
When moving from one sprint to the next, simply change the sprint hierarchy so that the new sprint (Sprint 2 for example) appears below the “Current” release and the previous sprint (Sprint 1) is returned to the correct release structure.

With these changes in place, the queries will just work as is when you transition from one sprint to the next. Furthermore, this technique is valid and expected to work for TFS Preview, TFS11, Microsoft Visual Studio Scrum 1.0, and MSF for Agile.

(Note: Releases are not required, you can just have a parent node (Current) that appears anywhere in the hierarchy and move the Current Sprint below that – with corresponding queries to match.)