document.getElementById('MyID').scrollIntoView(true);

This method will jump you straight to the top of the element with Id MyID. If you want to animate the scroll down the page, then a simple little bit of jQuery will give the right effect.

$("#my-link-id").click(
    function()
    {
        $('html:not(:animated), body:not(:animated)').animate({
            scrollTop: $("#scrollToHere").offset().top
        }, 2000);
    }
);

The first solution is to run the application without debugging by using Ctrl+F5 instead of just F5.  The console window will remain open when the program has finished.  The disadvantage of this is that you lose Visual Studio’s debug information.

The second solution is to add a couple lines of code to the end of your Main() method which halts the application until the user presses a key.  This allows you to run in Visual Studio’s Debug mode but requires a change to the code that you might not want in a production environment.

Console.WriteLine("Press any key to close");
Console.ReadKey();

Neither solution is perfect, but they both solve the problem well enough to let me get on with development.

Re-Writing the ASP.NET PostBack URL

So, what do we do about this?  We use the ASP.NET Control Adapter framework to change the way the action attribute of our <form> tag is rendered.  This doesn’t require you to change any code on any pages, we are simply overriding a part of the standard ASP.NET page rendering pipeline which serves all pages.

To get started we need two things:

1. A .browser file in the /App_Browsers directory of your application
2. A class which inherits ControlAdapter to do the work.

First up, lets look at the contents of the browser file.  I’m calling mine Form.browser.

<browsers>
    <browser refID="Default">
        <controlAdapters>
            <adapter controlType="System.Web.UI.HtmlControls.HtmlForm"
                     adapterType="Storm.ControlAdapters.FormRewriteControlAdapter" />
        </controlAdapters>
    </browser>
</browsers>

In this file we are registering a new control adapter for the HtmlForm Control.  My adapter is in Storm’s common library for easy reuse across projects.

Next, lets take a look at the FormRewriteControlAdapter

    using System.Web;
    using System.Web.UI;

    /// <summary>
    /// Used to rewrite the form action attribute when using URL re-writing to the
    /// RawUrl so we don't get in a big mess!
    /// </summary>
    public class FormRewriteControlAdapter : System.Web.UI.Adapters.ControlAdapter
    {
        /// <summary>
        /// Override the render method
        /// </summary>
        /// <param name="writer">The text writer</param>
        protected override void Render(HtmlTextWriter writer)
        {
            base.Render(new RewriteFormHtmlTextWriter(writer));
        }
    }

There’s nothing terribly exciting here – we are inheriting System.Web.UI.Adapters.ControlAdapter and then simply call the base Render method with a custom TextWriter implementation.  So let’s move on and take a look inside the TextWriter and see how the magic happens:

    /// <summary>
    /// The internal text writer to use in FormRewriteControlAdapter
    /// </summary>
    public class RewriteFormHtmlTextWriter : HtmlTextWriter
    {
        /// <summary>
        /// Initializes a new instance of the RewriteFormHtmlTextWriter class
        /// </summary>
        /// <param name="writer">Html text writer</param>
        public RewriteFormHtmlTextWriter(HtmlTextWriter writer)
            : base(writer)
        {
            this.InnerWriter = writer.InnerWriter;
        }

        /// <summary>
        /// Initializes a new instance of the RewriteFormHtmlTextWriter class
        /// </summary>
        /// <param name="writer">An IO text writer</param>
        public RewriteFormHtmlTextWriter(System.IO.TextWriter writer)
            : base(writer)
        {
            this.InnerWriter = writer;
        }

        /// <summary>
        /// Do the actual attribute writing of the action attribute
        /// </summary>
        /// <param name="name">The name of the attribute</param>
        /// <param name="value">The value of the attribute</param>
        /// <param name="fEncode">Dont know</param>
        public override void WriteAttribute(string name, string value, bool fEncode)
        {
            if (name.Equals("action"))
            {
                var context = HttpContext.Current;

                if (context.Items["ActionAlreadyWritten"] == null)
                {
                    // Set the action to the raw url
                    value = context.Request.RawUrl;
                    context.Items["ActionAlreadyWritten"] = true;
                }
            }

            base.WriteAttribute(name, value, fEncode);
        }
    }

The key part here is the WriteAttribute method. This is called for each attribute that appears on the <form> tag.  First we check to see if we are working on the ‘action’ attribute and then check that we haven’t already written it.  Now we get to the good part.  We grab the RawUrl of the request – this should contain the Url that was first requested by the browser (i.e. our nice, clean re-written Url) – and overwrite the value parameter.  We then call the base WriteAttribute method with the new value and the ASP.NET rendering pipeline takes care of the rest.

Thanks to Scott Guthrie for getting me started fixing this!  If you’re working in VB.NET, Scott provided a sample project.

Let’s look at the code we need:

protected void Page_Load(object sender, EventArgs e)
{
    ScriptManager.RegisterStartupScript(
                        upPanel,
                        this.GetType(),
                        "MyAction",
                        "doMyAction();",
                        true);
}

RegisterStartupScript is a static method on the ScriptManager class.  You do not need to have an actual ScriptManager in scope to call this function (for example, you might be coding within a UserControl and have the ScriptManager on the Page).

The first parameter is the UpdatePanel you want to associate the script with.  The second parameter is a type parameter, we’ll just use the type of the current object for this.  Now we get to the interesting bits.  The third parameter, “MyAction”, is a key to identify the script, allowing you to reference or update it in the future if you wish.  Next we have the script itself.  This can be a block of inline JavaScript but I prefer to wrap everything I want to happen in a function and call that instead.   The final parameter is a flag to indicate whether the ScriptManager should wrap your code in script tags.   You can do this manually if you want, but I prefer to set this flag to true and let somebody else worry about it.

ASP.NET will output the following code at the bottom of your page and execute it on PostBack. Provided you have defined the function doMyAction() somewhere everything should work as you expect.

<script type="text/javascript">
    doMyAction();
</script>

If you set the final parameter to false you would get the following:

    doMyAction();

You can pass variables from your C# code to your JavaScript by including them in your function call:

protected void Page_Load(object sender, EventArgs e)
{
    int myVar = 5;
    ScriptManager.RegisterStartupScript(
                        upPanel,
                        this.GetType(),
                        "MyAction",
                        "doMyAction(" + myVar + ");",
                        true);
}

We’d then get the following output:

<script type="text/javascript">
    doMyAction(5);
</script>

Configuring hibernate.cfg.xml for SQLite

You need to change your connection.driver_class, connection.connection_string and dialect to the SQLite specific values shown below.

<?xml version="1.0" encoding="utf-8" ?>
<hibernate-configuration  xmlns="urn:nhibernate-configuration-2.2" >
  <session-factory>
    <property name="connection.provider">
      NHibernate.Connection.DriverConnectionProvider
    </property>
    <property name="connection.driver_class">
      NHibernate.Driver.SQLite20Driver
    </property>
    <property name="connection.connection_string">
      Data Source=:memory:;Version=3;New=True;Pooling=True;Max Pool Size=1;
    </property>    
    <property name="adonet.batch_size">10</property>
    <property name="show_sql">true</property>
    <property name="dialect">NHibernate.Dialect.SQLiteDialect</property>
    <property name="use_outer_join">true</property>
    <property name="command_timeout">60</property>
    <property name="query.substitutions">true 1, false 0, yes 'Y', no 'N'</property>
    <property name="proxyfactory.factory_class">
      NHibernate.ByteCode.LinFu.ProxyFactoryFactory, NHibernate.ByteCode.LinFu
    </property>
  </session-factory>
</hibernate-configuration>

That should be that. Just make sure that you have System.Data.SQLite added as a reference to your test assembly. You can download the compiled binary from SourceForge.  Make sure you select the correct version, x86 or x64!

Warning: The first example I found on the net had the following driver_class:

<property name="connection.driver_class">NHibernate.Driver.SQLiteDriver</property>

This does not work with the lastest version of SQLite.  You need to use NHibernate.Driver.SQLite20Driver else you will get an exception similar to:

NHibernate.HibernateException : Could not create the driver from NHibernate.Driver.SQLiteDriver.  
----> System.Reflection.TargetInvocationException : Exception has been thrown by the target of an invocation.  
----> NHibernate.HibernateException : The IDbCommand and IDbConnection implementation in the assembly SQLite.NET
      could not be found. Ensure that the assembly SQLite.NET is located in the application directory or in the Global
      Assembly Cache. If the assembly is in the GAC, use <qualifyAssembly/> element in the application configuration file
      to specify the full name of the assembly.

The Google support page for configuring a mail client gives us a good starting point.  We can see that we need to use the host smtp.gmail.com on port 587.  We can also see that we must transmit over a secure connection and that we need to use our GMail username and password to authenticate with the server.

using System.Net.Mail;

public class GMailSMTP
{
    public void Send(string to, string subject, string message, bool isHtml)
    {
            // Create a new message
            var mail = new MailMessage();

            // Set the to and from addresses.
            // The from address must be your GMail account
            mail.From = new MailAddress("example@gmail.com");
            mail.To.Add(new MailAddress(to));

            // Define the message
            mail.Subject = subject;
            mail.IsBodyHtml = isHtml;
            mail.Body = message;

            // Create a new Smpt Client using Google's servers
            var mailclient = new SmtpClient();
            mailclient.Host = "smtp.gmail.com";
            mailclient.Port = 587;

            // This is the critical part, you must enable SSL
            mailclient.EnableSsl = true;

            // Specify your authentication details
            mailclient.Credentials = new System.Net.NetworkCredential(
                                             "YOUR GMAIL USERNAME",
                                             "YOUR GMAIL PASSWORD");
            mailclient.Send(mail);
    }
}

That's all there is to it!

As you can see if you visit the WikiPedia page, it’s not a simple formula!  However, it is beautifully elegant and a very fast solution to the problem.

During the course of development we worked on two versions of the code. Our first iteration had the office co-ordinates stored in an SQL Server database, later we moved to keeping them in an in-memory List<T>. Below are both versions of the code to calculate the Haversine distance.

MS SQL Server

SELECT TOP 1 *, ( 3960 * acos( cos( radians( @custLat ) ) *
  cos( radians( Lat ) ) * cos( radians(  Lng  ) - radians( @custLng ) ) +
  sin( radians( @custLat ) ) * sin( radians(  Lat  ) ) ) ) AS Distance
FROM Offices
ORDER BY Distance ASC

@custLat and @custLng are the variable co-ordinates of the customer.  Lat and Lng are the fields of the database table in which we have stored the office co-ordinates.  The above code calculates the distance in miles, if you want the answer in kilometers you need to replace 3960 with 6371. This could be parameterised in a Stored Procedure if you were feeling adventurous – there are plenty of example of this on the web already.

C#

In the following C# example, we use a simple enum to specify the unit of distance. We also need to convert the latitude and longitude from degrees to radians. We created a simple extension method for the double type to do this conversion.

    /// <summary>
    /// Returns the distance in miles or kilometers of any two
    /// latitude / longitude points.
    /// </summary>
    /// <param name="pos1">Location 1</param>
    /// <param name="pos2">Location 2</param>
    /// <param name="unit">Miles or Kilometers</param>
    /// <returns>Distance in the requested unit</returns>
    public double HaversineDistance(LatLng pos1, LatLng pos2, DistanceUnit unit)
    {
        double R = (unit == DistanceUnit.Miles) ? 3960 : 6371;
        var lat = (pos2.Latitude - pos1.Latitude).ToRadians();
        var lng = (pos2.Longitude - pos1.Longitude).ToRadians();
        var h1 = Math.Sin(lat / 2) * Math.Sin(lat / 2) +
                      Math.Cos(pos1.Latitude.ToRadians()) * Math.Cos(pos2.Latitude.ToRadians()) *
                      Math.Sin(lng / 2) * Math.Sin(lng / 2);
        var h2 = 2 * Math.Asin(Math.Min(1, Math.Sqrt(h1)));
        return R * h2;
    }

    public enum DistanceUnit { Miles, Kilometers };

A simple helper class is used to pass around Longitude / Latitude co-ordinates:

    /// <summary>
    /// Specifies a Latitude / Longitude point.
    /// </summary>
    public class LatLng
    {
        public double Latitude { get; set; }
        public double Longitude { get; set; }

        public LatLng(){
        }

        public LatLng(double lat, double lng)
        {
            this.Latitude = lat;
            this.Longitude = lng;
        }
    }

To use the function to perform the search we grab an array of offices, loop over them calculating the distance to the customer and use LINQ to select the closest office.

    var Offices = GetMyOfficeList();
    for(int i = 0; i< Offices.Count; i++)
    {
        Offices[i].Distance = HaversineDistance(
                                coord,
                                new LatLng(Offices[i].Lat, Offices[i].Lng),
                                DistanceUnit.Miles);
    }

    var closestOffice = Offices.OrderBy(x => x.Distance).Take(1).Single();

Using the Google Maps API

Note: To make use of the example in the post you will need to sign-up for a free Google Maps API Key.

The following example is written in C#, but it can be converted to any language fairly trivially as we are actually only making an HTTP request and parsing the result.

We use a little helper class to hold a latitude/longitude co-ordinate.

public class LatLng
{
    public double Latitude {get;set;}
    public double Longitude {get;set;

    public LatLng(){
    }

    public LatLng(double lat, double lng)
    {
        this.Latitude = lat;
        this.Longitude = lng;
    }
}

We’ve packaged the function to get the co-ordinates in a helper class so that we can add extra Google Maps functionality if required. It also allows us to reuse the code across multiple projects as the API key is not hard coded.

    using System;
    using System.IO;
    using System.Net;
    using System.Web;
    using Storm.Common.Utils.Extensions;

    public class GoogleMaps
    {
        private string API_KEY = string.Empty;

        public GoogleMaps(string api_key)
        {
            this.API_KEY = api_key;
        }

        public void SetApiKey(string key)
        {
            if (key.IsNullOrEmpty())
            {
                throw new ArgumentException("API Key is invalid");
            }

            this.API_KEY = key;
        }

        /// <summary>
        /// Perform a geocode lookup of an address
        /// </summary>
        /// <param name="addr">The address in CSV form line1, line2, postcode</param>
        /// <param name="output">CSV or XML</param>
        /// <returns>LatLng object</returns>
        public LatLng GetLatLng(string addr)
        {
            var url = "http://maps.google.co.uk/maps/geo?output=csv&key=" +
                       this.API_KEY + "&q=" + HttpContext.Current.Server.UrlEncode(addr);

            var request = WebRequest.Create(url);
            var response = (HttpWebResponse)request.GetResponse();

            if (response.StatusCode == HttpStatusCode.OK)
            {

                var ms = new MemoryStream();
                var responseStream = response.GetResponseStream();

                var buffer = new Byte[2048];
                int count = responseStream.Read(buffer, 0, buffer.Length);

                while (count > 0)
                {
                    ms.Write(buffer, 0, count);
                    count = responseStream.Read(buffer, 0, buffer.Length);
                }

                responseStream.Close();
                ms.Close();

                var responseBytes = ms.ToArray();
                var encoding = new System.Text.ASCIIEncoding();

                var coords = encoding.GetString(responseBytes);
                var parts = coords.Split(",");

                return new LatLng(
                              Convert.ToDouble(parts[2]),
                              Convert.ToDouble(parts[3]));
            }

            return null;
        }
    }

Let’s talk through whats going on. First up, the boring bit:

        private string API_KEY = string.Empty;

        public GoogleMaps(string api_key)
        {
            this.API_KEY = api_key;
        }

        public void SetApiKey(string key)
        {
            if (key.IsNullOrEmpty())
            {
                throw new ArgumentException("API Key is invalid");
            }

            this.API_KEY = key;
        }

Here we have a private field to store the Maps API key required to issue a request. The key can be set either through the constructor or by using the SetApiKey() function.

Now lets see how we use this in the lookup function.

            var url = "http://maps.google.co.uk/maps/geo?output=csv&key=" +
                       this.API_KEY + "&q=" + HttpContext.Current.Server.UrlEncode(addr);

            var request = WebRequest.Create(url);
            var response = (HttpWebResponse)request.GetResponse();

First, we build the a URL which represents the request we want to make. The output param sets the format Google will return the results, here we have chosen CSV but you can also get JSON if you wish. Next we include our API key to identify ourselves. Finally, we pass the address we are searching for.

Using this URL we create a WebRequest and call GetResponse to fetch the page contents. Before we go any further we check that the result was returned successfully:

if (response.StatusCode == HttpStatusCode.OK)

Now we have another boring bit which reads the result of the web request into a byte array and converts the result into an ASCII encoded string

                var ms = new MemoryStream();
                var responseStream = response.GetResponseStream();

                var buffer = new Byte[2048];
                int count = responseStream.Read(buffer, 0, buffer.Length);

                while (count > 0)
                {
                    ms.Write(buffer, 0, count);
                    count = responseStream.Read(buffer, 0, buffer.Length);
                }

                responseStream.Close();
                ms.Close();

                var responseBytes = ms.ToArray();
                var encoding = new System.Text.ASCIIEncoding();

                var coords = encoding.GetString(responseBytes);

This string should look something like:

200,5,51.2268219,-2.4646913

We are interested in the 3rd and 4th values – the latitude and longitude. So, we split the string at the comma separator, create a new LatLng object and return the result:

        var parts = coords.Split(",");
        return new LatLng(Convert.ToDouble(parts[2]), Convert.ToDouble(parts[3]));

I hope this tutorial has proven useful and that you can go away and develop some cool apps!

The maths to convert an angle from degrees to radians is really quite simple:

(pi / 180) * angle

We can take this simple equation and create either a simple function, or a convenient extension method.

C# Function

    public double ConvertToRadians(double angle)
    {
        return (Math.PI / 180) * angle;
    }

C# Extension Method

    /// <summary>
    /// Convert to Radians.
    /// </summary>
    /// <param name="val">The value to convert to radians</param>
    /// <returns>The value in radians</returns>
    public static class NumericExtensions
    {
        public static double ToRadians(this double val)
        {
            return (Math.PI / 180) * val;
        }
    }

 var myHashTable = new Dictionary<TKey, TValue>

Where TKey is the type of your key (possibly an int to represent the Id of your object or string for a username) and TValue is the type of the value. I hope that saves you some time!