One down-side to LINQ is that, out of the box, it’s geared towards knowing your query structure at compile-time. The values can be dynamic, of course, but it’s assumed that the structure of your query is static. For example, if you want to select a set of "Person" objects from the "People" collection where Person.FirstName starts with "Aar", you could write it as such:

var results = from person in People
              where person.FirstName.StartsWith("Aar")
              select person;

That’s all fine and good, but what about scenarios where you want to dynamically build up your query structure? In our client application we have address books (directories) that include the ability to filter them on any, or nearly any, column:

How would I accomplish this with LINQ? Not easily. Just ask Ayende or Rob Conery, both of whom have blogged about some of their adventures in advanced usage scenarios. Enter the LINQ Dynamic Query sample from Microsoft. As usual, ScottGu’s got a good write-up. In a nutshell, it’s a custom expression tree generator based on a limited (but useful) string-based query grammar. With Dynamic Query I could write the query above like this:

var results = from person in People
              select person;
results = results.Where("FirstName.StartsWith(\"Aar\")");

It solved my problem nicely. Almost. As with my example above about matching FirstName’s, let me ask: how often does a user enter an exact case-sensitive match for what they’re looking for? I can save you the trouble and tell you: it doesn’t matter. It’s an unacceptable requirement for a user to have to match something exactly. It’s already questionable that we don’t automatically use fuzzy matching algorithms.

So what I really want is to specify a StringComparison enum value on the call to "StartsWith":

var results = from person in People
              select person;
results = results.Where("FirstName.StartsWith(\"Aar\", System.StringComparison.OrdinalIgnoreCase)");

Alas, this breaks. LINQ Dynamic Query doesn’t support enum values as parameters to methods. So I added it. I won’t redistribute the sample (I’m pretty sure I can’t, but I don’t care to anyway) so here’s what you need to do to add support for enum parsing. Note that I’ve only tested it with calls to string’s StartsWith(string, StringComparison) method. I don’t know what will happen if you sprinkle enum values in random places throughout your dynamic query. Work on My Machine, your mileage may vary, etc. etc. etc.

1. Download the sample.

2. Crack open the Dynamic.cs source file. It’s scary, but you can do it. Modify it like so (I added the "if (ParseEnumType…"

Expression ParseIdentifier() {
    ValidateToken(TokenId.Identifier);
    object value;
    if (keywords.TryGetValue(token.text, out value)) {
        if (value is Type) return ParseTypeAccess((Type)value);
        if (value == (object)keywordIt) return ParseIt();
        if (value == (object)keywordIif) return ParseIif();
        if (value == (object)keywordNew) return ParseNew();
        NextToken();
        return (Expression)value;
    }
    if (symbols.TryGetValue(token.text, out value) ||
        externals != null && externals.TryGetValue(token.text, out value)) {
        Expression expr = value as Expression;
        if (expr == null) {
            expr = Expression.Constant(value);
        }
        else {
            LambdaExpression lambda = expr as LambdaExpression;
            if (lambda != null) return ParseLambdaInvocation(lambda);
        }
        NextToken();
        return expr;
    }
    // ADD THIS IF STATEMENT
    if (ParseEnumType(out value))
    {
        Expression expr = Expression.Constant(value);
        NextToken();
        return expr;
    }
    if (it != null) return ParseMemberAccess(null, it);
    throw ParseError(Res.UnknownIdentifier, token.text);
}

3. Add the definition for ParseEnumType. This little bit of nastiness is essentially doing a look-ahead to resolve a type name, since most of the parser’s rules are built to process more contextual information (such as a property name of a type, etc.) In our case, we need to attempt to match "Foo.Foo.Foo" to a type name, and if it doesn’t end up resolving, we need to reset the parser back to the beginning of "Foo" to continue parsing.

bool ParseEnumType(out object value)
{
    value = null;

    ValidateToken(TokenId.Identifier);
    Type enumType = null;
    int position = token.pos;
    string typeName = token.text;
    while (enumType == null)
    {
        // Loop until we stop processing identifiers and/or dots
        enumType = Type.GetType(typeName, false, true);
        if (enumType == null)
        {
            NextToken();
            if (token.id == TokenId.Dot)
            {
                typeName += token.text;
                NextToken();
                if (token.id == TokenId.Identifier)
                {
                    typeName += token.text;
                }
                else
                {
                    break;
                }
            }
            else
            {
                break;
            }
        }
    }

    if ((enumType != null) && IsEnumType(enumType))
    {
        NextToken();
        ValidateToken(TokenId.Dot, Res.DotExpected);
        NextToken();
        ValidateToken(TokenId.Identifier, Res.IdentifierExpected);
        value = Enum.Parse(enumType, token.text, true);
        return true;
    }
    else
    {
        SetTextPos(position);
        NextToken();
    }

    return false;
}

4. Add an error "resource" string (but not really a true resource string) to the "Res" static class. We added a new condition, so we need an error message to match.

public const string DotExpected = "'.' expected";

Voila! Make sure your enum values are fully-qualified type names and you’ll be good to go.

Hopefully this works for you as well as it did for me, and I have to say I can’t believe I couldn’t find this on the ‘net, as I imagine this is a very common use-case.

Tip: if you surround the path with angle brackets (“<>”) it’ll link the whole thing. Typing it in, pasting, whatever, just get the path between the greater-than/less-than characters and when you type a whitespace/carriage return character Outlook will auto-link the path for you.

It’s one of those time savers that add up over time to give you back a few minutes of your life per day.

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>

With the amount of email we get at my company, that’s a pretty useful (and simple!) trick. I used it internally, which of course started a big time-wasting email thread testing it, joking, etc. And it resulted in my friend Scott Bauer creating the “anti-Hanselman” macro–same creation instructions as Hanselman’s, just use this code instead.

ActiveInspector.CurrentItem.Actions("Reply to All").Enabled = True
ActiveInspector.CurrentItem.Actions("Forward").Enabled = True

Anyway, it got me thinking about another common scenario we run into frequently. An email gets sent to the wrong distribution list. Doesn’t sound so horrible, does it? But it gets much worse when the email thread goes for a long time and plenty of people who don’t care are on the recipient list. You start getting a few emails like “take me off this thread please”, but most of just keep hitting Delete, and it wastes everybody’s time. (You can’t ignore it because it might be relevant-how can you tell, all you see is a “you’ve got mail” notice, and you don’t want to have to create a rule for every email thread like this.)

Here is how I deal with this scenario:

1. Forward the email (to maintain attachments, etc.)
2. Send it TO the original sender and the new (appropriate) distribution list/recipient
3. Maintain the CC list, as they probably still care
4. BCC everybody on the original To list
5. Add a line that says “Forwarding to the appropriate group, BCC’ing everybody else” – or something to that effect
6. (Here’s the key) Set the “Direct Replies To” field to the new list I’m forwarding to:
   

By directing replies to the list I’m redirecting to, I effectively take myself out of the loop. Otherwise I unnecessarily sacrifice myself for everybody else by remaining on the irrelevant thread.

Needless to say that gets annoying to do frequently. So, Scott (Hanselman and Bauer) motivated me to create a macro to automate it.

I won’t repeat the details of how to create the macro, and add a button to your message header, etc. Go read Scott Hanselman’s walk-through on how to do that. Then come back here. But just remember to add the macro “toolbar button” to a received message, not a new outgoing message (there is a difference!). I selected the right-arrow-in-a-circle icon for mine (), sort of indicating a different kind of “forward”.

Now, when I get an email like this:

I can click the “Redirect Email” macro and I’m prompted to select some addresses from the address book. After I select them (“Accounting” in this case), I get a new mail, pre-filled out and ready to send.

Notice that the “Direct Replies To” button is highlighted (it’s the image of the person with the left-facing purple arrow), indicating that its value is set. Clicking the button shows that it is indeed set:

All I have to do is press send. Much easier and much faster than doing all that work by hand.

Paste the following into your macro definition and tweak if you like – I’m not a VB/VBA programmer, so I’m sure it’s not perfect. Post back here if you tweak it and improve it. Also note that I’m including the “Sub” definition, to give my snippet some context. You should already have one created if you follow Scott’s instructions.

Sub RedirectMail()
    Dim mail As MailItem
    Dim forward As MailItem
    Dim recipient As recipient
    Set mail = ActiveInspector.CurrentItem

    Dim selectNamesDlg As SelectNamesDialog
    Set selectNamesDlg = Application.Session.GetSelectNamesDialog
    selectNamesDlg.ForceResolution = True
    If (selectNamesDlg.Display And selectNamesDlg.Recipients.Count > 0) Then

        ' Forward this mail item, initializing the "To" line with:
        ' The original sender of the mail, and the newly selected recipients
        ' Direct replies to the newly selected recipients
        ' People originally on the CC line still get CC'd
        ' Add everybody else on the BCC line

        Set forward = mail.forward

        If (forward.ReplyRecipients.Count > 0) Then
            For i = 1 To forward.ReplyRecipients.Count
                forward.ReplyRecipients.Remove (i)
            Next i
        End If

        forward.Recipients.Add (mail.SenderEmailAddress)

        For Each recipient In selectNamesDlg.Recipients
            forward.Recipients.Add (recipient.Name)
            forward.ReplyRecipients.Add (recipient.Name)
        Next recipient

        For Each recipient In mail.Recipients
            Set theRecipient = forward.Recipients.Add(recipient.Name)
            theRecipient.Type = recipient.Type

            If (recipient.Type <> olCC) Then
                theRecipient.Type = olBCC
            End If
        Next recipient

        If (forward.BodyFormat = olFormatPlain Or olFormatUnspecified) Then
            forward.Body = "Redirecting to the appropriate distribution, and BCC'ing others" + forward.Body
        Else
            forward.HTMLBody = "Redirecting to the appropriate distribution, and BCC'ing others" + forward.HTMLBody
        End If

        forward.Recipients.ResolveAll
        forward.Display

    End If
End Sub

Enjoy!

Update: Lee Holmes posted some good reasons why you shouldn’t use BCC. Please take that into account when using this macro – in my situation, this macro is useful, mostly because of the way my co-workers tend to use email coupled with the size of the distribution lists. It isn’t necessarily a good solution for everybody!

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!

It’s simple: create a shortcut with the following target.
“C:\Program Files\Microsoft Office\Office12\OUTLOOK.EXE” /c “IPM.Note”
(if your path to OUTLOOK.EXE differs, use yours)

Thanks Chris!
* Win+1 is, and always will be, PowerShell.

But I digress. In Vista by default you can activate the Win+# hotkeys to activate the Quick Launch shortcut in the specified location (1-based, so 0 == 10). In my screenshot above, Win+1 opens PowerShell, and Win+8 opens Reflector. As you reorder the shortcuts (you can drag and drop them to reorder) the hotkeys open the new shortcuts.

Very cool!

As I read a blog entry or a web site I will open interesting links in a new tab within Firefox. That way I can read uninterrupted but still have the relevant links available as soon as I’m done.

For example, if I want to know who Scott Hanselman respects, and I do, I have the preference set to open the link in a new tab, however it immediately gives the tab focus—sort of making the whole idea of “don’t interrupt me” a moot point. So I got in the habit of right-clicking and choosing “Open Link in New Tab” which opens a new tab but doesn’t steal the focus. But all that right-clicking gets old pretty fast.

So what’s the tip? If you click on a link with your scroll-wheel, it’s the same as right-clicking and choosing “Open Link in New Tab”! Problem solved! Didn’t I say this is ridiculously silly? Yep. But it’s 2 AM and I should’ve been in bed hours ago.

Helpful!