Unable to start debugging on the web server

If you’re getting this error when trying to debug an ASP.NET Web application on IIS7 or greater, check the system.webServer element in your Web.config.  If you have the httpErrors element configured, you won’t be able to debug.  For your local dev environment, remove or comment out the httpErrors element, and you should be good to go.

<WAG>
From my ASP.NET 1.1 days, I have a hazy memory of Visual Studio’s debugging startup process requesting a bogus URL on the target Web site, and then doing something with the 404 response prior to launching the debugging session.  Obviously, if it’s expecting a 404 or the page to contain certain text, redirecting to an error page will prevent you from launching the debugger successfully.
</WAG>

If you happen to know specifically why this happens, please leave a comment (or contact me if comments are closed), and I will gladly update this entry.

Cannot find 'servicereferences.clientconfig' in the .xap application package

I’m new to Silverlight development.  I was banging my head against the wall, trying to figure out what I had done to break our Silverlight app.  After all, the only changes I made were to add a Service Reference to a new WCF service, and to initialize the WCF proxy in App.xaml.cs.

Fortunately, after a little Google sleuthing, I came upon the solution, as shared by David Sandor:

[The code] is trying to read from the ServiceReferences.config file that can not be read at that point in the Silverlight application’s lifecycle.

Bingo, that was it.  Moving my proxy initialization code to Application_Startup fixed the problem.

It makes sense now, but, man, these types of bugs can be maddening.

ImageCodecInfo: Encoder and Decoder information

If you’ve ever been curious about the GDI+ encoders and decoders available on your system, you can call ImageCodecInfo.GetImageEncoders() and ImageCodecInfo.GetImageDecoders(), respectively, to find out more:

Encoders:

ImageCodecInfo.GetImageEncoders().ToList().ForEach(
    enc =>
    {
        Console.WriteLine(enc.FormatDescription);
        Console.WriteLine("tCLSID: {0}", enc.Clsid);
        Console.WriteLine("tCodecName: {0}", enc.CodecName);
        Console.WriteLine("tFilenameExtension: {0}", enc.FilenameExtension);
        Console.WriteLine("tFlags: {0}", enc.Flags);
        Console.WriteLine("tFormatDescription: {0}", enc.FormatDescription);
        Console.WriteLine("tFormatID: {0}", enc.FormatID);
        Console.WriteLine("tMimeType: {0}", enc.MimeType);
        Console.WriteLine("tVersion: {0}", enc.Version);
    });

On my Windows Server 2008 machine, the above code returns the following:

BMP
        CLSID: 557cf400-1a04-11d3-9a73-0000f81ef32e
        CodecName: Built-in BMP Codec
        FilenameExtension: *.BMP;*.DIB;*.RLE
        Flags: Encoder, Decoder, SupportBitmap, Builtin
        FormatDescription: BMP
        FormatID: b96b3cab-0728-11d3-9d7b-0000f81ef32e
        MimeType: image/bmp
        Version: 1
JPEG
        CLSID: 557cf401-1a04-11d3-9a73-0000f81ef32e
        CodecName: Built-in JPEG Codec
        FilenameExtension: *.JPG;*.JPEG;*.JPE;*.JFIF
        Flags: Encoder, Decoder, SupportBitmap, Builtin
        FormatDescription: JPEG
        FormatID: b96b3cae-0728-11d3-9d7b-0000f81ef32e
        MimeType: image/jpeg
        Version: 1
GIF
        CLSID: 557cf402-1a04-11d3-9a73-0000f81ef32e
        CodecName: Built-in GIF Codec
        FilenameExtension: *.GIF
        Flags: Encoder, Decoder, SupportBitmap, Builtin
        FormatDescription: GIF
        FormatID: b96b3cb0-0728-11d3-9d7b-0000f81ef32e
        MimeType: image/gif
        Version: 1
TIFF
        CLSID: 557cf405-1a04-11d3-9a73-0000f81ef32e
        CodecName: Built-in TIFF Codec
        FilenameExtension: *.TIF;*.TIFF
        Flags: Encoder, Decoder, SupportBitmap, Builtin
        FormatDescription: TIFF
        FormatID: b96b3cb1-0728-11d3-9d7b-0000f81ef32e
        MimeType: image/tiff
        Version: 1
PNG
        CLSID: 557cf406-1a04-11d3-9a73-0000f81ef32e
        CodecName: Built-in PNG Codec
        FilenameExtension: *.PNG
        Flags: Encoder, Decoder, SupportBitmap, Builtin
        FormatDescription: PNG
        FormatID: b96b3caf-0728-11d3-9d7b-0000f81ef32e
        MimeType: image/png
        Version: 1

Decoders:

ImageCodecInfo.GetImageDecoders().ToList().ForEach(
    enc =>
    {
        Console.WriteLine(enc.FormatDescription);
        Console.WriteLine("tCLSID: {0}", enc.Clsid);
        Console.WriteLine("tCodecName: {0}", enc.CodecName);
        Console.WriteLine("tFilenameExtension: {0}", enc.FilenameExtension);
        Console.WriteLine("tFlags: {0}", enc.Flags);
        Console.WriteLine("tFormatDescription: {0}", enc.FormatDescription);
        Console.WriteLine("tFormatID: {0}", enc.FormatID);
        Console.WriteLine("tMimeType: {0}", enc.MimeType);
        Console.WriteLine("tVersion: {0}", enc.Version);
    });

Again, on my Windows Server 2008 box, the above code returns the following:

BMP
        CLSID: 557cf400-1a04-11d3-9a73-0000f81ef32e
        CodecName: Built-in BMP Codec
        FilenameExtension: *.BMP;*.DIB;*.RLE
        Flags: Encoder, Decoder, SupportBitmap, Builtin
        FormatDescription: BMP
        FormatID: b96b3cab-0728-11d3-9d7b-0000f81ef32e
        MimeType: image/bmp
        Version: 1
JPEG
        CLSID: 557cf401-1a04-11d3-9a73-0000f81ef32e
        CodecName: Built-in JPEG Codec
        FilenameExtension: *.JPG;*.JPEG;*.JPE;*.JFIF
        Flags: Encoder, Decoder, SupportBitmap, Builtin
        FormatDescription: JPEG
        FormatID: b96b3cae-0728-11d3-9d7b-0000f81ef32e
        MimeType: image/jpeg
        Version: 1
GIF
        CLSID: 557cf402-1a04-11d3-9a73-0000f81ef32e
        CodecName: Built-in GIF Codec
        FilenameExtension: *.GIF
        Flags: Encoder, Decoder, SupportBitmap, Builtin
        FormatDescription: GIF
        FormatID: b96b3cb0-0728-11d3-9d7b-0000f81ef32e
        MimeType: image/gif
        Version: 1
EMF
        CLSID: 557cf403-1a04-11d3-9a73-0000f81ef32e
        CodecName: Built-in EMF Codec
        FilenameExtension: *.EMF
        Flags: Decoder, SupportBitmap, Builtin
        FormatDescription: EMF
        FormatID: b96b3cac-0728-11d3-9d7b-0000f81ef32e
        MimeType: image/x-emf
        Version: 1
WMF
        CLSID: 557cf404-1a04-11d3-9a73-0000f81ef32e
        CodecName: Built-in WMF Codec
        FilenameExtension: *.WMF
        Flags: Decoder, SupportBitmap, Builtin
        FormatDescription: WMF
        FormatID: b96b3cad-0728-11d3-9d7b-0000f81ef32e
        MimeType: image/x-wmf
        Version: 1
TIFF
        CLSID: 557cf405-1a04-11d3-9a73-0000f81ef32e
        CodecName: Built-in TIFF Codec
        FilenameExtension: *.TIF;*.TIFF
        Flags: Encoder, Decoder, SupportBitmap, Builtin
        FormatDescription: TIFF
        FormatID: b96b3cb1-0728-11d3-9d7b-0000f81ef32e
        MimeType: image/tiff
        Version: 1
PNG
        CLSID: 557cf406-1a04-11d3-9a73-0000f81ef32e
        CodecName: Built-in PNG Codec
        FilenameExtension: *.PNG
        Flags: Encoder, Decoder, SupportBitmap, Builtin
        FormatDescription: PNG
        FormatID: b96b3caf-0728-11d3-9d7b-0000f81ef32e
        MimeType: image/png
        Version: 1
ICO
        CLSID: 557cf407-1a04-11d3-9a73-0000f81ef32e
        CodecName: Built-in ICO Codec
        FilenameExtension: *.ICO
        Flags: Decoder, SupportBitmap, Builtin
        FormatDescription: ICO
        FormatID: b96b3cb5-0728-11d3-9d7b-0000f81ef32e
        MimeType: image/x-icon
        Version: 1

ImageCodecInfo is located in System.Drawing.Imaging.

Why am I writing this? On more than one occasion, I have found myself writing code to enumerate these values; I’d rather just have a place to look them up.

Project Euler: Problem 1 (in F#)

I have already done Project Euler Problem 1 in C#. Since I am currently learning F#, I thought I’d give it another shot:

let rec sumMultiples(data) =
    match data with
    | [] -> 0
    | head::tail when (head % 3 = 0 || head % 5 = 0) -> head + sumMultiples(tail)
    | _::tail -> sumMultiples(tail)

It produces the correct result, but seeing as how LINQ considerably simplified the C# version, and since I am a complete F# and functional programming n00b, I suspected there must be a better way.

I hate it when I’m right.

This solution is better, in my opinion:

List.sum(List.filter (fun n -> n % 3 = 0 || n % 5 = 0) [1..999]);;

Anyhow, I know I have a lot left to learn, so I’m looking forward to exploring the functional side of programming in the coming months.

Update 2010-01-08: Ooh, better yet:

[1..999] |> List.filter (fun n -> n % 3 = 0 || n % 5 = 0) |> List.sum;;

Pipelining FTW!

Free ZIP Code Database (data provided by PopularData.com)

PopularData.com provides a free list of U.S. ZIP codes in CSV format on their Web site.  I have taken the liberty of using that data to generate a SQL script that will create a [ZipCode] table in your SQL Server 2005 database and populate it with over 42k unique U.S. ZIP codes.  Schema details can be found on this page.

I have uploaded the SQL script to a new BitBucket repository: ZipCode database in SQL

Back in 2005, I wrote an article for CodeProject that describes how to use ZIP codes to find locations within a given radius from a central point.  I plan to update that code and host it in the BitBucket repository.

For now, I am assuming that if you download this file, you know why you need a ZIP code database and how you should use it.  If not, perhaps the above-mentioned CodeProject article can give you a little guidance.

If you find problems with the data, please alert PopularData.com, as they are the keepers of the master list.  If you don’t mind, please alert me, too.

If you find problems with the SQL script, please alert me.

I should also note that you get what you pay for.  As far as I know, 2001 was the last time this database was updated.  If you need assurance of accurate ZIP code data, look for a commercial solution.  They exist, and they are not that expensive.

Finally, the ZIP code data belongs to PopularData.com and is governed by whatever license they have in place (none is mentioned on their site, nor in the CSV file).  Everything else in the SQL script is governed by the MIT license.

Happy locating!

GuidHelper.TryParse

Microsoft has apparently added Guid.TryParse() to .NET 4.0, but if you’re stuck using an older version of the framework, you’re still kind of left flapping out in the wind.  Luckily, the great minds of the world have converged upon StackOverflow.com and provided a solution: call the Win32 function CLSIDFromString.

I have taken the code and created a little helper class with one public static method called TryParse.  Its usage is just like that of any other TryParse() method in the .NET Framework today.  Here is the code:

using System;
using System.Runtime.InteropServices;


/// <summary>
/// Class that encapsulates the Win32 function CLSIDFromString.
/// </summary>
public static class GuidHelper
{
    /// <summary>
    /// Converts the string representation of a GUID to its System.Guid equivalent.  A return value
    /// indicates whether the conversion succeeded.
    /// </summary>
    /// <param name="s">A string containing the GUID to convert.</param>
    /// <param name="value">When this method returns, contains the System.Guid value equivalent to
    /// the GUID contained in s, if the conversion succeeded, or Guid.Empty if the conversion
    /// failed. The conversion fails if the s parameter is null or is not of the correct format.
    /// This parameter is passed uninitialized.</param>
    /// <returns>true if s was converted successfully; otherwise, false.</returns>
    public static bool TryParse(string s, out Guid value)
    {
        if (string.IsNullOrEmpty(s))
        {
            value = Guid.Empty;
            return false;
        }


        // CLSIDFromString requires enclosing curly braces on its GUIDs.
        if (!s.StartsWith("{"))
        {
            s = "{" + s;
        }
        if (!s.EndsWith("}"))
        {
            s += "}";
        }


        int result = CLSIDFromString(s, out value);
        if (result >= 0)
        {
            return true;
        }
        else
        {
            value = Guid.Empty;
            return false;
        }
    }


    /// <summary>
    /// This function converts a string generated by the StringFromCLSID function back into the
    /// original class identifier.
    /// </summary>
    /// <param name="sz">String that represents the class identifier</param>
    /// <param name="clsid">On return will contain the class identifier</param>
    /// <returns>
    /// Positive or zero if class identifier was obtained successfully
    /// Negative if the call failed
    /// </returns>
    [DllImport("ole32.dll", CharSet = CharSet.Unicode, ExactSpelling = true, PreserveSig = true)]
    private static extern int CLSIDFromString(string sz, out Guid clsid);
}

Fair warning: I verified the author’s performance numbers, but I have not yet run this through a profiler or done any checking for memory leaks. Use it at your own risk.

I suppose since the original is licensed under the cc-wiki license with attribution required, this is, too.

Anyway, enjoy!

"HTTP Error 401.1 – Unauthorized" when using Windows Authentication on IIS7.5

You may have run into this error while trying to develop a site that uses Integrated Windows Authentication on Windows Server 2008 R2 with IIS7.5.  I sure did, and I beat my head against the wall for a couple of hours trying to figure it out.

It turns out to be a security mechanism built into Windows, and the workaround is simple.  Just choose one of the two methods listed in this Microsoft KB article:

You can find a more detailed explanation here:

Hope this saves you some time.

(h/t to this ServerFault.com question/answer: IE 8 Authentication Denied on local SharePoint Site)