private string GetDefaultWebPath()
        {
            string result = null;
            using (var de = new DirectoryEntry("IIS://Localhost/W3SVC"))
            {
                foreach (DirectoryEntry child in de.Children
                .Cast<DirectoryEntry>()
                .Where(d => d.SchemaClassName == "IIsWebServer" &&
                     d.Properties["ServerState"]
                     .Value.ToString() == "2" /* Started*/))
                {
                    var bindings = child.Properties
                        .Cast<PropertyValueCollection>()
                        .Where(i => i.PropertyName == "ServerBindings")
                        .ToList().Cast<PropertyValueCollection>();
                    if (bindings.Count() == 1 && bindings
                        .First().Value.ToString() == ":80:")
                    {
                        var root = child.Children
                            .Cast<DirectoryEntry>()
                            .FirstOrDefault(d => d.SchemaClassName == "IIsWebVirtualDir");
                        if (root != null)
                        {
                            result = root.Properties["Path"].Value.ToString();
                        }
                    }
                }
            }
            if (string.IsNullOrEmpty(result))
            {
                throw new Exception("Could not determine the default web.");
            }
            return result;
        }

public static class JavaScriptSerializerExtensions
    {
        private static object _lock = new object();
        private static IDictionary<Type, MethodInfo> _deserializers
               = new Dictionary<Type, MethodInfo>();

        private static MethodInfo GetDeserializeMethod(Type type)
        {
            lock (_lock)
            {
                if (_deserializers.ContainsKey(type)==false)
                {
                    var mi = typeof(JavaScriptSerializer)
                        .GetMethod("Deserialize");
                    _deserializers[type] = mi.MakeGenericMethod(type);
                }
            }
            return _deserializers[type];
        }

        public static object Deserialize(
               this JavaScriptSerializer serializer, Type type, string json)
        {
            return GetDeserializeMethod(type).Invoke(
                serializer, new object[] { json });
        }
    }

Array.prototype.sum = function (predicate) {
    predicate = predicate || function (match) {
        if (typeof match == "string") {
            return match.length;
        }
        return match;
    };
    var result = 0;
    for (var i = 0; i < this.length; i++) {
        result += predicate(this[i]);
    }
    return result;
};

Here are a couple usage examples:

// Baked-in sum for strings
var array1 = ["hello","world"];
var length = array1.sum());

// Baked-in sum for numbers
var array2 = [10,20,30];
length = array2.sum();

// Custom for custom objects.
var array3 = [{yearsOfExperience:3},{yearsOfExperience:5}];
length = array3.sum(function(match){return match.yearsOfExperience;});

Here’s a Fiddle that demonstrates this (hit F12 in FF, Chrome, IE*+ and look at the console when running):  http://jsfiddle.net/harperj1029/Zeaqa/

Think Linq!

gwmi win32_process -filter “name=’w3wp.exe’” | format-table -autosize name,processId,commandLine

So, you could pop that into a powershell file and call that either via an old-school batch file – or….. you could use a command line utility such as SlickRun and in-line the command into a “MagicWord” (Slickrun-speak for a named command) like this:

magic.

Of  course, this is pretty simple too: http://www.ervinter.com/2009/04/23/get-process-id-from-multiple-application-pool-iisapp/

For times when you need to use regular expressions – and you’re either not strong at them, or have been away from them for more than 2 minutes (the time it takes to forget most of the syntax), then check out RegExPal.  This little utility is handy, and give great real-time visual indications of matches.

So, if you are unit testing, or perhaps even new to unit testing, I encourage you to consider looking at both of these tools.  Perhaps start out with Moq, but if you encounter the same limitation, check out Moles.

J

<body xmlns:sys="javascript:Sys"sys:activate="*">

Then I added this 1-time-only registration line below (this essentially tells the sweet little $.declare function to burn my “backgroundColorizer” plugin as a registered behavior for each element this its attached to , activated by that global sys:activate=”*” piece we added to the <body> tag) (did that make any sense?):

$(function () {
    $.declare("backgroundColorizer");
});

Now, some html elements can simply look like this with no additional javascript needed:

   <ul sys:attach="backgroundcolorizer">

        <li>one</li>

        <li>two</li>

        <li>three</li>

        <li>four</li>

    </ul>

    <tablesys:attach="backgroundcolorizer"backgroundcolorizer:oddColor=’lightGreen’ backgroundcolorizer:evenColor=’Green’>

        <tr><td>Jane </td><td>Smith</td></tr>

        <tr><td>Joe </td><td>Smith</td></tr>

        <tr><td>John </td><td>Doe</td></tr>

        <tr><td>Jane Q. </td><td>Public</td></tr>

    </table>

OK, here’s the worst and hackish part, where i took my plugin and put in embarrassingly cheesy code to get around the various “children” semantics.  I’m sure this would break down immediately, but for this trivial sample it works ok:

        // The "backgroundColorizer" pluggin allows you to essentially color alternative odd/even rows' background
        // (thrilling, eh?)
        (function ($) {
            $.fn.extend(
            {
                backgroundColorizer: function (options) {
                    var defaults = { oddColor: 'red', evenColor: 'blue' };
                    var options = $.extend(defaults, options);
                    var selector = this;
                    if (this[0].tagName == "TABLE") {
                        selector = $('tr');
                    } else {
                        selector = this.children();
                    }

                    return $(selector).each(function (index) {
                        var obj = $(this);

                        if (index % 2 > 0) {
                            obj.css("background-color", options.oddColor);
                        } else {
                            obj.css("background-color", options.evenColor);
                        }
                    });
                }
            });
        })(jQuery);

OK.  So, there you have it.  We’re using the declarative behavior approach of Microsoft’s ajax library to wrap around our JQuery plugin.  Check out that link at the beginning of this post and after your brain stops curdling (as mine did) from that dude’s solution, then soak it up and savor.