Here are a couple of functions to calculate Euclidean distance between 2 points and similarity based on that distance. These are useful in the sort of algorithms described in the excellent book Programming Collective Intelligence

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;

namespace Algorithms
{
 public class Distance
 {
 /// <summary>
 /// Return the distance between 2 points
 /// </summary>
 public static double Euclidean(Point p1, Point p2)
 {
 return Math.Sqrt(Math.Pow(p1.X - p2.X, 2) + Math.Pow(p1.Y - p2.Y, 2));
 }

 /// <summary>
 /// Calculates the similarity between 2 points using Euclidean distance.
 /// Returns a value between 0 and 1 where 1 means they are identical
 /// </summary>
 public static double EuclideanSimilarity(Point p1, Point p2)
 {
 return 1/(1 + Euclidean(p1, p2));
 }
 }
}

And some tests:

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Text;
using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace Algorithms.Test
{
 [TestClass]
 public class TestDistance
 {
 [TestMethod]
 public void Test_Euclidean()
 {
 var p1 = new Point(5, 4);
 var p2 = new Point(4, 1);

 Assert.AreEqual(3.1622776601683795, Distance.Euclidean(p1, p2));

 }
 [TestMethod]
 public void Test_EuclideanSimilarity()
 {
 var p1 = new Point(5, 4);
 var p2 = new Point(4, 1);

 Assert.AreEqual(0.2402530733520421, Distance.EuclideanSimilarity(p1, p2));

 }
 }
}

Sometimes it’s useful to be able to access the current RouteData from outside a controller, for instance in a library class. In webforms you could always do

HttpContext.Current

but in Asp.Net MVC it’s a bit less obvious how you get access to this data.

I’ve found the following code works:

RouteTable.Routes.GetRouteData(new HttpContextWrapper(HttpContext.Current));

Whether there is an easier way or not I don’t know, but this will do me for now…

To group a sequence getting a count for each element of the grouped sequence using Linq:

            var wordList = new List<String> { "test", "one", "test", "two" };
            var grouped = wordList
                .GroupBy(i => i) //Group the words
                .Select(i => new { Word = i.Key, Count = i.Count() }); //get a count for each

Which results in this sequence:

notepad (gci -Include hosts -Path c:\windows\system32 -Recurse)

I’ve seen two examples of this in the last few days.

Firstly we have an Asp.Net website which has recently moved to a new datacentre and seemed to be working well, but then the other day it fell over big time and the event log started filling up with errors about deadlocks in the aspnet_isapi.dll and faults in the W3SVC service. We googled away and just came up with some thing about thread contention and upping the maxWorkerThreads parameter in the machine.config which I didn’t want to do without understanding why this had suddenly become and issue.

At the same time somebody noticed that printing no longer worked in non Internet Explorer browsers, but we ignored that to focus on the more serious stability issue. It was only when I gave up on the first error and looked into the printing bug that I worked out what was going on. The printing page for Non IE browsers tried to make an http request to another page on the site to load the image it was trying to print. Stricter firewall rules in our new datacentre meant that this http request was being blocked meaning that the thread that was trying to make this request was also blocked until the request timed out, and this was what caused both the printing problem and the threading deadlock.

The second example of this maxim is a bit less high tech; my washing machine started leaking water through the door and we noticed the seal was a bit torn. At the same time it kept stopping with an error message (yup, even washing machines have them now) about the filter being blocked (which it wasn’t). It turns out that the loss of pressure from the leaking water affected its ability to pump out water, so it thought that the filter was blocked (that may not be 100% accurate, but when it comes to washing machines I’m not technical).

A cool way to get WordPress to format and sytax highlight your C# code:

[sourcecode language=’csharp’]
string MyCode = “My Code”;
[/sourcecode]

Which appears in the post as:

string MyCode = "My Code";

I couldn’t find an example of using the new auto initialization syntax in C# 3.0 with a Dictionary so here is one:

var dict = new Dictionary<string, string> { { "key1", "value1" }, { "key2", "value2" } };

Connect to:

\\[ServerName]\root\MicrosoftIISv2

In the connection dialog:

If you are logged in as a user who has admin rights on the server then check ‘Login as current user’, otherwise uncheck it and enter the credentials of a user who does.

Click ‘Options>>’ button:

Set Impersonation level to ‘Impersonate’

Set Authentication level to ‘Packet Privacy’

Check ‘Enable all privileges’

Click ‘OK’ and hey presto!

This is just a reminder for me really, as I struggle to debug one of our LAMP sites after our Sys Admin left…

cd [directoryname] – Change directory

cd .. – Go up one directory

cd ../.. – Go up 2 directories

ls – List directory contents

cat [filename] – Show the contents of a text file

rm [filename] – Delete a file

rmdir [directory] – Delete a directory

rmdir -r [directory] – Delete a directory and all it’s contents

sh [filename] – Execute a shell script file

Tab – Complete a filename

Ctrl + c – Cancel a running command

crontab -l – List all the current user’s cron jobs

ps -A – List all running processes

ps -A | grep java – list all running java processes

find -name *blah*.zip – Find all zip files with blah in their name, more examples

grep “[string literal]” *.log -C 4 – Search for a string literal in all .log files and return 4 lines on either side of the matching line, more examples

tail [filename] -follow - Show the last 10 lines of a file and watch it for changes (Ctrl + c to cancel)

I expect there are a number of implementations of this around, but I couldn’t find one so I wrote this. It is an extension method which implements Fold on IEnumerable

public static class Extensions
{
  public delegate TDestination FoldOperation<TSource, TDestination>(TSource item, TDestination acc);
  public static TDestination Fold<TSource, TDestination>(this IEnumerable<TSource> list, FoldOperation<TSource, TDestination> foldOperation, TDestination acc)
  {
     foreach(TSource item in list)
     {
       acc = foldOperation(item, acc);
     }
     return acc;
  }
 }

I can then use this Fold function for something like this which takes an object with a number of properties and creates a querystring with the name/value pairs of all of those properties which are non-null:

public class UrlConstructor
{
  //Takes a RequestParameter object with a number of properties which
  //if their value is set should be translated into querystring parameters
  public static string ConstructUrl(RequestParameters rp)
  {
    //Get all the properties where the value is not null
    var values = typeof(RequestParameters).GetProperties().Where(p => (p.GetValue(rp, null) != null));

    //Fold these values up into a string
    var querystring = values.Fold(((p, acc) => acc + p.Name + "=" + p.GetValue(rp, null) + "&"), "").TrimEnd('&');

    return "http://mybaseurl.com/default.aspx?" + querystring;
  }
}