c pound

Asymmetric Accessor Accessibility

Dan Koster — Wed, 20 Dec 2006 23:10:00 GMT

Asymmetric Accessor Accessibility means you can do this:

public string Name

{

get { return this.name; }

protected set { this.name = value; }

}

Is that cool, or what! There a few caveats, so be sure to read the Language Spec page on this topic.

Fall is here

Dan Koster — Thu, 31 Aug 2006 13:16:00 GMT

I can feel it. I was running the other day, The Distance playing in my ear-buds, and I caught a whiff of it. The scent of rain and plants and cold pavement and other things I can’t remember, a barbeque, maybe. The sun was shining, the clouds were awesome. I had clear road in front of me and nothing to do but run. I had to laugh – a bit maniacally, I admit. Then the moment passed and all returned to the way it was. But, oh yes, fall is here.

Traced Debug Line

Dan Koster — Wed, 23 Aug 2006 19:35:00 GMT

Bloody useful, this code. Especially when threads or timers are involved.

class Tracer

{

private Tracer() { }

public static void WriteTracedDebugLine(string message)

{

StackTrace stack = new StackTrace();

string caller = stack.GetFrame(2).GetMethod().Name;

string callee = stack.GetFrame(1).GetMethod().Name;

if(message != null && message.Length > 0)

Debug.WriteLine(message, caller + " -> " + callee);

else

Debug.WriteLine(caller + " -> " + callee);

}

Asynchronous Anonymous Methods

Dan Koster — Mon, 21 Aug 2006 15:17:00 GMT

Anonymous methods are a great new feature in .Net 2. Another great new feature is the ParameterizedThreadStart delegate. Since the ParameterizedThreadStart delegate is just a delegate, these two concepts can be combined to effectively create an asynchronous anonymous method – an anonymous thread, if you will. You can spin off a chunk of code to run asynchronously without having to put it into a separate function. Check out the following code:

private void AddAsync(int a, int b)

{

//Define the code we want to run asynchronously.

// Note that an anonymous delegate works just

// as well as a ParameterizedThreadStart

Thread t = new Thread(delegate(object paramArray)

{

//get the data we passed into the thread

object[] param = paramArray as object[];

//do your long-running process here (this part runs asynchronously)

Thread.Sleep(1000);

int result = (int)param[0] + (int)param[1];

//when we're done with our asynchronous processing, hit the callback function

this.Invoke(new AdditionDoneDelegate(AdditionDone), new object[] { result });

});

//start running the asynchronous code

t.Start(new object[] { a, b });

}

private delegate void AdditionDoneDelegate(int result);

private void AdditionDone(int result)

{

//this gets called when your asynchronous processing is done

MessageBox.Show(result.ToString());

}

Another cool application for this is to create a partially asynchronous function. You can enclose a long running data access operation, for example, within an anonymous thread and use a non-blocking wait (a mutex) to keep the rest of the function from running until the operation is complete. That’s right, you can make just part of your function run asynchronously:

private void AddPartiallyAsync(int a, int b)

{

int result = 0;

Mutex mutex = new Mutex();

Thread t = new Thread(delegate()

{

//do your long-running process here (this part runs asynchronously)

Thread.Sleep(1000);

result = a + b;

//when we're done with our asynchronous processing, release the mutex

mutex.ReleaseMutex();

});

//start running the asynchronous code

t.Start(new object[] { a, b });

//non-blocking-wait here until the thread is done

mutex.WaitOne();

//continue the function here...

MessageBox.Show(result.ToString());

}

Notice that the code inside the anonymous asynchronous method can access variables defined in the surrounding function. I fully expected there to be scoping that would prevent this. But, amazingly, it works. However, I wouldn’t be surprised if this behavior was eliminated in a later version of the framework. Another surprising part of all this is how well the debugger handles it. Simply amazing!

Find SQL Server instances on your network

Dan Koster — Mon, 27 Mar 2006 20:58:00 GMT

Previously, the discovery of what SQL servers exist on your network was quite a task. The general approach involved PInvoke. Yeah. Now, it .Net 2, it's a one-liner. Sweet!

public List<SQLServer> GetServers()
{
    DataTable dt = SqlDataSourceEnumerator.Instance.GetDataSources();

    List<SQLServer> servers = new List<SQLServer>();
    foreach(DataRow row in dt.Rows)
    {
        SQLServer svr = new SQLServer();
        svr.Name = row.ItemArray[0] as string;
        svr.InstanceName = row.ItemArray[1] as string;
        svr.IsClustered = row.ItemArray[2] as string;
        svr.Version = row.ItemArray[3] as string;
        servers.Add(svr);
    }
    return servers;
}

Hmm... I just noticed that they used a singleton with one method instead of just making GetDataSources static. Odd.

Program computers for fun and profit

Dan Koster — Tue, 07 Mar 2006 20:17:00 GMT

Joel likes to run off on little rants right in the middle of an article about whatever. Usually they're great. Sometimes they are dead on:

“If you enjoy programming computers, count your blessings: you are in a very fortunate minority of people who can make a great living doing work they enjoy. Most people aren't so lucky. The very idea that you can "love your job" is a modern concept. Work is supposed to be something unpleasant you do to get money to do the things you actually like doing, when you're 65 and can finally retire, if you can afford it, and if you're not too old and infirm to do those things, and if those things don't require reliable knees, good eyes, and the ability to walk twenty feet without being out of breath, etc.”

ListView Flicker

Dan Koster — Mon, 27 Feb 2006 15:44:00 GMT

The ListView control has a flicker issue. The problem appears to be that the control's Update overload is improperly implemented such that it acts like a Refresh. An Update should cause the control to redraw only its invalid regions whereas a Refresh redraws the control’s entire client area. So if you were to change, say, the background color of one item in the list then only that particular item should need to be repainted. Unfortunately, the ListView control seems to be of a different opinion and wants to repaint its entire surface whenever you mess with a single item… even if the item is not currently being displayed. So, anyways, you can easily suppress the flicker by rolling your own as follows:

class ListViewNF : System.Windows.Forms.ListView
{
    public ListViewNF()
    {
        //Activate double buffering
        this.SetStyle(ControlStyles.OptimizedDoubleBuffer | ControlStyles.AllPaintingInWmPaint, true);

        //Enable the OnNotifyMessage event so we get a chance to filter out
        // Windows messages before they get to the form's WndProc
        this.SetStyle(ControlStyles.EnableNotifyMessage, true);
    }

    protected override void OnNotifyMessage(Message m)
    {
        //Filter out the WM_ERASEBKGND message
        if(m.Msg != 0x14)
        {
            base.OnNotifyMessage(m);
        }
    }
}

Send a command to a console window (cmd.exe)

Dan Koster — Mon, 27 Feb 2006 15:09:00 GMT

Easy but with a couple little catches. If you need to do this, I recommend reading the help on the various properties of ProcessStartInfo. This code runs a console window that is visible to the user. There is a way to run commands by cmd.exe without actually showing a window... and I'm sure you can figure that out if you're interested enough. This should getcha started.

//set up to show a console window and send input to it
string pathToCmdExe = Environment.GetEnvironmentVariable("COMSPEC");
ProcessStartInfo psi = new ProcessStartInfo(pathToCmdExe);
psi.RedirectStandardInput = true;
psi.UseShellExecute = false;

//open the console windown
Process console = Process.Start(psi);

//send it a command
console.StandardInput.WriteLine("dir");

//TODO: Send more commands, read the results, etc.

//close the console window
console.Close();

Random Photography

Dan Koster — Tue, 14 Feb 2006 19:43:00 GMT

It’s been too long. I can’t believe it’s been over a month since I did a post here. Well, that’s not actually true. I’ve posted a few random photos from my phone. I’ll probably post a whole lot more of those because it’s such an interesting and fun medium. You don’t have to worry about image quality (it’s guaranteed to be bad) so you’re free to focus on composition. Just catch some interesting light or an unusual angle and Blam! You’ve got a cheap (free), modern, lazy form of impressionism… if you will. Actually most of the photos are awful and only make sense to about three people. But hey it’s fun, easy, and no paint stains. Brilliant! Also, if you’re feeling particularly adventurous (and you don’t mind lugging a scanner around) you can make some really… really… well, just go check out the web site. It’s cool stuff.

Arcane Asynchronous Invocation

Dan Koster — Thu, 05 Jan 2006 21:12:00 GMT

Say you want to call a method on a control on your form from a thread... For example, you might want to populate a ListBox with a lot of data or with data from a really slow data source. In these cases you'll probably be using a seperate thread to get the data because it's generally a Bad Idea to block (freeze) your UI while you wait for all the data to come in. Especially if the data is of an indeterminate length. So, one way to get at that ListBox from a seperate thread it is to use Control.Invoke:

private void StartAsynchLoad()
{
    this.lstDatabases.Items.Clear();
    //load the databases asynchronously
    Thread t = new Thread(new ThreadStart(LoadDatabasesThread));
    t.Start();
}

private void LoadDatabasesThread()
{
    //load the databases into the listbox
    string dataSource = this.txtServer.Text;
    string [] names = DataAccess.Instance.GetDatabases(dataSource);
    foreach(string name in names)
    {
        this.Invoke(new AddItemDelegate(AddItem), new object[]{name});
    }
}

private delegate void AddItemDelegate(string text);
private void AddItem(string text)
{
    this.lstDatabases.Items.Add(text);
}

The way things are done

Dan Koster — Thu, 05 Jan 2006 14:43:00 GMT

So, what if you need to pop up a dialog box that could potentially abort the application before you pop up your main form? There are usually no good reasons to construct objects that you don't intend to use. That would include opening a Form which will immediately be closed. But is the following acceptable? I know it's possible... I'm doing it. But what could go wrong in this situation? This must be bad in some way that I haven't found yet.

[STAThread]
static void Main()
{
    //let the user choose a database before we start the program
    DialogResult dr = frmDatabases.Instance.ShowDialog();

    if(dr == DialogResult.OK)
        Application.Run(new frmMain());
}

Angst fueled progress

Dan Koster — Tue, 20 Dec 2005 18:04:00 GMT

So, I don’t really have anything to write about that wouldn’t be a rant about boredom, job satisfaction, ridiculous inefficiency, or one of the other states of the various affairs with which I am associated at this juncture. I wish I could post some cool code samples, but that would imply that I had actually written some interesting code lately… which I haven’t. But never fear, all this lack of momentum has prompted me to take much more of an interest in my side projects, which were all previously on hold. I have two main projects in mind which should be pretty slick. They should also generate some interesting bloging material before long. Stay tuned... cool stuff is to coming soon!

Mahna Mahna

Dan Koster — Tue, 13 Dec 2005 13:34:00 GMT

doo doooo da doo doo! http://www.devilducky.com/media/7452/

Thing-a-beauty

Dan Koster — Mon, 05 Dec 2005 13:13:00 GMT

... and I'd probably be heading back today, if only my car wasn't in the shop

[Vista Express web-cam pic from this morning]

Ending on a high note

Dan Koster — Mon, 05 Dec 2005 13:06:00 GMT

So... last week I got a new job, had a great day of snowboarding, finished the book I was reading, and saw a good movie with one of my roommates. What a great way to end the week.