I, Codemonkey

C# Extensions and Casting

Chas Williams — Sun, 07 Oct 2007 20:24:53 GMT

One of the things in VS 2008 that has intrigued me has been Extension Methods. I've been trying to think of ways to use these in my applications and coming up with ways to move functions associated with various processes to Extensions in our own APIs. ScottGu recently posted an interesting article on his weblog about writing an Extension for creating JSON.

One thing I dislike doing and have to do fairly often is cast Object sender to various things to pull information out of it. The most common reason to do this is that I'm making my buttons dynamically and I need to know which button was pressed so that I can have the program act accordingly. Usually I do something like this:

Button b = (Button)sender;

Then grab something out of it like b.Text and use that value.
I dislike this because the casting is just straight up, no holds barred, you were one thing and now you're this. And, if I'm wrong I throw an exception. So, I should be doing some checking, some Exception handling, and what have you. But, I really don't want to clutter up the code with all that since the Event is only tied to these buttons. Of course, a nagging in the back of my mind asks if it will always be that way (probably) and another nagging asks if I'm compromising my ethics by not doing these checks.

Then along comes Extension methods in the VS 2008 (Orcas) Beta. I can do basically the same things using Extensions but hide some error checking behind the scenes without having to write the code over and over. I can also update my casting method in one place and it will be changed everywhere, because right now it is very basic. Here's what I have so far:

        public static Button AsButton(this object o)
        {
            if (o is Button)
                return (Button)o;
            return null;
        }

Then in the forms code:

        Button btn = sender.AsButton() ?? new Button();

This is, of course, very simplistic, but it does allow me to create a place where I can handle this casting in one place, something I am very fond of doing. Although I'm still contemplating whether or not returning null is the right answer. Basically what I'm saying is that it will always have to be a Button, and if it isn't a button... then its a Button. I'm not sure if I like that. But, that's not the the functionality of the Extension doing that, so what I do with that returned null can vary from place to place.

You made my program the SHELL???

Chas Williams — Sun, 19 Aug 2007 19:06:39 GMT

So, a while back I created what I consider a neat .NET program. It opens a remote desktop session to a Virtual Machine we have running on VMWare and logs into the machine. Then, if the remote session is closed, it shuts down the computer. It did have the downside that the remote session could, of course, be minimized and the users could access the computer. We've got some Neoware boxes now, but these were good for some training sessions we were doing throughout the company.

In any case, I found out today that the shells of all these laptops had been replaced by my program. That means no taskbar, and it pretty much locks out the computer completely. But, I swear, I swear! that nobody had told me about this change. It took me about 20 minutes before I gave up trying to fix one of these laptops and asked, only to be assured that I had agreed to this crazy idea. It's pretty cool, I have to admit. But, now getting the computers back is going to be a pain. And, here I thought the program could just be removed from Windows Startup folder.

Acronis, here I come!

Custom Exceptions and Exception Wrapping

Chas Williams — Tue, 03 Jul 2007 14:05:26 GMT

I work almost only with code written by predecessors at my job. There's good code and bad code. Recently, I've been trying to clean up the exceptions. Just about everything is throw Exception(<my message here>) instead of customized exceptions, so you never really know what you're catching. It could be an IO exception, a null pointer, or whatever. The message is generally something that can be displayed to the user without them becoming confused, but with a mix of "good" message exceptions and "bad" ones (for example something generated by SQL), its impossible to dig through them and see what I need and what the user needs.

So, while consolidating much of this into an error handling class that will aid us both, I've been looking into creating my own exceptions and going over some code I've never really had a chance to examine before. I'm starting with database access because that's been the biggest problem for me in this regard. Here's a snip of part of our back end that opens a database connection with some stuff cut out to make it more readable.

        /// <summary>
        /// Open the database.
        /// </summary>
        /// <param name="tDatabaseType">Which database to connect to</param>
        public void Open(DBType tDatabaseType)
        {
            try
            {
                _Connection.Open();
                _Command = new OleDbCommand();
                _Command.Connection = _Connection;
            }
            catch(Exception ex)
            {
                _lastError = ex.Message.ToString();
            }
        }

I didn't even realize until now that there was no exception being thrown when it can't connect to the database. This isn't how I'd like to do things, especially considering that I want to centralize exception handling. This way, the connection never happens, but I don't know that unless I either check _lastError or until I try to use the connection and get an exception thrown at me. First, I'm going to create my own custom exception.

using System;
using System.Runtime.Serialization;
using System.Collections.Generic;
using System.Text;

namespace DecoCore.Err
{
    [Serializable]
    public class DatabaseNotFoundException : Exception
    {
        /// <summary>
        /// The database could not open a connection
        /// </summary>
        public DatabaseNotFoundException()
            : base()
        {
        }
        /// <summary>
        /// The database could not open a connection
        /// </summary>
        /// <param name="sMsg">Message displayed to user</param>
        public DatabaseNotFoundException(string sMsg)
            : base(sMsg)
        {
        }
        /// <summary>
        /// The database could not open a connection
        /// </summary>
        /// <param name="sMsg">Message displayed to user</param>
        /// <param name="eInnerException">exception causing this exception</param>
        public DatabaseNotFoundException(string sMsg,
            Exception eInnerException)
            : base(sMsg, eInnerException)
        {
        }
        /// <summary>
        /// The database could not open a connection
        /// </summary>
        /// <param name="info"></param>
        /// <param name="context"></param>
        protected DatabaseNotFoundException(SerializationInfo info,
            StreamingContext context)
            : base(info, context)
        {
        }
    }
}

Very simple and straightforward. Now, what I'll do is go back to the first code block above, the one that opens a connection to a database supplied to it through an enumeration.

        /// <summary>
        /// Open the database.
        /// </summary>
        /// <param name="tDatabaseType">Database Type</param>
        public void Open(DBType tDatabaseType)
        {
            try
            {
                _Connection.Open();
                _Command = new OleDbCommand();
                _Command.Connection = _Connection;
            }
            catch (OleDbException ex)
            {
                _lastError = ex.Message.ToString();
                throw new DatabaseNotFoundException("Could not connect to the database.", ex);
            }
            catch (Exception ex)
            {
                _lastError = ex.Message.ToString();
                throw;
            }
        }

Luckily for me, every call to Open is already in a try/catch even though it didn't throw an exception previously.

Now when I get to call my error handler after this propagates up, I know there was an exception thrown and I know exactly why it was thrown. The user doesn't get strange SQL errors displayed, instead they get a simple "Could not connect to database" which they will understand, and I can now, very importantly, extract the underlying OleDbException from the DatabaseNotFoundException and get the debugging information I need for proper logging of errors.

Nested String Statements

I, Codemonkey — Mon, 25 Jun 2007 13:11:27 GMT

Here's a strange one. Last night I had a dream about nested strings. The most obvious use of this would be in a nested SQL statement, so here's a made up on the fly example:

select phone_number
from Addressbook
where name = (select name from customers where city = 'Atlanta')

But instead of writing that out as a string in my code, I did this crazy thing:

string sQuery = "select name from customers where city = 'Atlanta'";
sQuery = " select phone_number from Addressbook where name = (" + sQuery + ")";

Mostly, I would never use that. It's far too difficult to go back and read later. However, I got to thinking and it might be interesting to use that with a dynamically created SQL statement. Say I was going to do a phone look up, but I wasn't sure what I was going to do the test against, I could use this little pattern. That way I could do a lookup versus city, zip code, PO numbers, or anything else, and it might actually be easier to read in the future this way than with some kind of nested if statement that creates the SQL through conditional statements.

I'll have to think on this a little more.