Read pretty much anything this guy writes,
Learn SOLID, and lern it güd. I recommend starting here.
and
Let me know if you have any questions and let’s chat.

If you’re anything like me, you’ll find yourself up until 4 AM reading, reading, and reading as you link from post to post and article to article. I swear one of these days I will find the end of the internet.

Maybe.

Certainly there are a lot of new twitter client apps being made, some with lofty aspirations, but more importantly I see a twitter client as the new "Hello World" for desktop applications. And I think it’s a great choice. The days of a Hello World application consisting of a Console.WriteLine are long past. To dig in and learn something new, you have to implement something with at least a little substance to it.

A twitter client has the key components one needs when learning a new technology:

Simple

In terms of base functionality, a twitter client has a very simple task. Heck, Twitter itself is built around the simple premise of asking "What are you doing right now?" and letting you answer. A twitter client, at it’s core, needs to do two things: display your timeline and let you update your "status". Simple as that.

Easy and intuitive API

Twitter’s API is easy. Really easy. When you’re writing a real-world Hello World application, you want to focus on what you’re trying to learn, which is the technology, and not a complex API or other things that simply distract.

Options

Like most applications that have a user interface (and even those that don’t), there’s always room for choices. Depending on what you’re trying to learn (I’m a UI guy) you have different approaches you can take. If you’re learning WinForms or WPF, you can play with different presentation models, learning how to accomplish what you want. If you’re learning deeper back-end programming, you could play with the windows services APIs, or WCF, or whatever. It’s flexible.

Room for expansion

A twitter client can move beyond the basics I mentioned above and incorporate more features, with the limit practically being your imagination. Just look at twittervision.

My friend Mike has been diving head first into .NET (he’s an MFC guru), and decided to create a great twitter client (Bitter) not to create the ultimate one, but to learn the technology. Which is good, because an ultimate twitter client has already been created. It’s called Twitterific.

I can’t keep up!

Wow, that was liberating! I think I should start a taxi service for developers.

There is so much going on in the world of software, how can I keep up with it all, while still making progress in my job? I can’t shift with the winds of what’s new or popular–even if it makes sense–they just shift too fast, it seems, and there’s no way I can be productive at work and keep up with all the new stuff. Goodness knows I try.

Here’s a list of things/buzzwords I really want to learn or use but haven’t had the time, or more importantly, haven’t had a real project that I could practice on. Growing in your software development abilities and experience relies on mentoring and apprenticing, after all. I wholeheartedly believe that. That’s why I work to surround myself with incredible people.

1. TDD – Test Driven Development
For a while now I’ve been at the point where I see the great benefits to TDD, and would love to do it, I just don’t know where to start. I need to really learn it. And by learn, I mean "be mentored". I can read about it, but implementing it on a project takes it to a ‘hole nutha level‘. And if I don’t know what I’m doing, I can’t implement it on a real project at work.

2. DDD – Domain Driven Design
This is a tough one, as it’s not really a technology or methodology, but more of a way of thinking. Which always makes me wonder: am I thinking this way? Should I be, if I’m not? How can I apply this way of thinking to my projects, considering that in many cases I’m adding features to existing products that haven’t necessarily been designed this way?

3. BDD – Behavior Driven Development
No comment. I think I just need one or two more xDD acronyms to investigate.

4. DI/IoC – Dependency Injection/Inversion of Control
This feels pretty basic, and I understand the concepts and at least grok the list of available frameworks. But in my experience it’s an architectural decision that if you don’t make from the start of an enterprise project, well, good luck getting it in later without a significant effort. And doing this right plus learning one of the existing frameworks takes a large investment that frequently I don’t have. At the moment we’ve chosen to use CAB (and related technologies) at work for our new projects, and I’m on the learning curve for it right now. I wish I was more well-rounded.

5. ORM – Object Relational Mapping
Basic stuff, right? Not for me. I work on a real-time system, not so much a database driven one, although I have done a lot of database-related work in the past. ORM doesn’t apply to me as much right now, but if you work on anything but a real-time system you’re probably using one. I’ve been learning NHibernate lately with CodeCampServer, and it’s definitely a stretch for me. I think the real problem is combining the ORM with DDD. ASAP, PDQ. FYI.

6. AOP – Aspect Oriented Programming
Another "nice to learn" idea, but I have trouble making time to learn it, not to mention how to apply it.

7. A bunch of stuff from this list (though not nearly everything)
Stuff like refactoring (specifically how to apply it successfully to large projects), proper and structured integration of LINQ and dynamic languages (if at all), what I’ll call "reasonable agile" — non-extreme agile practices, visual modeling/model-driven design, evolving architectures, etc.

You might notice that some of these things on my list aren’t exactly new or groundbreaking. This is a confession, after all. Would it be confessing to say that I don’t know much about Astoria? Nah, most people don’t. So… does anybody else struggle to learn and incorporate stuff like this? What about those who don’t? Got any suggestions for me, and people like me? What are some good sources that a random developer on the Internet can find for being mentored in practices like TDD?

* Disclaimer: I have to limit the term "software developer" to what I am: a non-consultant, full-time developer leading a team of 8 (within a dev organization of 130+) working on a mature and complex product with a release cycle of 12-18 months, and handling escalated support cases–you can’t not mention support! Oh, and I have a family and a life.

Unfortunately all of these tools are restricted in one normally insignificant way: they only operate on the currently loaded project(s). For most software this really is insignificant. The entire application can be loaded into the IDE all at once. Sometimes, though, it is a problem–usually when there’s another problem at play: code "bloat" (via Jeff).

If you’ve ever changed a namespace and wanted to simply push the change into every code file in an entire directory branch, PowerShell comes to our rescue with it’s search-and-replace capabilities. I wrote the following "Move-Namespace" function to do just that.

Invoke the function like so: "Move-Namespace *.cs "[current namespace]" "[current class name]" "[new namespace]".

After it completes, any explicit reference will be changed, and any implicit references (using traditional "using [namespace];" statements) will have a new "using [new namespace];" line inserted after the last existing using statement.

Let’s hope you don’t have a code base that requires this function. But if you do, I hope it helps!

Note that this function relies on my "Replace-String" function, found here.

function Move-Namespace(
    $includes = $(throw 'Specify a file filter to use'),
    $oldNamespace = $(throw 'The namespace to replace - i.e. MyCompany.Product'),
    $className = $(throw 'The class name to search for - i.e. MyClass'),
    $newNamespace = $(throw 'The new namespace to add - i.e. MyCompany.Product.Feature'))
{
    # Look for cases of $className
    # or $oldNamespace.$className
    # and replace as necessary

    # First check for assumed "using" statements, and add the using statement
    $results = @{}
    $files = get-childitem -r -i $includes | select-string "(?<!$oldNamespace\.)\b$className\b" -list |% { $_.Path }
    select-string "^using.*;" -path $files | group-object Path | select-object Name, @{Expression={ ($_.Group | measure-object -property LineNumber -max).Maximum }; Name="LastUsingStatement" } |% { $results[$_.Name] = $_.LastUsingStatement }
    foreach ($key in $results.keys)
    {
      $processFile = $true
      $lastUsingIndex = $results[$key]
      $fileContents = get-content $key
      # look for existing using statement and cancel processing this file
      for ($i = 0; $i -lt $lastUsingIndex; $i++)
      {
        if ($fileContents[$i] -match "using $newNamespace;")
        {
          # this file already has the correct using statement, stop processing
          Write-Warning "File $key already has the required using statement, ignoring"
          $processFile = $false
          break;
        }
      }

      if ($processFile)
      {
        $newContents = $fileContents[0..($lastUsingIndex-1)] + "using $newNamespace;" + $fileContents[$lastUsingIndex..$fileContents.Length]
        set-content -path $key -value $newContents
        Write-Host "Successfully updated file $key" -foregroundcolor Green
      }
    }

    # Next check for explicit references
    replace-string "\b$oldNamespace\.$className\b" "$newNamespace.$className" $includes
}

I can’t decide whether this post should be categorized as a tip/trick or a warning, though. It’s both, probably.

In many development environments you won’t care – if you upgrade to Visual Studio 2008 then your build environment is upgraded also. But in some places, such as my company, we have large code bases that span many different technologies, and we have a specially created build system to handle all that. It uses specific compilers – VS7.1 for C++, for example, and the .NET 2.0 SDK compiler for C#.

You can use Visual Studio 2008 for Visual Studio 2005 project files, and with multi-targeting, you can use it in a .NET 2.0 environment. So, back to me as an example, I can transparently use VS2008 as my new IDE of choice – on my local machine. That means when I build from VS2008 locally, the new C# 3.0 language features will work seamlessly, but will fail when our automated builds pick up my changes.

Thus the warning – if you’re not careful (if you’re on “autopilot”) you can write code that will compile in the IDE but not with an SDK.

So, use VS2008, and be careful.
In my case, I always build from the command line anyway – that way I know that what I check in will build everywhere.

I did have a note to myself to get the .NET 3.5 SDK integrated into our build system, but I see that a stand-alone version doesn’t exist – it’s being rolled into the Windows SDK which would have far too wide an impact. <sigh>

Once I got my ducks in a row (by perusing the MSDN documentation on the Win32 edit control, which is the foundation of the .NET TextBox anyway) I found a few resources online, but they either a) didn’t wrap the exact Win32 edit control behavior, or b) were just a one-off “send a message to the control like this”, when I’d prefer a more polished derived control with designer support, etc.

So I present CueTextBox.cs, CueComboBox.cs, and CueToolStripTextBox.cs. Here’s a simple example that hosts all 3 of them:

And, in the interest of making this as easy as possible to get, here is the code. It’s really a very simple extension – I’m not sure why this wasn’t included in the BCF (but I can guess: this will only work on Windows XP and higher, and only if visual styles are enabled).
Note that the downloaded versions have the license text, but I’ve left it off this page (the license from the downloaded files applies). Why do you care? Let Jeff Atwood tell you.

CueTextbox.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Runtime.InteropServices;

namespace Lerch.Samples
{
    public class CueTextBox : TextBox
    {
        #region PInvoke Helpers

        private static uint ECM_FIRST = 0x1500;
        private static uint EM_SETCUEBANNER = ECM_FIRST + 1;

        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = false)]
        private static extern IntPtr SendMessage(HandleRef hWnd, uint Msg, IntPtr wParam, String lParam);

        #endregion PInvoke Helpers

        #region CueText

        private string _cueText = String.Empty;

        /// <summary>
        /// Gets or sets the text the <see cref="TextBox"/> will display as a cue to the user.
        /// </summary>
        [Description("The text value to be displayed as a cue to the user.")]
        [Category("Appearance")]
        [DefaultValue("")]
        [Localizable(true)]
        public string CueText
        {
            get { return _cueText; }
            set
            {
                if (value == null)
                {
                    value = String.Empty;
                }

                if (!_cueText.Equals(value, StringComparison.CurrentCulture))
                {
                    _cueText = value;
                    UpdateCue();
                    OnCueTextChanged(EventArgs.Empty);
                }
            }
        }

        /// <summary>
        /// Occurs when the <see cref="CueText"/> property value changes.
        /// </summary>
        public event EventHandler CueTextChanged;

        [EditorBrowsable(EditorBrowsableState.Advanced)]
        protected virtual void OnCueTextChanged(EventArgs e)
        {
            EventHandler handler = CueTextChanged;
            if (handler != null)
            {
                handler(this, e);
            }
        }

        #endregion CueText

        #region ShowCueTextOnFocus

        private bool _showCueTextWithFocus = false;

        /// <summary>
        /// Gets or sets a value indicating whether the <see cref="TextBox"/> will display the <see cref="CueText"/>
        /// even when the control has focus.
        /// </summary>
        [Description("Indicates whether the CueText will be displayed even when the control has focus.")]
        [Category("Appearance")]
        [DefaultValue(false)]
        [Localizable(true)]
        public bool ShowCueTextWithFocus
        {
            get { return _showCueTextWithFocus; }
            set
            {
                if (_showCueTextWithFocus != value)
                {
                    _showCueTextWithFocus = value;
                    UpdateCue();
                    OnShowCueTextWithFocusChanged(EventArgs.Empty);
                }
            }
        }

        /// <summary>
        /// Occurs when the <see cref="ShowCueTextWithFocus"/> property value changes.
        /// </summary>
        public event EventHandler ShowCueTextWithFocusChanged;

        [EditorBrowsable(EditorBrowsableState.Advanced)]
        protected virtual void OnShowCueTextWithFocusChanged(EventArgs e)
        {
            EventHandler handler = ShowCueTextWithFocusChanged;
            if (handler != null)
            {
                handler(this, e);
            }
        }

        #endregion ShowCueTextOnFocus

        #region Overrides

        protected override void OnHandleCreated(EventArgs e)
        {
            UpdateCue();

            base.OnHandleCreated(e);
        }

        #endregion Overrides

        private void UpdateCue()
        {
            // If the handle isn't yet created, 
            // this will be called when it is created
            if (this.IsHandleCreated)
            {
                SendMessage(new HandleRef(this, this.Handle), EM_SETCUEBANNER, (_showCueTextWithFocus) ? new IntPtr(1) : IntPtr.Zero, _cueText);
            }
        }
    }
}

CueComboBox.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Runtime.InteropServices;

namespace Lerch.Samples
{
    public class CueComboBox : ComboBox
    {
        #region PInvoke Helpers

        private static uint CB_SETCUEBANNER = 0x1703;

        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = false)]
        private static extern IntPtr SendMessage(HandleRef hWnd, uint Msg, IntPtr wParam, String lParam);

        #endregion PInvoke Helpers

        #region CueText

        private string _cueText = String.Empty;

        /// <summary>
        /// Gets or sets the text the <see cref="ComboBox"/> will display as a cue to the user.
        /// </summary>
        [Description("The text value to be displayed as a cue to the user.")]
        [Category("Appearance")]
        [DefaultValue("")]
        [Localizable(true)]
        public string CueText
        {
            get { return _cueText; }
            set
            {
                if (value == null)
                {
                    value = String.Empty;
                }

                if (!_cueText.Equals(value, StringComparison.CurrentCulture))
                {
                    _cueText = value;
                    UpdateCue();
                    OnCueTextChanged(EventArgs.Empty);
                }
            }
        }

        /// <summary>
        /// Occurs when the <see cref="CueText"/> property value changes.
        /// </summary>
        public event EventHandler CueTextChanged;

        [EditorBrowsable(EditorBrowsableState.Advanced)]
        protected virtual void OnCueTextChanged(EventArgs e)
        {
            EventHandler handler = CueTextChanged;
            if (handler != null)
            {
                handler(this, e);
            }
        }

        #endregion CueText

        #region Overrides

        protected override void OnHandleCreated(EventArgs e)
        {
            UpdateCue();

            base.OnHandleCreated(e);
        }

        #endregion Overrides

        private void UpdateCue()
        {
            // If the handle isn't yet created, 
            // this will be called when it is created
            if (this.IsHandleCreated)
            {
                SendMessage(new HandleRef(this, this.Handle), CB_SETCUEBANNER, IntPtr.Zero, _cueText);
            }
        }
    }
}

CueToolStripTextBox.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Runtime.InteropServices;

namespace Lerch.Samples
{
    public class CueToolStripTextBox : ToolStripTextBox
    {
        public CueToolStripTextBox()
            : base()
        {
            if (this.Control != null)
            {
                this.Control.HandleCreated += new EventHandler(OnControlHandleCreated);
            }
        }

        public CueToolStripTextBox(string name)
            : base(name)
        {
            if (this.Control != null)
            {
                this.Control.HandleCreated += new EventHandler(OnControlHandleCreated);
            }
        }

        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (this.Control != null)
                {
                    this.Control.HandleCreated -= new EventHandler(OnControlHandleCreated);
                }
            }

            base.Dispose(disposing);
        }

        void OnControlHandleCreated(object sender, EventArgs e)
        {
            UpdateCue();
        }

        #region PInvoke Helpers

        private static uint ECM_FIRST = 0x1500;
        private static uint EM_SETCUEBANNER = ECM_FIRST + 1;

        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = false)]
        private static extern IntPtr SendMessage(HandleRef hWnd, uint Msg, IntPtr wParam, String lParam);

        #endregion PInvoke Helpers

        #region CueText

        private string _cueText = String.Empty;

        /// <summary>
        /// Gets or sets the text the <see cref="TextBox"/> will display as a cue to the user.
        /// </summary>
        [Description("The text value to be displayed as a cue to the user.")]
        [Category("Appearance")]
        [DefaultValue("")]
        [Localizable(true)]
        public string CueText
        {
            get { return _cueText; }
            set
            {
                if (value == null)
                {
                    value = String.Empty;
                }

                if (!_cueText.Equals(value, StringComparison.CurrentCulture))
                {
                    _cueText = value;
                    UpdateCue();
                    OnCueTextChanged(EventArgs.Empty);
                }
            }
        }

        /// <summary>
        /// Occurs when the <see cref="CueText"/> property value changes.
        /// </summary>
        public event EventHandler CueTextChanged;

        [EditorBrowsable(EditorBrowsableState.Advanced)]
        protected virtual void OnCueTextChanged(EventArgs e)
        {
            EventHandler handler = CueTextChanged;
            if (handler != null)
            {
                handler(this, e);
            }
        }

        #endregion CueText

        #region ShowCueTextOnFocus

        private bool _showCueTextWithFocus = false;

        /// <summary>
        /// Gets or sets a value indicating whether the <see cref="TextBox"/> will display the <see cref="CueText"/>
        /// even when the control has focus.
        /// </summary>
        [Description("Indicates whether the CueText will be displayed even when the control has focus.")]
        [Category("Appearance")]
        [DefaultValue(false)]
        [Localizable(true)]
        public bool ShowCueTextWithFocus
        {
            get { return _showCueTextWithFocus; }
            set
            {
                if (_showCueTextWithFocus != value)
                {
                    _showCueTextWithFocus = value;
                    UpdateCue();
                    OnShowCueTextWithFocusChanged(EventArgs.Empty);
                }
            }
        }

        /// <summary>
        /// Occurs when the <see cref="ShowCueTextWithFocus"/> property value changes.
        /// </summary>
        public event EventHandler ShowCueTextWithFocusChanged;

        [EditorBrowsable(EditorBrowsableState.Advanced)]
        protected virtual void OnShowCueTextWithFocusChanged(EventArgs e)
        {
            EventHandler handler = ShowCueTextWithFocusChanged;
            if (handler != null)
            {
                handler(this, e);
            }
        }

        #endregion ShowCueTextOnFocus

        private void UpdateCue()
        {
            // If the handle isn't yet created, 
            // this will be called when it is created
            if ((this.Control != null) && (this.Control.IsHandleCreated))
            {
                SendMessage(new HandleRef(this.Control, this.Control.Handle), EM_SETCUEBANNER, (_showCueTextWithFocus) ? new IntPtr(1) : IntPtr.Zero, _cueText);
            }
        }
    }
}

But I think I’ve been very wrong. A while back Jeffrey Snover posted a great “core dump” of cmdlets vs. APIs. He makes some good points, but even after reading it (back when he first posted it) I still thought that API + Cmdlet was the best approach. Experience has changed my mind. Here are, in my opinion, the most important points from his list (paraphrased).

Error handling. An API can throw exceptions, but a Cmdlet can have terminating and non-terminating errors. With Cmdlets users can easily control the behavior when a non-terminating error occurs as well as get access to the collection of troublemaker objects.

-WhatIf, -Confirm, and -Verbose support. There simply isn’t an easy way to have an API support a -WhatIf type of operation, while remaining a good API.

Pipelines and wildcards. Wildcard support needs to be implemented on a per-API basis, making it a time-consuming (and possibly difficult) task. Working with “pipelines” requires specific coding by the user of the API.

The common thread between those three points is that an API simply can’t provide those services independent of Powershell. You really can’t create an API and wrap it in a Cmdlet. (If you have a choice.) If my “Remove-Foo” Cmdlet simply wraps “foo.Delete()”, “foo.Delete()” can’t make use of advanced error handling, or conditional processing (ala “-WhatIf” or “-Confirm”), or pipeline or wildcard support.

Because applications can host a Powershell runspace, any argument for an API goes away. Your Cmdlets are an API that developers can write code against. The thing that still gets me about this, though, is the verbose code it requires to exercise a Cmdlet’s “API”. Apparently Powershell V2 is going to help simplify the runspace hosting story. Maybe that’s enough to knock the final leg out of my leaning towards an API? Once I finish my work, perhaps I’ll update the symstore SnapIn for V2 – in the meantime, I’d like to release them in a state that people could actually use them.

What sort of “fun” (not nasty!) function names do you tend to create? Or do you keep them all boring plain Jane? (Boooo!!) The way metadata is exposed in the .NET world, combined with a tool like Reflector, make function names like this more readily “available”. But still, we’ve gotta have some fun somehow!

The Problem

Even though it “seems” like a static resource, accessed via a static property, should create an instance once and only once, it’s not true. Consider adding and using an image resource – for example, a “lock” image that could be shown in the rows of a DataGridView to represent a boolean value:

One way to translate the data type of a bound object to an “expected” data type for a DataGridView column is to handle the CellFormatting event. You might be tempted to write the code to reference your strongly typed “lock” image resource like this:

private static Image _blankIcon = new Bitmap(16, 16);
private void transactionDataGridView_CellFormatting(object sender, DataGridViewCellFormattingEventArgs e)
{
    if ((e.ColumnIndex == Locked.Index)
        && (e.DesiredType == typeof(Image))
        && (e.Value is bool))
    {
        bool locked = (bool)e.Value;
        e.Value = (locked) ? Properties.Resources.LockIcon : _blankIcon;
        e.FormattingApplied = true;
    }
}

But you could very easily encounter a Win32Exception indicating that you are out of memory. Why? The short answer is that every reference to the property ends up creating a new instance of the resource. With images, movies, or sounds, that can end up using a lot of memory. Notice that the code generated for accessing the resource doesn’t perform any caching, and in fact two instances of the returned object are logically the same, but are not the same reference. The following is true: “Properties.Resources.LockIcon != Properties.Resources.LockIcon”.

internal static System.Drawing.Bitmap LockIcon {
    get {
        object obj = ResourceManager.GetObject("LockIcon", resourceCulture);
        return ((System.Drawing.Bitmap)(obj));
    }
}

The Solution

It’s simple, really, but you just have to know to do it. The only real solution is to be intelligent about accessing these resources such that as few instances as possible are created. 99% of the time that means creating a global static variable that is initialized with the resource, and all your code accesses your static variable. This can be time consuming to maintain, if you have a lot of resources, but it’s definitely worth it. The change to the CellFormatting event handler is a simple one.

private static Image _lockIcon = Properties.Resources.LockIcon;
private static Image _blankIcon = new Bitmap(16, 16);
private void transactionDataGridView_CellFormatting(object sender, DataGridViewCellFormattingEventArgs e)
{
    if ((e.ColumnIndex == Locked.Index)
        && (e.DesiredType == typeof(Image))
        && (e.Value is bool))
    {
        bool locked = (bool)e.Value;
        e.Value = (locked) ? _lockIcon : _blankIcon;
        e.FormattingApplied = true;
    }
}

One possibility that could increase maintainability is to write your own Visual Studio custom tool that generates the strongly-typed resource class (the .Designer.cs file). The custom tool could create the standard resource access code but also create a 2nd class that ends in “Cache”, for example, and manages a static reference to each resource – as mentioned in this MSDN forum post. An article on The Code Project gives an example implementation of a custom tool. I downloaded it with the intention of doing exactly what I mentioned, but there’s quite a bit of code there – and it’s a lot less trivial than I had hoped. In addition, everybody would have to install this custom tool on their own machine, and would have to manually run it on resource files. Non-optimal. Oh, and I’m lazy.

There are a couple of gotchas that have to be configured for this to work. I was scratching my head wondering why this didn’t work for me immediately, here’s why.

First, make sure the “Just My Code” setting is turned OFF in the Visual Studio settings (Tools -> Options -> Debugging). In fact, just leave this setting off all the time — it sucks.

Secondly, make sure you have a symbol path configured so you can load the appropriate symbols. You must have symbols for the “source-less” code! The symbol path/server is specified via an environment variable named “_NT_SYMBOL_PATH“. If you don’t have a symbol server configured (more on that in a later post) your environment variable will probably look like this: (see the previous link for the exact syntax)

_NT_SYMBOL_PATH = SRV*C:\Symbols*http://msdl.microsoft.com/download/symbols

You can also configure symbols from within Visual Studio in the Tools -> Options -> Debugging -> Symbols configuration:

Now, start debugging your application (have it break on the first instruction of the app). This is especially important if Visual Studio hasn’t yet pulled down the symbols from the symbol server. Bring up the breakpoint window in Visual Studio (CTRL+B) and type in enough detail for the resolver to find the method/property you’re looking for. If you want to break on a property, be sure to use the method syntax for the property: “get_[propertyname]” or “set_[propertyname]“.

Hit OK, and, if you had “Use Intellisense to verify the function name” selected, press “Yes”:

At this point, if your code calls the method or property, the debugger will break on it and take you to the Disassembly view. You can use the Call Stack window to traverse up to whatever point you care about. Notice also that in this example, “child” breakpoints were automatically set on all the overloaded methods for System.Console.WriteLine, automatically.

This is an awesome trick, one that can save you loads of time! Thanks John!