Visual Studio Tips and Tricks

Surround with a Code Snippet (C# Only)

zainnab — Wed, 14 Dec 2011 09:00:00 GMT

Keyboard: CTRL + K, CTRL + S
Menu: Edit | IntelliSense | Surround With
Command: Edit.SurroundWith
Versions: 2008,2010
Published: 4/21/2010
Code: vstipEdit0052

This is one that even people who know about snippets tend to forget. You can actually put a snippet AROUND existing code. Assuming you have some code selected:

Just press CTRL + K, CTRL + S:

Then type the statement you want to surround the code with. In this case, I’ll use an “if” statement:

Hit your TAB key once and you get your result:

Now you can put in your condition and any additional logic you want. Pretty cool stuff!

Visual Studio 11 Developer Preview: Code Clone Detection (aka Code Clone Analysis)

zainnab — Tue, 13 Dec 2011 09:00:00 GMT

Versions: Visual Studio 11 Developer Preview

Make sure to get your copy of the new book from Sara and me:

Coding Faster: Getting More Productive with Microsoft Visual Studio

Note: As always with pre-release software, some of the features may not make it into the final version or may change significantly before RTM. Also, although I will only show features that are publicly available, I may be using a slightly older or newer version of the build than you are so there may be slight differences in the feature set I show and the feature set you currently have.

</Disclaimer>

In my travels across the country, with my fellow Evangelist, Clint Edmonson, talking about Visual Studio we often come across great stories to tell. One of our favorite true stories is of a customer that had a web application running very slow. We ran code metrics against it and, sure enough, the Page_Load event had 9,000 lines of code in it. Naturally we were curious so we opened it up to see that it was basically the same if statement copied over and over. Apparently they needed to find out who was coming into the website in order to show customized content and the solution they came up with was this massive set of statements.

For better or worse we have all had code that gets copied throughout our solutions. Until now there was no tool to tell us there were copies and, instead, we had to rely on other metrics such as lines of code to hopefully reveal any code smells. Now, however, we have the new Code Clone Detection (aka Code Clone Analysis) feature.

According to the documentation:

“Code clones are separate fragments of code that are very similar. They are a common phenomenon in an application that has been under development for some time. Clones make it hard to change your application because you have to find and update more than one fragment. Visual Studio can help you find code clones so that you can refactor them.”

http://msdn.microsoft.com/en-us/library/hh205279%28v=vs.110%29.aspx

Specific Clones

You can find clones of specific code by selecting the segment you are interested in:

Then Right-click on the selection and choose Find Matching Clones in Solution from the context menu:

Visual Studio will search for code clones and produce the result in the new Code Clone Search Results window:

The original line of code is put in a group on its own and then all the matches are put into a different group. You can expand the groups to see the specific locations of the matches:

Solution Clones

Besides looking for specific clones you can also just look for code clones for the entire solution. This will search the entire solution for duplicate code and display the results. To use this feature go to Analyze | Analyze Solution for Code Clones:

This creates a result set for the entire solution:

By default it groups and sorts the results by the strength of the match. Exact matches come first then those matches that may be close but not exact come next. As you can see the other terms used are Strong, Medium, and Weak in this example.

Reviewing Matches

Once you have the result set, there are a couple of ways you can compare them against each other.

Comparison Tools

Although I don’t show it here, if you have a comparison tool configured you can Right-click on any two items and select Compare from the shortcut menu. You would know if you have this feature available by going to Tools | Options | Source Control | Team Foundation Server and click on Configure User Tools.

Manual Comparison

If you don’t have a comparison tool you can do manual comparisons between two entries in the list. If the clones are in different files then you can just double-click each one and file tabs will be available for you to look at for comparison:

When it comes to comparisons in the same file I’ve only found one good way to accomplish this so far. Granted, I have just started playing with this feature so there might be something coming or something I missed that makes this easier. Here is a series of steps to compare two items in the same file.

First, find the first entry you want to look at and double-click on it to open a file tab and highlight the code segment:

Now make a copy of the current code window by going to Window | New Window:

Next, go to the second entry you are interested in and double-click it. The result should be one code segment on each tab so you can compare the two:

You can do this for as many entries in the list as you like. Just repeat these steps for each entry you want to compare.

What Is Found

You are probably curious as to what is found by this tool. The heuristics for finding clones will find duplicates even if the following changes have happened:

· Renamed identifiers.

· Insert and delete statements added.

· Rearranged statements.

What Is Not Found

There are some rules for what is not found as well. I have taken this list from the documentation pretty much verbatim.

· Type declarations are not compared. For example, if you have two classes with very similar sets of field declarations, they will not be reported as clones. Only statements in methods and property definitions are compared.

· Analyze Solution for Code Clones will not find clones that are less than 10 statements long. However, you can apply Find matching clones in solution to shorter fragments.

· Fragments with more than 40% changed tokens.

· If a project contains a .codeclonesettings file, code elements that are defined in that project will not be searched if they are named in the Exclusions section of the .codeclonesettings file.

· Some kinds of generated code are excluded:

· *.designer.cs, *.designer.vb

· InitializeComponent methods

· However, this does not automatically apply to all generated code. For example, if you use text templates, you might want to exclude the generated files by naming them in a .codeclonesettings file.

Code Clone Settings and Exclusions

A settings file is available to configure this feature at the project level. I tried to use it at the solution level but it didn’t work so this is definitely a per-project activity. Currently we have only announced the ability to do exclusions in the file but there will most likely be other elements that are added later on. The file is just XML with a .CODECLONESETTINGS extension. The only requirement for use is that the file exists in the top level directory of the project.

The base elements consist of a CodeCloneSettings element with an Exclusions child:

Within the Exclusions element you can have the following children:

<File>

This element is used to indicate files that should be excluded from analysis. Path names can be absolute or relative and you can use wildcards as well. So, for example, to ignore all the C# text template files that have been put in their own directory (called MyTextTemplates) you might have the following:

<Namespace>, <Type>, and <FunctionName>

You can also exclude namespaces, types, and functions. Just like files these items can use absolute names or names with wildcards in them. Here is an example of what it might look like:

Example Scenario

In the Tailspin Toys sample that I have there is some generated code in the TailSpin.SimpleSqlRepository project that is the bulk of the duplications:

Code clone analysis doesn’t automatically know to ignore text templates so I have created an XML file called TailSpinRepository.codeclonesettings and inserted an entry like this:

Now if I run clone analysis here is the result:

As you can see the results are significantly less than the first time the analysis ran. It’s common to create several exclusions in different projects to weed out noise in the analysis results.

Finally

Code Clone Detection is a great new tool to add to your arsenal for improving code quality. Combined with Code Analysis and Code Metrics, this will help quickly find potential issues.

Greatest Hits: Using the New IntelliSense - Pascal Case

zainnab — Tue, 06 Dec 2011 09:00:00 GMT

Keyboard: CTRL + J
Menu: Edit | IntelliSense | List Members
Command: Edit.ListMembers
Versions: 2010
Published: 2/9/2010
Code: vstipEdit0017

Have you ever been in a situation where you wanted to use IntelliSense to get a method but there are a TON of methods that start with same word and you have to type almost the entire method name?

Well those days are over! Let's say you want the SetWindowSize Method but really, really don't want to type it out or even scroll down to get the method. IntelliSense now supports Pascal Case! All you have to do is type "SWS" and you are all set:

Greatest Hits: Using Visual Studio 2010 IntelliSense with Keywords

zainnab — Wed, 30 Nov 2011 09:00:00 GMT

Keyboard: CTRL + J
Menu: Edit –> IntelliSense –> List Members
Command: Edit.ListMembers
Versions: 2010
Published: 2/8/2010
Code: vstipEdit0016

The one feature we regularly use more than just about anything else in Visual Studio is IntelliSense. It has been our friend for many years. Well it just got more friendly! To show you the new feature, let’s take a look at VS2008 IntelliSense. Notice when I type Console.Key what happens:

It does what you would expect it to do and highlights the first (in this case—only) item that begins with the word “Key”. That’s great but what if I don’t know what I am looking for but I know that it has the word “Key” somewhere in it? Well, I can go search in the Object Browser, of course OR I can use the new IntelliSense in VS2010. Watch what happens when i do the same thing in VS2010:

Voila! It now shows only those items that have the word “Key” in them AND doesn’t care where the word is in the name of the member! So not only do it get items that begin with “Key” but I get ANYTHING that has the word “Key” in it.

Visual Studio 11 Developer Preview: Multiple / Floating Tab Wells

zainnab — Tue, 29 Nov 2011 09:00:00 GMT

Versions: Visual Studio 11 Developer Preview

Make sure to get your copy of the new book from Sara and me:

Coding Faster: Getting More Productive with Microsoft Visual Studio

Note: This feature was first introduced in the VS2010 Productivity Power Tools extension found here:

http://visualstudiogallery.msdn.microsoft.com/d0d33361-18e2-46c0-8ff2-4adea1e34fef?SRC=Home

Visual Studio 11 Developer Preview

Continuing with our look at Visual Studio 11 Developer Preview we will examine the concept of multiple/floating tab wells that was originally created by Radames Cruz Moreno from the VS Platform Team. In VS2010 we introduced the idea of floating document windows. The only problem was, once detached; the window was a completely independent entity. This was great if all you wanted was one window but what if you wanted, say, 20 windows on one screen and 10 on another? Things get pretty out of hand fast when dealing with multiple windows beyond a certain point. Visual Studio 11 Developer Preview comes with the ability to not only detach windows but have them in multiple tab wells to better organize your windows. In this tip I’ll show you how to take advantage of this feature.

Quick Walkthrough

Open up Visual Studio 11 Developer Preview and get a couple of tabs in the tab well like I have here:

Now click and drag one of the tabs outside the IDE:

You should notice a new window is created, with a new tab well, and the tab is inside the well:

Now you can add more tabs to the new area and treat it just as you would the original tab well:

Menu Commands

I think the hardest part for people to get used to is that certain menu items impact the current active window regardless of where it is. For example, Window | New Window which makes a copy of the current window:

Will work regardless of where the active window is located:

Also, as I am sure you have guessed by now, you can have multiple independent tab wells:

So there you have it! This is a huge advantage that allows you to move and organize your VS windows the way you want.

Turning It Off

Note: When I tried this on my system the change didn’t take effect so you may not be able to turn this feature off in your pre-release build.

If you don’t like this feature it can be turned off by searching on “tabs” in the Quick Launch area (CTRL + ` [back tick]):

Selecting the entry for Environment -> Tabs and Windows:

Then turn off Enable Independent Floating Tab Wells:

This will return you to the VS2010-like experience.

For those who like menu commands the path to this option is Tools | Options | Environment | Tabs and Windows | Floating Tab Well.

O’Reilly / MS Press Cyber Monday Ebook Deal

zainnab — Mon, 28 Nov 2011 09:00:00 GMT

Now that I’m published the marketing folks send me all kinds of stuff on book specials. Most of them are cheezy but this one looks pretty cool so thought I would share. Here is the tweet they are sending out:

CyberMonday Deal: Save 60% on 60 new and top ebooks! Today only. Shop now: http://bit.ly/s3vkkJ

Naturally the book I did with Sara is on there for like 12 bucks or something as well as many other titles. Good times

Greatest Hits: Make IntelliSense Transparent

zainnab — Wed, 16 Nov 2011 09:00:00 GMT

Keyboard: CTRL
Versions: 2008,2010
Published: 10/17/2010
Code: vstipEdit0077

I thought it would be cool to rerun some of the items that many people have really liked in the past. This is the first of the posts I’ll call the Greatest Hits for folks to get exposure to tips they may have missed the first time around. With that said, on with the tip…

Sometimes when you are cranking code you find yourself in a situation where IntelliSense is covering up some code you want to see:

You can easily make it temporarily opaque by pressing and holding the CTRL key:

This way you don't have to completely get rid of IntelliSense, see the code, then bring IntelliSense back. Just press the CTRL key, get the information you need, and move on.

Visual Studio 11 Developer Preview: Preview Tab

zainnab — Tue, 15 Nov 2011 09:00:00 GMT

Shortcut: CTRL + ALT + Home (promote); ALT (do not preview in Solution Explorer)

Versions: Visual Studio 11 Developer Preview

Make sure to get your copy of the new book from Sara and me:

Coding Faster: Getting More Productive with Microsoft Visual Studio

Preview Tab: Common Scenarios

We all explore code and need move quickly between files. In prior versions of Visual Studio you had to open a file to look at the contents which often resulted in many open files (tabs) after debugging or reviewing some code. The Preview Tab eliminates the need to open certain files when browsing code. Most likely you’ll first encounter the Preview Tab when you are looking at files with Solution Explorer. When you click on a supported file, you will see the contents of that file in the new preview tab:

The point of the preview tab is to let you view the contents of a file without actually opening up a new tab in the tab well. As you look at different files the preview tab only shows the contents of the file you are currently on. This keeps the environment from getting cluttered with open tabs and allows you to focus on only those files that are interesting to you. Solution Explorer isn’t the only place you can use the preview feature. It turns up in several situations where you might need to look at file content. For example, when using Find (CTRL + F) to locate information you will see the preview tab:

Promoting Previews

At some point you may decide to promote the preview to an opened tab in the Tab Well so you can do additional work on the file. There are a few ways you can make this happen.

Click the Promote button

Just click the promote button on the preview and it will open up a tab for that file:

Press CTRL + ALT + HOME

With the cursor in the file, just press CTRL + ALT + HOME to open a tab for the file you are currently viewing.

Change the File

While previewing a file, if you make any change to the file it will automatically be promoted to an open tab so that you can make additional changes and do any other actions you need to perform.

Turning Preview Off

To see the options you have for using the preview feature, just type preview in Quick Launch (CTRL + ` [back quote]) and click Environment -> Tabs and Windows:

This will take you to Tools | Options | Environment | Tabs and Windows:

To turn off the preview feature uncheck the Allow New Files to be Opened in the Preview Tab option. Also notice you can decide if a single click open the files in the preview and/ or use ALT to prevent a file from being previewed when you click on it. While I see the value in using ALT to prevent preview from happening; I haven’t yet found any reason for turning off the single-click option as it, in effect, makes the feature unusable.

Finally

The Preview Tab is one of the great new additions to the Visual Studio IDE that, I believe, will be an exceptional productivity enhancement. Try it yourself and let me know what you think.

Docking External Document Windows

zainnab — Thu, 10 Nov 2011 09:00:00 GMT

Windows: CTRL + Double Click on Title Bar
Menu: Window | Dock As Tabbed Document
Command: Window.DockAsTabbedDocument

SKU: Professional, Premium, Ultimate
Versions: 2010, Visual Studio 11 Developer Preview
Code: vstipEnv0065

In Visual Studio 2010 we introduced the ability to take document windows outside the IDE:

However, the old trick of double-clicking on the Title Bar to dock the window back into the tab well doesn’t work anymore. It turns out that CTRL + Double-Click is the new shortcut to dock document windows back into the IDE:

If you have installed the Productivity Power Tools (http://visualstudiogallery.msdn.microsoft.com/d0d33361-18e2-46c0-8ff2-4adea1e34fef) or have Visual Studio 11 Developer Preview then you have floating tab wells:

You can CTRL + Double-Click on the window’s Title Bar to dock all the tabs in the external tab well.

The strange part comes when you have multiple tabs in an external tab well. If CTRL + Double-Click on an individual tab in the external tab well when there is more than one tab it creates a new tab well with only one tab in it. When you CTRL + Double-Click on a tab that is the only one in the current tab well then it will dock it. Not sure if this is intentional behavior or a bug.

Visual Studio 11 Developer Preview - Project Backward Compatibility (Round-Tripping)

zainnab — Tue, 08 Nov 2011 09:00:00 GMT

Probably one of the most welcome new features in VS11DP is the new project backward compatibility feature also known as project round tripping. Let’s dig into the details.

The Old Days

In all prior incarnations of Visual Studio if you had an older version, VS2008 for example, and opened up the project in a newer version, VS2010 in this case, you had the option to convert the project. If you did the conversion it was a one-way trip. You couldn’t open the project again in VS2008 if you tried to go back. This has been the source of a lot of pain and suffering for developers who have to work with multiple versions of Visual Studio. We want the cool features of the latest IDE but still want others on our team to be able to open the solution in the older version of Visual Studio when they get the files from source control.

The New, Happy Days

You can now create projects in Visual Studio 2010 with Service Pack 1 then open those projects in Visual Studio 11 Developer Preview and THEN open the project up again in VS2010SP1. In other words, we now have full project round-tripping capability so you can work with the latest features but still keep the solution compatible with and older version of Visual Studio.

Putting it to the Test

Here are the steps you can take to test this for yourself:

Create a project with Visual Studio 2010 with Service Pack 1 and put in a little sample code.
Save and close the solution.
Open the solution (CTRL + SHIFT + O) in Visual Studio 11 Developer Preview and add some more code. Notice there is no longer a prompt to convert the project that appears.
Save the close the solution.
Open the project up again in VS2010SP1 and bask in the glory of project round-tripping.

Limitations / Observations

I know this works with Visual Studio 2010 Service Pack 1 but haven’t tested VS2010 with out the service pack. I believe it will not work unless you have the service pack but am checking with the team.
You can’t use this feature with versions older than VS2010.
When you use any feature specific to the new version of Visual Studio, like changing the Framework to the latest version, then the project cannot be opened in the prior version. I just changed the framework version from 4.0 to 4.5 for a project and saved it without many any other change and was not able to open the solution in VS2010.

Visual Studio 11 Developer Preview: Quick Launch

zainnab — Thu, 29 Sep 2011 08:00:00 GMT

I’m very excited about the new Quick Launch feature! You can catch my latest post on this feature on the Visual Studio Team Blog here:

http://blogs.msdn.com/b/visualstudio/archive/2011/09/27/visual-studio-11-developer-preview-quick-launch.aspx

I’ll be posting some of my material to the various team blogs and, of course, this blog throughout the VS 11 cycle but will always have pointers to the information from here for reference.

Visual Studio 11 Developer Preview: Visual Basic (VB) Call Hierarchy

zainnab — Tue, 27 Sep 2011 08:00:00 GMT

Hey folks! Well Visual Studio 11 Developer Preview is here and the Visual Studio team has asked me to write about some of the cool new features coming in the next release. My first post, on the new VB Call Hierarchy, can be found at the Visual Basic Team blog here:

http://blogs.msdn.com/b/vbteam/archive/2011/09/20/visual-studio-11-developer-preview-visual-basic-vb-call-hierarchy.aspx

I’ll be writing more about new features going forward and will either post it here or have a post, like this one, that will show you which VS Team blog you can find my latest work at. Enjoy!

Windows 8: Under the Hood

zainnab — Mon, 12 Sep 2011 08:00:00 GMT

I know I normally stick to Visual Studio topics but thought I would throw in some Windows 8 information since that is the platform we will be using going forward. I’ll mix in Win 8 information through the product lifecycle and pull the covers off interesting pieces that we may want to dig into. With that said, Steven Sinofsky has been blogging on the new features coming up in the new OS. You can find his posts at the Building Windows 8 blog found here:

http://blogs.msdn.com/b/b8/

Keep an eye out for more information going forward…

Coding Faster: Getting More Productive with Microsoft Visual Studio -- Getting the Appendix

zainnab — Wed, 07 Sep 2011 08:00:00 GMT

Folks I just wanted to call it out since the book doesn’t really emphasize it as much as I would like. The appendix is basically a second book that goes with the first. I took the entire body of work and divided it into part that go to print and parts that get put in the appendix area. If you only read the book you are only getting half the content so make sure you do the following:

Download the appendix: http://go.microsoft.com/fwlink/?linkid=223758
Please submit a review at the site you purchased the book from and on Amazon where most folks will probably go to get the book: http://www.amazon.com/gp/product/0735649928. Also, you can reach me at zainnab@microsoft.com to give direct feedback.

Visual Studio vNext Performance Enhancements

zainnab — Tue, 06 Sep 2011 08:00:00 GMT

Continuing on our odyssey of exploring the features in vNext, I thought we would look at some of the performance enhancements that have been publicly announced. Naturally, at this time, I can’t go very deep into the inner-workings of the improvements but will endeavor to list them out and explain somewhat based on information currently available. Also, be aware that this is a very early look at these features so there will be many improvements made as the product gets closer to RTM. I’m actually running two versions of vNext currently; the one that will be made available to the public as a pre-release at some point and the one we build internally so I have a pretty good handle on what you will see and what is coming out. I can say that there are some great things that are being done with the product you will definitely enjoy. With that said let’s take a look at some of the things we have revealed so far…

Microsoft Visual Studio IDE Futures

First off, if you haven’t seen it yet, most everything I mention comes from the great TechEd session done by Weston Hutchins that can be found here:

http://channel9.msdn.com/Events/TechEd/NorthAmerica/2011/DEV326

Performance: The Four Pillars

For vNext we are focused on four areas of investment to improve the product:

Overall Responsiveness
Long Running Operations
Memory Utilization
Better Feedback

Overall Responsiveness

As I review the areas of improvement expect a great deal of overlap as many of the improvements fall into multiple categories. With that said, this area is pretty self-explanatory: We want vNext to enable users to quickly go about their work without waiting on the IDE. These improvements manifest themselves in a variety of ways but all have the singular goal of making the product more responsive. Below are some of the areas that address this goal that we have made public so far.

Faster, Stronger, Better Add Reference Dialog

One of the IDE enhancements revealed so far is Add Reference dialog box. First and foremost it has been supercharged to load almost instantaneously. How? We index the assemblies beforehand to have a ready-made list on demand. We haven’t gone into detail yet on what exactly is being done but expect that revelation in due course. Also, as with most of the IDE, we have added the ability to search/filter the list so you don’t spend a billion years looking for the assembly you want.

Out-of-Process Operations

We have moved some activities out-of-process to give control back to the IDE quickly. See Memory Utilization.

Parallel Operations

vNext will take advantage of multi-core systems much better than VS2010 which will result in more overall responsiveness. See Long Running Operations.

Long Running Operations

Building and debugging are examples of a long-running operations that we are addressing. For example, Visual Studio 2010, while a great improvement over previous versions, really doesn’t take full advantage of multi-processor machines. Our goal is to speed things up so you can get your work done faster with less time spent waiting.

Background Builds

Build operations have now been moved to background threads so you can actually do other things in Visual Studio while a build is happening.

Parallel Project Builds

Another great new feature is the ability to build projects in parallel. vNext comes with an option to have parallel project builds based on the number of cores your system has. In fact, the default value is automatically set to the max cores on your system. You can reduce this value if you want.

Memory Utilization

Responsiveness also includes the overall efficiency of Visual Studio. We are working on reducing the memory utilization overall based on usage.

Virtual Memory Utilization

vNext uses much less virtual memory internally. Much of this is due to running builds out-of-process (see below) as well as other enhancements we have made that haven’t been released yet.

Out-Of-Process Builds (C++, C#)

C++ has had this feature for a while and we are now brining it to C# and, in a future release sometime after vNext, VB as well. We now perform builds outside the Visual Studio process. Instead of loading numerous referenced assemblies inside the VS process they are now loaded into an external process then discarded when we are done. This results in significantly less memory usage inside Visual Studio which results in a more responsive, stable product.

Better Feedback

This one is really simple. How do we get the best information possible when there are issues with the product so we can continuously improve it for you? Solving for this question is never easy but we have devised ways of obtaining performance data from your actual use of the product to help strengthen our knowledge of areas that need to be addressed.

PerfWatson, PerfWatson, PerWatson

The number one tool you can download TODAY to give us feedback on VS2010 and vNext is PerfWatson. You can get it from the Visual Studio Gallery here:

http://visualstudiogallery.msdn.microsoft.com/fa85b17d-3df2-49b1-bee6-71527ffef441

This tool allows us to get up-to-date, immediate information on the issues that are impacting performance. This tool is currently built into the pre-release version of vNext and, I suspect, we will include it in the RTM version as well with an option for you to turn it off if you don’t want it.

Visual Studio Feedback on Connect

If you haven’t gone to http://connect.microsoft.com/VisualStudio/ yet then you need to. This is one of the main ways we have been getting directed feedback from you for some time now. It’s a great way to get to see what others are saying and to communicate directly with the VS team.

Visual Studio vNext IDE Enhancements

zainnab — Thu, 01 Sep 2011 08:00:00 GMT

===

Quick Housekeeping Note: I’ve deprecated the old Visual Studio Tips extension and have tried to get it removed from the gallery so it isn’t available anymore but have had little success. I am currently not planning to replace the tool with a new version but am open to suggestions as to a viable alternative. For now I suggest you use your favorite RSS feeder or visit the blog directly. Now on with the post…

===

With the BUILD conference (http://www.buildwindows.com/) just around the corner and lots of announcements coming I thought now would be a good time to pause the usual posts and talk about the next version of Visual Studio (vNext) and how you can prepare for some of the goodness to come. This is a high-level look at what is coming and I will be blogging in much more detail on the features throughout the vNext cycle. With that said, I’ve intentionally left out any images of the IDE for this post in favor of brief feature descriptions. Additionally, I will be blogging and tweeting directly from the BUILD conference while I am there to keep you up to date on the latest revelations that are coming out. To get a sneak preview of some of the features make sure to see the following video:

Microsoft Visual Studio IDE Futures

http://channel9.msdn.com/Events/TechEd/NorthAmerica/2011/DEV326

vNow

Visual Studio 2010 introduced a great new extensibility model that made custom additions very easy to make. You can find these extensions at the Visual Studio Gallery (http://visualstudiogallery.msdn.microsoft.com/) and, if you haven’t explored some of these great additions, I suggest you browse through the gallery to see the items there. When asked which extension I suggest everyone download the number one answer I give is always been the Productivity Power Tools (http://visualstudiogallery.msdn.microsoft.com/d0d33361-18e2-46c0-8ff2-4adea1e34fef?SRC=Home). Download it now. Seriously. Now.

We have (and will going forward) use extensions to field test new features that will be included in future versions of Visual Studio and it is a safe bet that some of the Power Tools will find their way into the vNext. If you watched the video mentioned above you will hear Weston Hutchins mention this as well. What better way to see what people want than to let them vote by actually downloading and using a feature? Granted it’s a little harder to focus on individual features when a lot are packed together but, even then, we get plenty of feedback on what people like and don’t like.

vNext

Once we get beyond VS2010 then we can start looking at the new features that have been publicly revealed so far. Here is a list of things you can expect in the next version:

Project Round-Tripping

One of the bigger pains in prior versions of Visual Studio is moving a project between versions. It was an all-or-nothing proposition typically due to schema changes to the proj files. If you opened a VS2008 project in VS2010 and converted it to the new project format then that project could no longer be opened in the prior version. For those that have experienced this you know this wasn’t entirely true and you could do a little proj file hacking to go back but it wasn’t fun or intuitive to do so. Visual Studio vNext will solve that issue. You will now have the ability to open a project in the new version of Visual Studio and still go back to prior versions. The net effect is you can have different teams on different versions of Visual Studio but still able to share projects with each other!

Search the IDE

With the dizzying array of menu items, toolbar buttons, options, files, etc… it is often difficult to remember where a particular item exists. VS vNext adds the ability to quickly search the IDE for these things. A good analogy would be to compare it to the ability to search programs and files when you click on the start button in Windows. I don’t know about you but I don’t look for files anymore for the most part, I just hit my Windows key then type in what I am looking for then select what I want. Imagine that level of functionality inside the Visual Studio IDE and you have an idea of what this new feature does.

Solution Explorer Enhancements

Multiple Instances of Solution Explorer

vNext supports creating new instances of Solution Explorer so you can have focused areas (one project in one instance and another project in a second instance) for working on multiple monitors. Additionally these instances can be nested inside windows that have been pulled outside the IDE for use on other monitors.

Navigation

In the Productivity Power Tools we introduced the Solution Navigator with some cool new features that have found their way into the new IDE. The ability to drill down into the classes then members from Solution Explorer now exists. You can right-click, say, a method in Solution Explorer and see some new terminology: Calls, Is Called By, and Is Used By. Calls represents the call hierarchy for the method; Is Called By represents a list of methods that call the current method; and Is Used By represents all the specific file, line, and column positions where the method is mentioned.

Search

Much like the new search for the IDE, we now have a new search for just the items in Solution Explorer. You can quickly type in a file, class, reference, etc… and see a filtered list in Solution Explorer of the items you are looking for.

Collapse All

A long-awaited feature that will collapse everything in Solution Explorer so you can expand items “fresh” as you navigate though the various hierarchies.

Tab Well Enhancements

Pin Tabs

Another feature introduced in the Productivity Power Tools, this feature will let you keep interesting tabs surfaced on the left of the tab well while non-pinned tabs get pushed out of the visible area based on usage.

Floating Tab Wells

You can now rip off documents from the IDE and have multiple tabs grouped together in one or more floating tab wells. This is great for multi-monitor situations where you want groups of related files on separate monitors.

Search Toolbox

There is now a dedicated search box for the Toolbox window so you can quickly filter items to find the controls you want.

Add Reference Dialog

The most notable change to the Add Reference dialog is speed. It is way, waaaaay faster to add a reference with the new dialog than ever before. Also, a search box has been added to allow quick filtering of assemblies.

Streamlined Quick Find / Replace

The Quick Find / Replace has been cleaned up and streamlined to make using the experience easier overall.

Error List Window Enhancements

Search Errors

As with many other tool windows, the Error List window now sports a search box you can use to filter the list of errors, warnings, and information messages.

Scope Filter

The Error List window also now supports a scope filter that lets you show only those items in Open Documents, the Current Project, or the Current Document.

Preview Tab

Probably one of the coolest new changes is the Preview Tab. Essentially it allows you to look at a preview of a file and decide if you want that file to be opened up in the tab well. I’ll show much more on this feature later but wanted to mention it here to round out the list of items I will be covering in the short-term.

Finally

There are a lot of very cool changes coming in Visual Studio vNext. This post is meant to make you aware of the coming changes at a high-level to prepare you for a deeper discussion of each of these features in future posts.

Now Shipping! Coding Faster: Getting More Productive with Visual Studio (Covers Microsoft Visual Studio 2005, 2008, and 2010)

zainnab — Tue, 30 Aug 2011 08:00:00 GMT

At long last it is with great pride that I can officially announce the availability our new book! After a year of work and a few interesting speed bumps along the way the book is now in stores world-wide. If you want the best price that I have seen so far, I suggest you go to Amazon:

http://www.amazon.com/gp/product/0735649928

If you get a copy of the book, Sara and I would love to hear what you think about it and any improvements you would like to see in the next revision. You can email me at zainnab@microsoft.com with your comments / suggestions / etc.. Also, if you get a chance, please make sure to give a review on Amazon and/or the O’Reilly web site so others will know if they should buy the book or not.

For those who aren’t regular readers of this blog, here is the basic information from the main O’Reilly book site:

Description

Take a detailed look into Visual Studio—and learn practical techniques to help you work more efficiently. This fully revised and expanded version of Visual Studio Tips: 251 Ways to Improve Your Productivity includes a comprehensive collection of tips and shortcuts for working with the code editor, visual designers, searches, debugger, and other features in Visual Studio 2005, 2008, and 2010.

Expert advice to help you work smarter and increase your productivity with Visual Studio.

Discover how to:

Change development settings and keyboard mappings to optimize your efficiency
Save time initiating a new project by creating custom templates
Uncover secrets for working with the toolbox, commands, and window layouts
Work with files in more practical ways, such as using the File Tab Channel
Use the Editor more effectively with tips on selecting and manipulating code
Apply techniques to help reduce the time you spend debugging code
Create Visual Studio extensions to increase your development productivity

Acknowledgements

I thought it would be appropriate to list the acknowledgements for the book here again to thank those who had an impact on our lives and on the book:

Jane and Louie Smolensky / Beulah Bourgeois / Annabelle Fayard / Helen Naboulsi / Russell Chandler—Our immediate friends and family.

Russell Jones and Adam Zaremba—Editors at O’Reilly Media, who herded the cats to make
this book happen.

Kevin Stevens—Who came up with the name of the book and was instrumental in the
technical review process.

Paul Millsaps and Bill Needels—For doing some of the technical review for the book.

Sean Laberee—Senior Program Manager Lead at Microsoft who helped both Sara and me
get started with Tips and Tricks.

Dustin Campbell—Program Manager at Microsoft who continues to be a constant source of
information when I get stuck on a feature or concept.

Brittany Behrens—Program Manager at Microsoft who helped me during those first tenuous
days after I took over Sara’s work.

Matt Manela—for writing the content for the Snippet Designer extension.

Andrew Steele—for writing the content for the Productivity Power Tools extension.

Jim Christopher—for writing the content for both the GhostDoc and the StudioShell
extensions.

Terry Leeper—Principal Architect, Windows C++ Team, my main contact with the C++ folks
and a good friend that has helped me resolve questions about features since I started doing
the tips.

Lisa Feigenbaum and Beth Massi—Program Managers at Microsoft who constantly provided
guidance and support as the content of the book evolved.

Brian Moore—Director, DPE Central Region, for providing support and being a great manager.

Clint Edmonson—Senior Architect Evangelist at Microsoft who I have toured with throughout
the country delivering Visual Studio talks to thousands of people.

Phil Wheat—My best friend at Microsoft and a constant source of information. Phil is easily
the smartest person I know.

Jared Bienz, Mike Azocar—Very good friends who have been great to bounce ideas around
as I worked on the book.

Rob Bagby, Mike Benkovich, John Weston, Keith Combs—My old Microsoft Across America
buddies.

Finally, Sara Ford wishes to thank Dr. Terrance Delaney and Dr. Michael McMurray for fixing
her chronic shin splints during the course of writing this book.

Static Code Analysis – Understanding the Predefined Rules

zainnab — Thu, 25 Aug 2011 08:00:00 GMT

SKU: Premium, Ultimate

Versions: 2010

Code: vstipTool0140

In vstipTool139 (“Static Code Analysis – Simple Code Analysis”) we scratched the surface of code analysis for a simple class. Now we will begin to delve deeper into the extensive set of predefined rules available out-of-the-box in Visual Studio. In these examples I will be using Visual Studio 2010 however most of the rules exist in Visual Studio 2008 as well. To see the list of the differences in rules read this article from the Code Analysis Team blog:

http://blogs.msdn.com/b/codeanalysis/archive/2010/03/22/what-s-new-in-code-analysis-for-visual-studio-2010.aspx

The biggest difference between Visual Studio 2008 and 2010 is the creation and management of rule sets which is why I have the version set to 2010 only. The new way to manage rules makes it very easy to work with existing rules in a multitude of ways. Also, I am limiting myself to managed code rules for these examples but the same techniques apply to unmanaged code rules as well. Without further ado, let’s explore some of the ways we can work with predefined rules.

First, create a new class library project in C# or VB then go to the project properties. Click on the Code Analysis tab inside the project properties. You should see the following:

The first choice you are faced with is which set of predefined rules to use. By default the Microsoft Minimum Recommended Rules will be applied however if you click on the dropdown list for the rule sets you will see many more options to choose from:

This table lays out the names and general purpose of each of the available managed predefined rule sets:

Rule Set	Description
Microsoft All Rules	This rule set contains all rules. If you run this rule set, a large number of warnings might be reported. Use this rule set to get a comprehensive picture of all issues in your code. This approach can help you decide which of the more focused rule sets are most appropriate to run for your projects.
Microsoft Basic Correctness Rules	These rules focus on logic errors and common mistakes made in the usage of framework APIs. Include this rule set to expand on the list of warnings that the minimum recommended rules report.
Microsoft Basic Design Guideline Rules	These rules focus on enforcing best practices to make your code easy to understand and use. Include this rule set if your project includes library code or if you want to enforce best practices for easily maintainable code.
Microsoft Extended Correctness Rules	These rules expand on the basic correctness rules to maximize the number of logic and framework usage errors that are reported. These rules emphasize specific scenarios such as COM interoperability and mobile applications. Consider including this rule set if one of these scenarios applies to your project or to find additional problems in your project.
Microsoft Extended Design Guideline Rules	These rules expand on the basic design guideline rules to maximize the number of usability and maintainability issues that are reported. These rules emphasize naming guidelines. Consider including this rule set if your project includes library code or if you want to enforce the highest standards for writing maintainable code.
Microsoft Globalization Rules	These rules focus on problems that prevent data in your application from appearing correctly in different languages, locales, and cultures. Include this rule set if your application is localized, globalized or both.
Microsoft Minimum Recommended Rules	These rules focus on the most critical problems in your code, including potential security holes, application crashes, and other important logic and design errors. You should include this rule set in any custom rule set that you create for your projects.
Microsoft Security Rules	This rule set contains all Microsoft security rules. Include this rule set to maximize the number of potential security issues that are reported.

Note: You can find this table in the documentation at http://msdn.microsoft.com/en-us/library/dd264925(VS.100).aspx

At a high level the rules deal with correctness, design, globalization, and security issues. Since we are creating a class library it might make sense for us to use the design guidelines based on the description. Pick the Microsoft Extended Design Guideline Rules for our project then click the Open button so we can explore the details:

NOTE: Keep one thing in mind as you explore these rules: there is no “one size fits all” solution. Your final rule set will almost always consist of several other rules that you feel are best for your needs.

We’ll get to the inner workings of this editor in a later post but, for now, focus on the ID column. Take note of the various categories we can expand to get details. Below is a list of these categories and what they represent:

Category	Description
Design Warnings	Warnings that support correct library design as specified by the .NET Framework Design Guidelines.
Globalization Warnings	Warnings that support world-ready libraries and applications.
Interoperability Warnings	Warnings that support interaction with COM clients.
Maintainability Warnings	Warnings that support library and application maintenance.
Mobility Warnings	Warnings that support efficient power usage.
Naming Warnings	Warnings that support adherence to the naming conventions of the .NET Framework Design Guidelines.
Performance Warnings	Warnings that support high-performance libraries and applications.
Portability Warnings	Warnings that support portability across different platforms.
Reliability Warnings	Warnings that support library and application reliability, such as correct memory and thread usage.
Security Warnings	Warnings that support safer libraries and applications.
Usage Warnings	Warnings that support appropriate usage of the .NET Framework.

Note: You can find this table in the documentation at http://msdn.microsoft.com/en-us/library/ee1hzekz.aspx

The number of rules you deal with in each category depends on the rule set you have chosen. For example, the extended design rule set has about 60 design rules, 2 globalization rules, and 7 interoperability rules among the other rules in this set:

By now you have no doubt noticed the warning just below the toolbar in this editor. You are just exploring the rules for now but when we modify the rules in a later tip you will have to save your changes to a new rule set file. Don’t be intimidated by rule set files, they are just XML files. Here is a piece of the extended design rule set in Notepad:

Back in our rule set editor, expand the Microsoft.Design category and select rule CA1044:

The first time you select a rule, you will be presented with this choice at the bottom of the rule set editor:

I suggest leaving the default settings and then click the OK button. When you do, you will then see the help entry for the rule you are currently looking at:

At this point we have gone from understanding the basic function of the predefined rule sets to understanding the categories of the rules in a set to understanding individual rules. From here you can explore the different rule sets and each of the rules in those sets to determine what rules may be interesting to you going forward. We will learn more about navigating these rule sets in the next tip.

Static Code Analysis (aka FxCop) – Simple Code Analysis

zainnab — Tue, 23 Aug 2011 08:00:00 GMT

SKU: Premium, Ultimate

Versions: 2008, 2010

Code: vstipTool0139

In my extensive travels with my good friend Clint Edmonson (http://www.notsotrivial.net/blog/) we found yet another feature available in Visual that seems to be underutilized: Static Code Analysis. After some digging, we discovered many people don’t realize they have this feature already and can use it anytime they want to warn of possible issues. I thought it would be instructive to start with a basic understanding of code analysis and, in a series of tips, dig into the specific implementation.

Let’s begin with a basic definition from Wikipedia on static code/program analysis:

“Static program analysis is the analysis of computer software that is performed without actually executing programs built from that software (analysis performed on executing programs is known as dynamic analysis). In most cases the analysis is performed on some version of the source code and in the other cases some form of the object code. The term is usually applied to the analysis performed by an automated tool, with human analysis being called program understanding, program comprehension or code review.”

http://en.wikipedia.org/wiki/Static_code_analysis

Essentially, we have a set of rules that we use to examine our code and see if there are any issues that arise. Static code analysis is a great way to avoid common pitfalls in your code. Not only can you use a set of predefined rule sets but you can make your own rule sets from existing rules and even create custom rules specific to your needs.

Given the complexity of this topic the best way to learn is by doing. So let’s go through a simple example using code analysis. First, create a new C# class library project (give it any name you want) and then create a method as I have done here:

By default, projects are set to use the Microsoft Minimum Recommended Rules set which essentially does what is says and ensures the bare minimum set of rules are applied when used. I’ll get into the details of what those rules are in later tips but, for now, let’s see if there are any issues that crop up with this small set of rules. Right-click your project in Solution Explorer and choose Run Code Analysis:

Problems will show up in your Error List window as errors or warnings. Notice we have neither in this case which shows that there aren’t any violations with the minimal rule set. Now let’s go to the other extreme and apply the strictest rule set possible. Go into your project properties and click the Code Analysis tab:

Notice the Rule Set area? Click the drop-down list under Run This Rule Set to see the list of rules that are available and select Microsoft All Rules from the list:

Note the description for this rule set:

This will produce the largest amount of noise in your Error List window so be warned. I only suggest using this rule set as a way to find out what rules apply to certain areas of your code. To my knowledge only internal Microsoft developers are regularly required to use this level of strictness.

Now that you are using this new rule set, right-click your project in Solution Explorer and run code analysis again. Notice we now get some warnings that we can address:

You are welcome to explore these warnings on your own to get more detail. Just click any warning and press F1 to get help on it. Right now I am just interested in the last one in the list called CA1801. It’s definitely telling us we need to either use the parameter for the method or remove it. We could correct the issue:

Then rerun code analysis to make sure it passes the check:

At this point you have just enough information to scratch the surface of code analysis. We will continue to dig deeper into this amazing feature over the next few tips.

Code Metrics: Working with Columns

zainnab — Thu, 18 Aug 2011 08:00:00 GMT

Windows: Alt, V, M (press several times), Enter

Menu: View | Other Windows | Code Metrics Results

Command: View.CodeMetricsResults

SKU: Premium, Ultimate

Versions: 2008, 2010

Languages: C++ (managed only), C#, VB

Code: vstipTool0138

The last top on our tour of the Code Metrics Results window is how to work with columns. Sadly the tool window is surprisingly lacking in some features we see in other windows. Let’s take a look at some of the features when working with columns.

Adding or Removing Columns

Choosing the columns you want is really easy. Just use the Add/Remove Columns button:

Or right-click anywhere in the window and choose Add/Remove Columns:

You get a dialog that allows you to select the columns you want to be visible:

Sorting

You can sort by any column by clicking on the column header which gives an indicator for ascending or descending sorts respectively:

Unfortunately, you can’t do multicolumn sorting in this window but hopefully it will be added at a later date. Also, you can’t rearrange the column order in this window.

Code Metrics – Creating Work Items from Code Metrics Results

zainnab — Tue, 16 Aug 2011 08:00:00 GMT

Windows: Alt, V, M (press several times), Enter

Menu: View | Other Windows | Code Metrics Results

Command: View.CodeMetricsResults

SKU: Premium, Ultimate

Versions: 2008, 2010

Languages: C++ (managed only), C#, VB

Code: vstipTool0137

NOTE: This tip requires that you are connected to a Team Foundation Server (TFS) for source control. You can learn more about TFS here:

http://www.microsoft.com/visualstudio/en-us/products/2010-editions/team-foundation-server/overview

When you are working with code metrics, you typically don’t have time to stop and redo every issue right away. You can create work items in the Code Metrics Results window to file issues away to be reworked later. First, locate an item that you feel needs attention and right-click it:

As you can see there are a lot of options here that you can use. For our purposes we will just create a new issue:

Visual Studio will automatically fill on some data and let you fill in other information as needed:

When you are done you can save and close the work item then continue examining the rest of the code metrics results.

Code Metrics: Code Metrics Results Exporting

zainnab — Thu, 11 Aug 2011 08:00:00 GMT

Windows: Alt, V, M (press several times), Enter

Menu: View | Other Windows | Code Metrics Results

Command: View.CodeMetricsResults

SKU: Premium, Ultimate

Versions: 2008, 2010

Languages: C++ (managed only), C#, VB

Code: vstipTool0136

Previously I showed you how to filter your code metrics results. Now let’s look at how to export your results to Excel for deeper analysis. First, you need to calculate your results:

Now, click on the button with the Excel icon on the Code Metrics Results toolbar that is used to export our results:

Once exported, you will have a new Excel workbook with all your data on Sheet 1:

Clearly your ability to use Excel comes into play here. All the data is available for you to manipulate as you see fit. I suggest paying particular attention to the filtering and sorting options that are available as you work with the information:

Code Metrics – Code Metrics Results Filtering

zainnab — Tue, 09 Aug 2011 15:10:36 GMT

Windows: Alt, V, M (press several times), Enter

Menu: View | Other Windows | Code Metrics Results

Command: View.CodeMetricsResults

SKU: Premium, Ultimate

Versions: 2008, 2010

Languages: C++ (managed only), C#, VB

Code: vstipTool0135

Having explored code metrics in great detail in the previous posts (see the article on Cyclomatic Complexity that started the series here: http://blogs.msdn.com/b/zainnab/archive/2011/05/17/code-metrics-cyclomatic-complexity.aspx) we can now turn our attention to the Code Metrics Results window. One of the first activities you will probably use it for is to calculate the code metrics for your solution:

Once metrics have been calculated there are several options available to you to work with the code metrics. Chief among the various actions is filtering. Using a filter, you can narrow down the metric you are interested in. For this example, I’ll choose Class Coupling:

Once I choose the metric to filter by then the Min and Max combo boxes are enabled so I can choose my filtering criteria:

Here is an example of some data before I apply a filter:

And after I apply a filter with a minimum of 3:

As you can see the members of DeliveryMethod have been reduced to show only those that match the current criteria. Also, whenever you apply criteria, the last ten filters (at the end of the list, indented) used are available in the Code Metrics window regardless of the project or solution:

When Visual Studio is closed the ten most recently used filter criteria are written to the registry at
HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\<version>\EnterpriseTools\CodeMetrics

WARNING: Make changes to the registry at your own risk.

A string value called MRUList is created that contains the filter information:

There isn’t any way to clear this list that I am aware of so occasionally I’ll just delete the MRUList value from the registry when I want the list to go away. Visual Studio will automatically create a new value once you start making new criteria.

FY12 Plans and The Almost Nearly Last Book Update for Now

zainnab — Wed, 03 Aug 2011 14:21:20 GMT

Well folks, vacation is over for most of us and it’s time to get back to work. As most of you know I took a “blogcation” to spend some time finishing up the book (more on that later) and we were successful. Beginning next week the posts start up again and I’m thinking of taking another swing at videos when vNext comes out. I’m not sure how much you know about Microsoft but our fiscal year runs from July-June. We are in the early stages of our FY12 and, today, we are finalizing commitments for the year, etc… This year, in the interest of transparency, I am considering sharing some of the commitments with all of you. I’m not sure if that is interesting or just boring so I’ll experiment and adjust based on your feedback.

Now on to the book. This is a tough one for me. I’ve never kept anything back from you all when it comes to the book and, I have to admit, I was seriously considering it recently. Sometimes you just want to eat the sausage not see how it is made. But you have been with me every step of the way whether it was pointing out technical errors in the content, helping with the title of the book, or just letting me vent to some of you privately. It goes against my nature and the spirit of this blog to keep things in the dark so here is what is happening with the book:

The book is scheduled to (finally) be on shelves just before the BUILD conference (http://www.buildwindows.com/). Sara and I will actually be doing a book signing at the event and we are pretty pumped up about it. With that said we seem to have overcome some of the delays that occurred and are on track to actually have the book out this time. The single biggest issue to cause the delay was a problem the publisher missed that required Sara and I to reshoot every image in the book (about 2000 images). Not fun. If that was all it might have not been so bad but there were some formatting changes that were also missed by the publisher that needed adjusting. We managed to get all the issues corrected and have just finished QC1 which means there is only one more set of minor edits (QC2) until we go to print. In book writing, as in life, nobody gets everything they want and this book was no exception. I had to sacrifice my beloved tables in favor of a more simplified format for the summary information this time around. As it stands now there are no serious impediments to getting the book on the shelves as planned.

So…The blog posts are starting up again, the new year for Microsoft is beginning, and the book will be out before BUILD. All in all it looks like it was a productive (although somewhat frustrating) Summer and everything is back on track. I want to add a special thanks to everyone for being so patient and appreciate all the support folks have been giving as we work through all the weirdness with the book.

Zain

Meeting New Business Challenges with Dynamic Quality Assurance – Testing is Your Friend

zainnab — Sun, 10 Jul 2011 16:30:59 GMT

My buddy Clint Edmonson and I spent a lot of time on the road last year and one of the people we had the best time hanging out with was Angela Dugan from the Chicago area. She has done a most excellent talk on Visual Studio Testing Tools recently that was caught on video. I thought I would share with you all as you will definitely see more of this type of stuff on the blog going forward.

http://mediasite01a.mfldclin.edu/mediasite/SilverlightPlayer/Default.aspx?peid=88ed071716d4485dbf5808dc311e80e41d