Visual Studio .

NET Tips and Tricks

Provided by: Dan Haught, FMS Executive Vice President

Use Comments To Flag Bugs and Undone Items

You have probably seen the Task List toolwindow in Visual Studio .NET. This window
shows you a number of useful things including any known compile errors in your
code. But did you know it will also show you all your bugs and undone items? Well, it
doesn’t actually do this automatically, but it gives you a truly useful mechanism for
tracking these items.

Whenever you are typing code and you know that you are about to leave something
undone, simply type in a comment that starts with ‘undone’. When you do this,
Visual Studio .NET can show all your undone items in the Task List toolwindow. There
is one trick here: by default, the Task List is filtered to not show Comment items. To
fix this, simply right-click on the task list window, and select Show Tasks, and check
the Comments box. Better yet, select all so you can always see all tasks.

For example, of you put in the following comment:

Your Task List now shows the Undone comment, along with the line and column
where it exists. Simply click on the item in the Task List and the code editor
automatically goes to that location.

But you can do more than just flag undone items. Visual Studio .NET comes with four
default “tokens” you can use in your comments, including HACK, TODO, UNDONE
and BUG. And you can add your own items to the list. To access these tokens, select
Tools, Options, Environment, Task List.

The really truly useful part comes when you are done with a milestone on your
project. You now need to review all the potential bugs and undone items. In the
past, you would have gone scrambling for your yellow pad, or a notepad file (if you
had the foresight to keep a list of items manually!). But with Visual Studio .NET, you
simply open your Task List and click through all the items.

Use Regions

A truly nifty feature of the Visual Studio .NET code editor is the concept of regions.
You can create named regions directly in your source code. You can then expand and
collapse regions in the editor to hide or show code based on its type. For example,
you could create a region called “Public Properties” and put all your property code
there. Additional regions could support your public methods, and privates. Using
regions is easy: simply type the #Region phrase followed by the name for your
region, as in:

You can now expand and collapse the region by clicking on the +/- icons on the
right. You can also use the keyboard to expand and collapse regions. Try Ctrl-M, M
and Ctrl-M, L.

Use the Toolbox to Store Code Snippets

How about this? Highlight some code in the code editor. Drag the code on to the
toolbox. Lo and behold, you now have a snippet of code saved. You can drag that
snippet from the toolbox back on to the code editor window in any place and you
code snippet is automatically inserted.

To make this feature truly useful (and to avoid cluttering up your default toolbox
tabs) consider creating one or more tabs just to hold snippets. To do this, right-click
on the toolbox and select Add Tab. Create a new tab and give it name to describe
the type of snippet, and then drag snippets on that tab. I spent an hour or so
spelunking through my local disk trying to find where Visual Studio .NET stores these
items, but to no avail. Perhaps they are in some mystery binary blob, or hidden deep
in the registry encoded as GUIDs. Or perhaps, they are sent off as SOAP packets to
that mysterious internet “cloud” Bill Gates keeps talking about. Regardless, I would
hardly use this feature as an industrial strength code repository. (What happens
when you re-install Visual Studio .NET or move to another computer? Where do your
snippets go?)

Finally, remember that all code repositories are potential bug factories. If you paste
in buggy code and re-use it, you are cloning bugs. And this inevitably leads to
fascinating new strains and variants of defects which are likely to be un-fixable.

Control Minus Takes You Back

I was programming in Visual Studio .NET for over 6 months before I discovered this
one, and it is one of the most useful navigation keys there is. To “Go Back” (in other
words, return to the previous position before you navigated away) simply press Ctrl-
Minus. This works across windows, and the navigation buffer appears to be limitless,
so this is a great replacement for the old VB Ctrl-Shift-F2.

Dock the Class View to the Left of Code

Call me slow, but after a class I’m writing reaches over 100 properties and methods,
I can no longer get a quick handle on how it works. Although using Regions in code
makes code expandable and collapsible, that can only go so far. One neat trick I’ve
found is to dock the Class View toolwindow directly to the left of my code window.
The Class View then acts as a table of contents for me as I work on the code.
Use Folders to Organize Complex Solutions

If your solution View tab is becoming hard to manage because your solution has too
many projects and items, consider creating folders to group items. To do this, right-
click in the Solution Explorer and select Add, New Folder. You can create folders to
hold user controls, HTML pages, resources, and other items. This makes navigating
through a complex project much easier. You can even drag existing items into new
folders which makes reorganizing existing projects much easier.

Use Full Screen Mode to Battle Dense Code

When you are working with lots of code and need to see as much as possible, or are
designing a particularly large form, switch in to FullScreen mode. To do this, select
View, Full Screen from the menu, or press Shift-Alt-Enter. FullScreen mode gives full
screen real estate to the current design window by hiding all the toolwindows and
command bars. Shift-Alt-Enter again and you’re back in regular view.

Get a Bigger Monitor

Visual Studio.NET is a festival of toolbars, menus, toolwindows, and editors. To use

the IDE to its fullest potential, you really should consider working at a minimum
resolution of 1280x1024. And 1600x1200 is ideal. The obvious problem with these
resolutions is that text can be hard to see. Hence, you need a bigger monitor. 19
inch monitors are now cheap enough that you owe it to yourself to upgrade if you
haven’t already done so. Increased productivity and coding skills are sure to follow.

Go To Definition (With the Keyboard)

Yet another keystroke that evaded me for the first six months of .NET development:
Go To Definition. In the code editor, it is easy to right-click on a name and select Go
To Definition, but the keystroke eluded me. Here it is. It is F12. There are hundreds
of very cool key combinations in Visual Studio.NET. The best guide to these is the
online help topic:

Visual Studio Shortcut Keys

Zoom HTML Windows (like Visual Studio .NET Help for

Instance)

All Visual Studio.NET help is in HTML format. That means when you view help, you
are using Internet Explorer. Did you know you can change the text size on the fly to
help read those particularly dense code examples? The five cent way is to right-click
on the help window, and select Text Size. You can then select one of six preset text
sizes. But did you know that if you have a Microsoft Mouse with a wheel, you can use
the wheel? Simply click anywhere in the help window, hold down the Shift key, and
wheel away. You can zoom in and out with this handy feature.

Hidden Power of the “Find” toolbar dropdown

You probably never noticed it before, but the innocuous little Find dropdown on the
toolbar is actually a fully function command window.

Click on the box and type the > character. Now you are in command mode. Type in
any valid Visual Studio .NET command alias and press Enter. What is a Command
Alias you ask? You can find a complete list of pre-defined aliases in the following
Visual Stduio .NET help topic:

Pre-defined Visual Studio Command Aliases

Resize Windows Forms Controls with the Mouse

If you are like me, after about seven cups of coffee, your hands shake way to bad to
use the mouse to do minute sizing and positioning of controls. Here’s a tip: use the
keyboard instead. Simply highlight the control, and use Ctrl-Left/Right and Ctrl-
Up/Down to resize. Of course, this isn’t new to Visual Studio .NET (You could do this
in VB 6, at least I think you could), but it bears repeating.

Use Keyboard Mapping Schemes

If you are coming to Visual Studio .NET from another Microsoft IDE such as Visual
Basic of VC++, you may find that the default key mappings are way to foreign for
you to be productive. Although you have the chance to set default key mappings on
the Start Page when Visual Studio .NET runs for the first time, you may want to
change them as you work on a different machine. To do this, go to Tools, Options,
Environment, Keyboard and select the scheme that most closely matches what you
are used to. You can also use this dialog to map keys to commands.

Make Visual Studio .NET a bit Snappier

Depending on your hardware, Visual Studio .NET may seem a bit sluggish compared
to previous Microsoft IDEs. Here are two simple tips to make things appear a bit
quicker. First, turn off that awful Dynamic Help window. When open, it steals cycles
as it tries to determine which inappropriate help topics to display based on where the
mouse currently is. Second, go to Tools, Options, Environment, General and turn off
the Animate Environment Tools option. This option causes un-pinned toolwindows to
fold in slowly. Who need’s that? When you’re three days past your deadline, you
have 200 unsolved bugs, and there is too little blood in your caffeine system, that
last thing you need is slow window paint effects.

Build Code Comment Web Pages

C# has the ability to be somewhat self-documenting through the use of XML

Comments. You can type XML comments into your code and the Visual Studio .NET
Build Code Comment Web Pages command can extract those comments, along with
information from the code itself to generate basic documentation web pages. For
example, if you typed the following comments before your button1_Click member:

You then generate Comment Web Pages, and you see the following entry:
C++ has limited support for this feature, and Visual Studio .Net has no support for
XML Comments. However, with Visual Studio .Net, you can still Build Code Comment
Web Pages albeit without much information.

Visual Basic .NET Shows You Errors as you Type

Visual Basic .NET has a background compiler that compiles your code as you type. A
huge benefit of this technology is that Visual Studio .NET can show you compiler
errors as you type. This benefit is truly wonderful when you remember the old Visual
Basic debug cycle: compile, hit the first error, respond to the message box, fix the
error, compile, and start again. With Visual Basic .NET, you can see compiler errors
right way.

Compiler errors are shown as a squiggly underline in your code. The default color for
this squiggly is blue, but I like compiler errors to be really noticeable. Mine show up
in red (you can change this in Tools, Options, Fonts and Colors. The real interesting
part happens when you hover your mouse over the offending code: it shows a tool
tip explaining the error.

You can also see all compile errors in the Task List toolwindow as you type.