.NET

Tip of the Day #16: NaN (Not a Number)

Colin Angus Mackay — Sat, 12 Sep 2009 12:21:15 GMT

The Issue

If you want to detect if a double (System.Double) or float (System.Single) is “not a number” or NaN you cannot use something like this:

if (myDouble == double.NaN) { /* do something */ }

It will always be false.

Sounds crazy? Try this:

double myDouble = double.NaN;
Console.WriteLine("myDouble == double.NaN : {0}", myDouble == double.NaN);

The result is:

myDouble == double.NaN : False

You can see that myDouble was explicitly set the value of double.NaN, yet in the next line it is returning false.

The Solution

If you want to test for a floating point value being Not a Number you to use IsNan() which is a static method on System.Double and System.Single. Here is the first example re-written to use the static method. It will now work correctly:

if (double.IsNan(myDouble) { /* do something */ }

If we re-write our other example:

double myDouble = double.NaN;
Console.WriteLine("double.IsNaN(myDouble) : {0}", double.IsNaN(myDouble));

We get the expected result too:

double.IsNaN(myDouble) : True

The Reason

According to Wikipedia: In computing, NaN, which stands for Not a Number, is a value or symbol that is usually produced as the result of an operation on invalid input operands, especially in floating-point calculations. For example, most floating-point units are unable to explicitly calculate the square root of negative numbers, and will instead indicate that the operation was invalid and return a NaN result. NaNs may also be used to represent missing values in computations.

It goes on to say: A NaN does not compare equal to any floating-point number or NaN, even if the latter has an identical representation. One can therefore test whether a variable has a NaN value by comparing it to itself, thus if x = x gives false then x is a NaN code.

This is why (double.NaN == double.NaN) always results in false. And it is also how the .NET framework detects the NaN value in the IsNan() method.

public static bool IsNaN(double d) 
{ 
    return (d != d); 
}

Technorati Tags: NaN,Not a Number,C#,.NET,floating point numbers,float,double,System.Single,System.Double

Tip of the day #13 (String Equality)

Colin Angus Mackay — Sun, 12 Jul 2009 11:19:05 GMT

When comparing two strings in a case insensitive manner, use:

myFirstString.Equals(mySecondString, StringComparison.InvariantCultureIgnoreCase)

or, if cultural rules are to be ignored completely* then use:

myFirstString.Equals(mySecondString, StringComparison.OrdinalIgnoreCase)

over:

myFirstString.ToLower() == mySecondString.ToLower()

* The invariant culture is actually a non-region specific English language culture. The ordinal comparison is faster than any culture specific comparison as it uses a much simpler comparison algorithm.

How to get a value from a text box into the database

Colin Angus Mackay — Fri, 12 Jun 2009 22:39:45 GMT

This question was asked on a forum and I took some time to construct a reasonably lengthy reply so I’m copying it to my blog for a bit of permanence.

I suspect that many of my regular readers will be dismayed at the lack of proper architecture (e.g. layering) but we all had to start somewhere and I suspect that your first programs were not properly layered or structured either. I know mine certainly weren’t. My aim with this was to show how a simple goal can be achieved, what basic things are needed and how to fit it all together by doing the simplest thing that would work (a mantra from the agile world).

Here’s the post (slightly edited to put back some of the original context):

Okay - Let's step back and show the whole thing from text box to database. NOTE: that this example shows everything in one place. This is generally considered poor practice, but as you are only just starting I'll not burden you with the principles of layered architecture and the single responsibility principle and so on. (Just be aware they exist and one day you'll have to learn about them)

So, let's say you have a form with two text boxes, one for a name, and one for an age. Lets call them NameTB and AgeTB. The user can enter information in these text boxes and press a button that adds them to the database.

First, we need to get the data from the text boxes into a form we can use.

string name = NameTB.Text;
int age = Convert.ToInt32(AgeTB.Text);

Since text boxes only deal with strings we have to convert the string into a number (an Int32 - a 32bit integer) for the age value.

Now, we need to set up the database connection and command in order to insert this. I'll assume you already have a connections string to your database, I've called it myConnectionString for this example.

SqlConnection myConnection = new SqlConnection(myConnectionString);
SqlCommand myCommand = new SqlCommand("INSERT Person(NameField, AgeField) "+
    VALUES (@nameParam, @ageParam)", myConnection);

I've now set up the SQL Command with an insert statement. I've assumed there is a table called Person and it has two columns called NameField and AgeField. I'm also going to insert the values via parameters, which I've indicated with @nameParam and @ageParam. SQL Server requires that all parameter names start with an @ symbol. Other databases may vary.

myCommand.Parameters.AddWithValue("@nameParam", name);
myCommand.Parameters.AddWithValue("@ageParam", age);

We've now added the parameters into the SQL command and we've given each parameter the value we got earlier. Finally:

myConnection.Open();
myComment.ExecuteNonQuery();
myConnection.Close();

This opens the connection, runs the INSERT statement and closes the connection again. We're using ExecuteNonQuery because we don't expect any results back from SQL Server. If we were expecting data back (e.g. because we were using a SELECT statement) we could use ExecuteReader (for many rows/columns) or ExecuteScalar (for a single value).

This is a very basic example. I’ve not shown any error checking or exception handling. There is also the implicit assumption that all this code resides inside a button click event, which is considered poor practice for anything but a small or throw away application.

Dynamic Objects in C# 4.0

Colin Angus Mackay — Thu, 04 Jun 2009 00:19:46 GMT

It seems only very recently that I was posting about this wonderful new feature in C# 3.0 called LINQ and its associated language features such as anonymous types, object initialisers and lambda expressions. Soon C#4.0 will be released and it has a host of new goodies to look forward to.

So far I’ve just been dabbling with dynamic types and the dynamic keyword.

C# has been up until this point a statically bound language. That meant that if the compiler couldn’t find the method to bind to then it wasn’t going to compile the application. Other languages, such as Ruby, IronPython, Magik and IronSmalltalk are all dynamically (or late) bound where the decision about where a method call ends up is taken at runtime.

Now if you declare an object as being dynamic the compiler will hold off, just as it would do naturally in a dynamic language. The method need not exist until runtime. The binding happens at runtime. If, like me, you rely heavily on intellisense to figure out if you are doing the right thing then you are going to have to get used to not having it. Since the call will be bound at runtime the compiler (and of course intellisense) won’t know whether a binding is valid or not. So, instead of regular intellisense you get a message simply saying “(dyanmic expression) This operation will be resolved at runtime.”

So, how do you get started with dynamic objects? I suppose the simplest example would be an object graph that is built at runtime that would normally have a fairly dynamic structure, say a nice XML file.

In this example, I’m going to take an XElement object (introduced in .NET 3.5) and wrap it in a new object type I’m creating called DynamicElement. This will inherit from DynamicObject (in the System.Dynamic namespace) which provides various bits of functionality that allows late binding.

using System.Dynamic;
using System.Linq;
using System.Xml.Linq;

namespace ColinAngusMackay.DynamicXml
{
    public class DynamicElement : DynamicObject
    {
        private XElement actualElement;

        public DynamicElement(XElement actualElement)
        {
            this.actualElement = actualElement;
        }

        public override bool TryGetMember(GetMemberBinder binder, 
            out object result)
        {
            string name = binder.Name;

            var elements = actualElement.Elements(name);

            int numElements = elements.Count();
            if (numElements == 0)
                return base.TryGetMember(binder, out result);
            if (numElements == 1)
            {
                result = new DynamicElement(elements.First());
                return true;
            }

            result = from e in elements select new DynamicElement(e);
            return true;
        }

        public override string ToString()
        {
            return actualElement.Value;
        }
    }
}

The key method in this class is the override of the TryGetMember method. Everytime the runtime needs to resolve a method call it will call this method to work out what it needs to do.

In this example, all that happens is that if the name matches the name of a child element in the XML then that child element is returned. If there are multiple child elements with the same name then an enumerable collection of child elements is returned.

In the event that there is no match the method defers to the base class. If the binding fails then a RuntimeBinderException is thrown.

However, if the binding works you can make complex or ugly calls look much easier. For example. This program using the DynamicElement class to read the contents of an RSS feed:

using System;
using System.Xml.Linq;
using ColinAngusMackay.DynamicXml;

namespace ConsoleRunner
{
    class Program
    {
        static void Main(string[] args)
        {
            XElement xel = XElement.Parse(SampleXml.RssFeed);
            dynamic del = new DynamicElement(xel);

            Console.WriteLine(del.channel.title);
            Console.WriteLine(del.channel.description);

            foreach (dynamic item in del.channel.item)
                Console.WriteLine(item.title);

            Console.ReadLine();
        }
    }
}

The program starts off by reading in some XML into a regular XElement object. It it then wrapped up into the DynamicElement object, del.

The variable del is declared as a dynamic which lets compiler know that calls to its members will be resolved at runtime.

The program then uses the dynamic object to very easily navigate the XML. In this example, I’ve used the XML of the RSS feed for my blog.

The output of the program is:

The barrier to entry for creating and using dynamic objects is quite low. It will be quite interesting to see how this new feature plays out.

Many people like the additional comfort that static binding at compile time provides as it means less things to go wrong at compile time. Advocates of dynamic binding often argue that if you are doing TDD then the tests will ensure that the application is running correctly.

Of course, dynamic binding, like any other language features, is open to abuse. I fully expect to see on forums examples of people who are using it quite wrongly and getting themselves into a terrible pickle as a result. This does not mean that dynamic objects are bad, it just means programmers need to learn how to use the tools they have correctly.

Caveat Programmator: This blog post is based on early preliminary information using Visual Studio 2010 / .NET Framework 4.0 Beta 1

Rant of the day: IDisposable

Colin Angus Mackay — Tue, 28 Apr 2009 18:35:30 GMT

My colleagues are probably used to the fact that I rant about code quality frequently. I take code quality very seriously. Not because I'm especially expert in it, but because features of basic code quality make it easier for other people to read and maintain the code.

Today's irritation comes from some code (replicated in a number of classes I might add) that implements IDisposable. It is a fine interface and by implementing it you are telling the rest of the world that you have some stuff that can't just be left to the garbage collector to clean up. These are things like file streams, database connections, etc. Any type of scarce resource that you want to hand back as soon as you are finished with it rather than leave it up to the garbage collector.

However, I came across this "gem" in some code today where the class, basically a utility class, contained no fields (so it wasn't holding on to anything at all, let alone anything that might be a scarce resource). Yet, for some reason it implemented IDisposable. What was it going to dispose? What could it dispose?

The answer was in the code:

public void Dispose()
{
    // Nothing to dispose of.
}

Quite!

The StackOverflowException

Colin Angus Mackay — Sat, 28 Mar 2009 00:14:41 GMT

Take a look at the following code:

class Program
{
    static void Main(string[] args)
    {
        try
        {
            RecurseForever();
        }
        catch (StackOverflowException)
        {
            Console.WriteLine("Caught Stack Overflow Exception");
        }
        catch (Exception)
        {
            Console.WriteLine("Caught general Exception");
        }

        Console.ReadLine();
    }

    static void RecurseForever()
    {
        RecurseForever();
    }
}

What do you think the output of the program will be?

If you had asked me a few days ago I'd have said the output would be "Caught Stack Overflow Exception", however that isn't the case. If you run the code in the debugger this is what you actually get:

The exception simply isn't caught.

If the application isn't being debugged it will simply end at this point. It goes directly to jail. It does not pass GO. It does not collect £200.

ASP.NET MVC Framework Preview - A review

Colin Angus Mackay — Sun, 28 Dec 2008 19:56:39 GMT

I've just finished reading Steven Sanderson's book ASP.NET MVC Framework Preview published by APress. While the book was short I felt it did give me a bit of an introduction to ASP.NET MVC. Although I have to admit that I could have probably got that from reading a number of articles.

The book is split in to a number of areas that could be summarised as Why? How? and Where? The Why? (chapter 1) describes why you would want to use ASP.NET MVC over traditional ASP.NET*. The How? (chapter 2) describes how you would create a web application with ASP.NET MVC and the Where? (chapter 3) describes the other architecture that ASP.NET MVC fits in with. Then, finally, there is an appendix that describes some of the new language features of C# 3.0 and I felt that this was added just to try and bulk the book out a little bit.

I have to admit that when I first opened the package containing the book I was a little disappointed by the size. When I opened the book I was more disappointed when I saw that, conversely, the font size was larger than I was expecting too.

If you already have an idea that you want to use ASP.NET MVC and why then chapter 1 can easily be skipped. If you are already familiar with n-tier development, ORM, IoC, unit testing and so on then chapter 3 can be skimmed quite quickly. That leaves the real meat of the book just in the 30 pages that is chapter 2.

Despite all the negative things that I have said up to this point, I rather like Steven's writing style. It is clear and and easy to follow. There are a fair number of footnotes for clarification or to point you off in the direction of more information that is outside the scope of the book. He's given enough information that a person could confidently make a stab at creating a starter application using ASP.NET MVC without too much trouble.

In short, I'm looking forward to Steven Sanderson's 500 page and hopefully much more in depth Pro ASP.NET MVC book coming out in January 2009.

* I think this is where terminology is going to get slightly confusing. We already talk about "Classic ASP" when referring to ASP as it was before .NET came along. Now we have "Traditional ASP.NET" to refer to ASP.NET before MVC. Of course, traditional ASP.NET isn't going away, just as the traditional songs I was taught at school haven't gone away just because a bunch of rock-stars have come along and created new songs. (I was going to say pop-stars, then I realised they don't tend to write their own songs these days)

Technorati Tags: ASP.NET MVC,MCV,APress,book review

New article on Code Project

Colin Angus Mackay — Sat, 06 Dec 2008 17:40:02 GMT

It has taken a while, but I finally got around to putting another article up on Code Project. The article is based on a series of blog posts (Finding things with Virtual Earth, Using PushPins with the Virtual Earth ASP.NET control, and Drawing lines on the map with the Virtual Earth ASP.NET control) that I wrote on the subject on ASP.NET Controls for Virtual Earth. However, it is updated and includes extra information on Polygons that wasn't in my original blog post series.

You can find the article here: Data Visualisation with Virtual Earth ASP.NET Controls

Technorati Tags: Virtual Earth,Code Project,.NET,ASP.NET

Formatting dates the hard way

Colin Angus Mackay — Tue, 02 Dec 2008 20:03:25 GMT

I was doing a bit of a code review and I spotted this in the code base.

string[] splitOptions = new string[1] { dayEarlier.Date.Year.ToString() };
string[] earlyDates = dayEarlier.Date.GetDateTimeFormats();
string[] earlySplit = earlyDates[67].Split(splitOptions, StringSplitOptions.RemoveEmptyEntries);
earlySplit[0] = earlySplit[0].Replace(",", string.Empty);

Essentially the code gets the date in a specific format. However, it does it in the oddest most convoluted way I’ve ever seen. Just to explain, here is the code again but this time I've added some comments:

// dayEarlier is a business object with a property called Date that returns a DateTime.
// splitOptions will contain the year in an 1-element string array.
string[] splitOptions = new string[1] { dayEarlier.Date.Year.ToString() };

// earlyDates will contain the dayEarlier Date in umpteen different formats.
string[] earlyDates = dayEarlier.Date.GetDateTimeFormats();

// earlySplit will contain the 68th (!) formatted date (out of 89 that get generated). 
// Element 0 in this array will contain the bit upto the year, element 1 will contain 
// the bit after the year. The year itself is discarded.
string[] earlySplit = earlyDates[67].Split(splitOptions, StringSplitOptions.RemoveEmptyEntries);

// The first element (element 0) of earlySplit is then modified to remove the comma.
earlySplit[0] = earlySplit[0].Replace(",", string.Empty);

In short, what is actually being looked for is the day name, day of the month and the month. That’s it. And that, apparently, isn’t even in the 89 permutations of the date that .NET generated in the second line of code. To add to the potential problems with this, I've not seen any documentation that states that the permutations given by this method will stay the same.

All this code could easily be re-written simply as:

dayEarlier.Date.ToString("ddd dd MMM");

And the bonus here is that we are not generating 88 completely useless permutations, nor are we generating the permutation that is simply the closest match that we still have to futz around with. We are generating the date in exactly the format that we want. (Current culture permitting)

Technorati Tags: C#,DateTime,ToString,date format,.NET

An Introduction to ASP.NET MVC

Colin Angus Mackay — Wed, 24 Sep 2008 13:18:49 GMT

[More details and registration]

16th October 2008 at 19:00 in Edinburgh

Today, ASP.NET webforms is a well established and highly productive platform for building web applications. Some people though, crave more control. They want to operate that bit closer to the metal, enjoy a clear separation of concerns and ensure that unit testing their application is made as easy as possible.

Enter ASP.NET MVC. ASP.NET MVC enables you to build Model View Controller (MVC) applications with the ASP.NET framework as an alternative to ASP.NET webforms.

In this session we'll take a look at the drivers behind MVC, the architecture of a typical ASP.NET MVC application, new features in ASP.NET that make it possible and we'll build a simple ASP.NET MVC application to explore the key concepts.

Speaker Bio

Mike Ormond gained a BSc(Hons) in Information Engineering from the University of Strathclyde before moving south of the border many years ago. After spending some time with the Defence Research Agency, Mike joined Mars Electronics where he worked on automated payment systems. In 1996 he joined Mercury Interactive before heading over to Microsoft in 1997 to work in their developer support organisation.

In 2003 he joined the Developer and Platform Group as a Developer Evangelist. Since then he’s travelled the length and breadth of the land talking about Microsoft’s platform and developer tools. Currently Mike’s interests include ASP.NET, AJAX, Silverlight and developing solutions with Office Open XML.

When he’s not working, Mike likes to potter in his allotment and listen to Radio 4 on the wireless.

You can contact Mike at: http://mikeo.co.uk

[More details and registration]

Technorati Tags: asp.net,asp.net mvc,.net,microsoft,mvc,edinburgh,scottish developers.