Dictionaries in C#: The HybridDictionary

So far we’ve looked at the HashTable collection, and determined that it’s the way to go for large collections. We’ve also taken a look at the ListDictionary, which is geared towards very small collections. But what if you don’t know how big your collection will be?

There are many situations where at design time you simply can not know what the final size of your collection will be. Sometimes it will depend on user input, what range of data the user selects for example. Other times it may be dependant on the data, how much is out there for you to use. There’s enough uncertainty in all our lives to get stressed out, so to keep us calm Microsoft has provided the HybridDictionary collection.

A HybridDictionary will self monitor itself. Initially, and while it remains small the HybridDictionary will internally keep itself as a ListDictionary. Once it exceeds a certain threshold, it will then convert it’s data into a HashTable. The nice part is you don’t have to care when, or what state it is currently in. All you have to know is the HybridDictionary is managing the memory most efficiently on your behalf.

Like it’s sibling the ListDictionary, the HybridDictionary will require a using System.Collections.Specialized reference. After that, it has the same interface as the HashTable and can be treated as such.

HybridDictionary genders = new HybridDictionary();

genders.Add(“M”, “Male”);

genders.Add(“F”, “Female”);

The question many will ask “well why not just use a HybridDictionary all the time?” As with most things in life, there is a trade off. There is a some overhead associated with HybridDictionaries, as they have to constantly monitor their own size, then convert back and forth between ListDictionaries and HashTables as needed. In return, you get the best possible performance from your collection as it changes in size.

The moral of the story, when you know you have a small collection, use a ListDictionary. On the other hand, if you know with certainty your collection will be large, use a HashTable. But for all those other times when you just don’t know, the HybridDictionary is your answer.

Dictionaries in C#: The ListDictionary

Hashtables (see my posts from the last two days ago) are a great, general use type of dictionary, but they have the one drawback of requiring some extra overhead to implement. For very small collections, say 10 items or less, the overhead can have an impact on performance. To solve this, Microsoft has created an alternate form of hashtable called a ListDictionary.

Behind the scenes, ListDictionaries are implemented as simple arrays. For small collections then their performance is very fast. They have the same interface as a hashtable, so it’s very easy to swap from one to another, aside of course from the issue of having to recompile your project.

Before starting, in addition to the using System.Collections reference, you will also need to include a using System.Collections.Specialized reference to the top of your code.

Next, all you have to do is create a variable of type ListDictionary. After that, using it is identical to using a HashTable.

ListDictionary genders = new ListDictionary();

genders.Add(“M”, “Male”);

genders.Add(“F”, “Female”);

Frequently when dealing with collections the size of the collection is quite small. Lists of values for drop down boxes, which hold data for things like employee type, gender, ethnicity, and perhaps ranges of ages are all times when you will have a short list. For those times, when you are certain the list is small, use a ListDictionary to increase the performance of your application.

The Hashtable Demystified

After reading yesterday’s post, one of my coworkers asked me “so what exactly is a hash and how does it work”. Fair question, in my post I concentrated more on how to use the dictionary than what it was, so it does deserve a little explanation.

When you enter a Key as part of the Key/Value pair, you use something human readable like “ArcaneCode”. While good for people, it’s very inefficient for the computer. Thus the .Net Framework runs your key through a sophisticated algorithm called a “hash”.

The output of this hash algorithm is a number, and that number is what the framework uses for the true key to your data. Thus “ArcaneCode” might produce a hash of 1234. It’s very fast for the computer to find your data when it can compare numbers, hence the usefulness of a hash.

The pseudo code below shows the general process a hash table goes through when retrieving your data.

Key is passed in.
Key is converted to a hash.
The collection is searched for a matching hash.
If found, the value in the dictionary associated with the hashed key is returned.

Hashes are unique, no two strings will ever yield the same hash value. Additionally, they are case sensitive. “ArcaneCode”, “ARCANECODE”, “arcanecode” and “aRCANEcODE” all produce different hash values.

The concept of hash tables are not unique to the .Net Framework, many languages have them, it’s just .Net hides the ugliness and makes them easy to use.

Dictionaries in C#: The Hashtable

About a week ago I began talking about collections in C#, and discussed two special cases, the Stack and the Queue. Another group of specialized collection classes are dictionaries. Dictionaries operate off of a key / value system, where you lookup your information, your value, based on a key you create. The key can be a string, number or other type of data, but it must be unique within the dictionary. Just like in your traditional printed dictionary, you can’t have two entries for the same key.

The most basic type of Dictionary is the Hashtable. The hashtable has the basic functionality for putting entries into the dictionary collection, getting a value based on a key, looping through them, and updating or removing them.

Getting data into the hashtable is pretty easy. First make sure to include a using reference to System.Collections, then simply create a hashtable variable, and finally call the Add method, passing in the key and value.

Hashtable myHash = new Hashtable();

myHash.Add(“ArcaneCode”, “arcanecode.wordpress.com”);

To read or update the data stored in the value, you can treat the hashtable as if it were a simple array, using the key where you’d normally put the index.

Console.WriteLine(myHash[“ArcaneCode”]);

myHash[“ArcaneCode”] = “Here I’ve changed the value.”;

Console.WriteLine(myHash[“ArcaneCode”]);

Console.Read();

Hashtables are great for storing data where you have a good primary key you can quickly reference things by. In our example, I’ve stored strings as the value part of the key / value pair, but you can use any type of object for the value, including classes you create.

The examples so far assume you will always want to retrieve a single item out of your hashtable. However, we all know there are times when you will want to iterate over the entire collection. To do this, it’s necessary to understand how your key / value pair is storied.

In keeping with the spirit of OOP, what is actually stored in the hashtable collection is another object of type DictionaryEntry. The dictionary entry object has two essential properties, the Key and the Value, both of which are the generic object type. Here’s an example of how to loop over the myHash collection.

// Clear out the previous items

myHash.Clear();

// Now add some new items.

// Note we use an int as the key this time.

myHash.Add(1, “Item one”);

myHash.Add(2, “Item two”);

myHash.Add(3, “Item three”);

// Loop over the list, writing out the value

foreach (DictionaryEntry myEntry in myHash)

{

Console.WriteLine(myEntry.Value);

}

Console.Read(); // Wait for user to press a key

Note we cycle through a list of DictionaryEntry objects, and each time through get the Value property. If we wanted to get the key, it would be a simple matter of replacing the Value property call with a call to Key.

If you are in a situation where you are not sure of the data types being used in the keys or the values, you should append a .ToString() after a reference to the Key or Value so as not to generate run time errors when displaying. In the above example, we’d have needed to use Console.WriteLine(myEntry.Key.ToString()); since our keys were integers (1, 2, and 3).

As you can see, the hashtable makes it easy to look up values when you have a specific key, yet at the same time is still flexible enough to allow you to iterate over your entire collection when you need to.

Arcane Searches

I thought it was time for another round of Arcane Searches. In case you missed the last round, these are some of the search terms users entered into their search engine and managed to run across my blog. I’ll try to pick out a few that seem to occur frequently and answer them. Let’s get started.

ssis package not reading environment variables

There is a policy setting on the server that dictates whether or not the SQL Server job engine can access environment variables.

virtual pc exit fullscreen

To exit full screen mode, use the Right ALT+ENTER combination. Note that the left ALT key won’t work, you must use the right ALT key, with the Enter key.

connectstring SQL compact, connectionstring sql compact edition

These two show up frequently, the connection string for SQL Server Compact Edition (SSCE) is:

Datasource=”C:\MyData\myFile.sdf”; Password=’mypassword’

Note a few things, first the password part is optional. Second, the password must be enclosed in single quotes. Finally, the path to your sdf data file must be in double quotes.

wrap a string in double quotes c#

I’m guessing the search here is how to embed a double quote in a string, that’s easy. Just use a backslash in front of the double quote, and C# will interpret it as a literal character and not a double quote.

string myvar = “Right before he became unconscious, he said \”Yes dear, those pants to make you look fat.\”. “

virtual pc 2007 different ip addresses

Each Virtual PC, be it 2004 or 2007, appears as it’s own PC to the network. Your network hub can’t tell the difference between a virtual machine and a real one, and assigns each machine it’s IP address.

why would I use an interface C#

Why not? OK, sorry, couldn’t resist. Short answer, an interface gives you a way to treat many kinds of objects as if they were all the same kind of object. For example, if you had manager, field worker, office worker, and executive objects, you could have all of the implement the employee interface, then you could treat them all like generic employees to do things like pay, give vacation, etc.

For a more detailed instruction, see my series of posts which begin at https://arcanecode.wordpress.com/2007/02/13/more-oop-interfaces-in-c-part-1/ or http://shrinkster.com/mjk.

There you go, a quick selection of the most common searches I found, that were not already answered in my previous blog entries.

Arcane Thoughts: Go Wildcats

By now many of you are aware of the devastating tornadoes to hit the state of Alabama, mostly in the Enterprise area. I reside in Alabama, currently near Birmingham but Enterprise is my home town. I graduated from Enterprise High, and my niece is currently a senior there, and was in the school today when the tornado hit. She got hit by some debris when the ceiling partially collapsed, but wasn’t injured thank goodness.

Somewhere between 8 and 15 others weren’t so lucky, and lost their lives (as I write this there are conflicting numbers and it’s unknown if they were students or not). What you can learn from this though, is to be prepared. Weather radios are not expensive, every home should have one (I do!). They will alert you to a variety of severe weather conditions, especially during the night when you might be asleep or not listening to the radio / TV.

Have a designated spot in the house to go when severe weather strikes. For us it’s a spot in our basement. We all know it, and are prepared for it. If you have kids, grab their bicycle helmets and put them on them. Our local meteorologist James Spann mentioned that a good number of the kids who are killed in storm events suffer head trauma, and the helmet could save their lives.

What can you do now? Well those folks in Enterprise are going to need a lot of help. If you can, donate blood, I understand there is a shortage now. Money is good too, and can help with the rebuilding. This is going to be a tough time, but I know that as time goes buy they will rebuild and bounce back. Enterprise High, Home of the Wildcats.

Go Wildcats!

Saving All Attachments in Outlook

Back on January 3’rd, 2007 (https://arcanecode.wordpress.com/2007/01/03/enhancing-the-save-attachments-outlook-macro/ or http://shrinkster.com/mhm) I posted a useful macro that would save attachments on the selected items in a folder. Since then several have written asking for a version that would save all attachments for every item in a folder, whether it was selected or not.

UPDATE: Some users were having problems downloading the code, so I’ve posted it at: https://arcanecode.com/2011/07/16/revisting-the-outlook-save-all-attachments-macro/

I finally had a chance to experiment, and it turned out to be very easy. To create a version that saves attachments for all items, you only have to change three lines of code.

The first line is the name of the sub. I changed

Public Sub SaveAttachments()

Public Sub SaveAllAttachments()

Easy enough. Next, the variable declaration of

Dim Sel As Outlook.Selection

Has to be changed to

Dim Sel As Outlook.Items

The final change is to

Set Sel = Exp.Selection

It becomes

Set Sel = Exp.CurrentFolder.Items

And that’s it, it works. Let me explain what’s happening. In the original, I was cycling through the Selection collection of the Outlook Explorer object. The Selection is a special type of Items collection that holds what’s selected.

For our new macro we wanted all of the items in the current folder, not just what was selected. The first thing we had to do, after changing the sub’s name, was to change the data type of the Sel variable. I wanted to get away from the specific selection collection to the more generic items collection.

Then, all I had to do was have the Sel point to the Items collection of the current folder. Since both Selection and CurrentFolder.Items both support the Items interface, everything else just worked. That’s the power of OOP!

I’ve uploaded a new version of the file as Save All Attachments. It contains this version, the original SaveAttachements, and the GetOutputDirectory function. If you are installing this new, please don’t forget to set a reference to the Microsoft Scripting Runtime Library (scrrun.dll).

Select Tool, References from the VB Macros Editor. Scroll down until you find Microsoft Scripting Runtime, and check it. You’ll know it’s the right one when the file name is scrrun.dll.

I’ve tested this with messages stored in a variety of folders, including the Inbox. It’s based off the current folder, so it doesn’t seem to care where you are at. I’ve also gotten this to work with the calendar as well.

There you go, you now have a choice. Using my original macro you can save attachments for only the selected items in the current folder, or using this version you can save all attachments for all items in the current folder. I hope the folks who requested the change will find this fits their needs, enjoy!

What to do with Ubuntu

OK, you’ve now installed Ubuntu under Virtual PC or on your spare machine, or perhaps as your main computer. If you are a “newbie” to Ubuntu, as am I, you might want some suggestions on things you can do with your spiffy new OS. Never fear, I have scoured the web and found some sites and other blogs with some good suggestions.

Linux on Desktop: 13 Things to do immediately after installing Ubuntu.

http://linuxondesktop.blogspot.com/2007/02/13-things-to-do-immediately-after.html or http://shrinkster.com/mgd

Has some really useful suggestions on some basic things you will want to do to make you Ubuntu experience more enjoyable.

Ten Tips for New Ubuntu Users

http://www.linux.com/article.pl?sid=06/06/08/1651225

Just as it says, some useful tips for those new to Ubuntu.

Check out the Ubuntu Forums

http://www.ubuntuforums.org/

Lots of good info and a good community to ask questions and learn more.

LinuxReality

http://www.linuxreality.com/

A great podcast on Linux. Chess Griffin does a really good job with lots of info, including (search the archives) a three part introduction to Ubuntu.

Mono

http://www.mono-project.com/Main_Page

If you are here, most likely you have some interest in .Net development. Mono is the open source project to allow you to do .Net development on the Linux platform. Check out the Mono pages for more info on .Net programming in Ubuntu.

Installing Ubuntu 6.10 on Virtual PC 2007 Step by Step

Update April 24, 2008 – The newest version of Ubuntu, 8.04 is out. Look for complete install instructions here.

Update: October 18, 2007 – Ubuntu 7.10 is now out, for full instructions on installing it, see
https://arcanecode.wordpress.com/2007/10/18/installing-ubuntu-710-under-virtual-pc-2007/

Note: If you are looking for instructions for version 6.06, see my post at: https://arcanecode.wordpress.com/2006/12/19/installing-ubuntu-on-virtualpc-step-by-step/. There are still good reasons to install 6.06, mostly because it’s the version targeted as the LS, or Longterm Support version. Many companies will likely stick with 6.06 for some time. For the past few weeks I’ve been trying to install Ubuntu 6.10 under VPC 2007, using the standard install model. I’ve come to an important conclusion. It can’t be done. (If you’ve figured out how, leave a comment cluing the rest of us in on it!)

Now, before you become distraught and start with the wailing and gnashing of teeth, note I said “standard install model”. There is a way to get it working.

Before you get started, spend a few minutes getting familiar with VirtualPC if you have not already done so. You can find my step by step instructions for VirtualPC at https://arcanecode.wordpress.com/2006/09/20/virtual-pc-step-by-step/. Keep it handy, at various points I will be referring to it. OK, let’s get started.

First, you need the right installer. Go to the Ubuntu website (http://www.ubuntu.com). Under desktop, click the Download link. Scroll down to the Ubuntu 6.10 area. Click on the region you live in, and find a mirror close to your location. Now, here is the inside trick, instead of “CD Image for desktop and laptop PC’s”, you should instead select “Other installation options”.

~~When the next screen comes up, scroll down to the “Alternate install CD” area. Find the link that says “PC (Intel x86) alternate install CD” and download the ISO it’s associated with.~~ It’s a big download, so be patient.

UPDATE! UPDATE! Ubuntu has changed their site, and so far I haven’t been able to find the alternate cd via their site. For now you can go to http://mirrors.gigenet.com/ubuntu/6.10 and grab the file ubuntu-6.10-alternate-i386.iso. This is the same file I was describing. We now return you to your regularly scheduled blog post…

Note that selecting the right version is the first thing you have to know, but there’s a few other tweaks you’ll have to do during the install process, so keep reading.

Once you have it downloaded, burn it to a CD or use Virtual CDRom Control Panel (see my post https://arcanecode.wordpress.com/2006/09/13/virtualization/) to load it into a drive.

In Step 1 of my VirtualPC Step by Step you are instructed to create a new machine, please do so. I’ve named mine “Ubuntu 6.10”. In step 2, you are prompted for your OS. You will need to pick Other. In step 3, you are asked about Ram. Ubuntu will run OK under 256 megs, however if you have the available space I’d highly suggest upping it to 512, especially if you intend to get into doing some graphics or mono coding. I’ve selected 512 meg for this tutorial.In step 4 you will want to create a new hard disk, and in step 5 confirm what you’ve selected. OK, now you are up to step 6, installing the OS, which is where this tutorial picks up.Your first screen comes up, but before you start pressing buttons there’s one tweak you have to make. So you can see everything correctly during the install, press the F4 (VGA) button. Select a video mode that ends with 16, in my example you can see I changed to 800 x 600 x 16.

Now you can proceed, press enter to start the “Install in text mode” option.

The first screen to come up asks about your language. I took the default of English, but if you are elsewhere please select your language, then press Enter to continue.

Next you are asked for your location. Select your location, or the one closest to you, and press Enter.

Next you are asked to let the installer determine your keyboard. Take the default, Yes, which will take you to the next screen.

You will then be asked to press a series of keys. Here’s the first screen in the series:
On some screens there may be keys you don’t have, if so just wait for the time out.

After going through each screen, you will see what keyboard pattern Ubuntu detected for you. If it’s correct just click Enter to continue, if not you can go back and reselect.

Next Ubuntu will scan for your CD rom, then begin loading components. Just kick back and wait, it will go through all sorts of detection steps as it finds hardware, networking, and more.

If all went well, you will now be asked for a host name. I took the default of Ubuntu, but you are free to change it. Enter your host name, or just hit Enter to continue.

Next Ubuntu will begin detecting your disks and hardware. Be patient. You will then be asked about partitioning disks. This should be a new partition, so take the default by pressing Enter to continue.

The next screen is the first place you don’t want to take the default. It’s asking you to confirm the partition format plan. Use your left arrow to move the red bar (shown below on No) over to the Yes side, then you can press enter.

Wait while Ubuntu formats your drives.

Next you are asked for your time zone. Select it, then press Enter.

Next you are asked if the system clock is set to UTC. I just took the default of Yes, this is easy enough to fix if it’s wrong.

Next you are asked for your name. Note this is not your login user name, but your real name. Ubuntu will use this in your documents and e-mails. I entered a name, and pressed enter to continue.

On the next screen you are prompted for the user name you want. This is what you will enter when you login. Enter something that suits you, then press enter to continue.

If you’ve done this sort of thing before, you’d probably guess Ubuntu wants your password next, and you’d be right. Enter a password and press enter to continue.

Now you are asked to re-enter the password, to confirm. Do so and press enter to go on.

Now sit back and wait. Ubuntu will start installing itself.

After running for a while, you are next asked about video modes. Use the space bar to toggle the modes you want, and use the arrows to move up and down. When you’ve selected the modes you want, press enter to continue. Below you can see I’ve selected a few common modes for my system.

OK, sit back and wait some more, while Ubuntu installs various software packages. This step takes a loooooooooong time.

Ubuntu has completed it’s install. But don’t hit enter quite yet! First, on the Virtual PC menu pick CD, Release Physical Drive Z: (where z is the drive you are installing Ubuntu from). This will let Ubuntu to boot from your newly installed virtual hard drive instead of the CD. After you’ve released the drive, you can hit Enter to continue.

When the system reboots, you will see your login screen, but it’s going to look very trashy. Don’t worry, we’ll fix in a moment.

Key in your user name, and press Enter. You probably won’t be able to read what you are typing so be careful.

If all went well, you’ll now see another garbled screen where you enter your password. Carefully, do so and press enter.

More garbled screens will appear. When it appears as if Ubuntu has loaded (see below, if you look close you can make out the menu across the top), press the CTRL+ALT+F1 key combo.

This key combo exists the graphic interface and puts Ubuntu in text mode. Key in your user ID, then (when prompted) password to login.

You’ll now see a command line, below.
We need to modify your xorg.conf file to change the color depth. First, let’s back it up. Type in this command:sudo cp /etc/X11/xorg.conf /etc/X11/xorg.conf.backupNote to copy it exactly, Linux is case sensitive, so if you were to type in say x11 instead of X11 your command will fail. Also, because you are attempting to run the command as the root user (the sudo part of the command) you will be prompted for your password.

Now that we’ve backed it up, we need to edit it. Type in this command:sudo nano /etc/X11/xorg.confYour new screen should look like this:

Press CTRL+W (Where is) and when prompted key in DefaultDepth and press enter.You should now be landed on DefaultDepth. Cursor over to the 24…

And hit delete twice, then type in 16.
Now hit CTRL+O (WriteOut) to save the file, and press enter to take the default xorg.conf file name. Then hit CTRL+X to exit.

You’re now back at the command prompt. Just type in this command:sudo reboot
and press enter.

Give it several minutes to shut down and restart. If everything worked, you should now see a beautiful, non garbled Ubuntu screen.

Key in your user name and password and you will be logged in to your working copy of Ubuntu 6.10 on Virtual PC 2007!

Virtual PC 2007 Released

Not sure when they slipped this in, but Microsoft has now release Virtual PC 2007. Like it’s predecessor, 2004, it’s still free.

Learn more at http://www.microsoft.com/windows/products/winfamily/virtualpc/default.mspx or http://shrinkster.com/me8

or go directly to the download at

http://www.microsoft.com/downloads/details.aspx?FamilyId=04D26402-3199-48A3-AFA2-2DC0B40A73B6&displaylang=en

or http://shrinkster.com/me7
I’ll keep you updated as to my experiences, please feel free to leave a comment with yours…

Arcane Review: Why Software Sucks

I promised myself I wasn’t going to have a blog filled with a lot of book reviews. But having just finished “Why Software Sucks” by David S. Platt (http://www.amazon.com/Why-Software-Sucks-What-About/dp/0321466756/sr=8-1/qid=1172286512/ref=pd_bbs_sr_1/105-8037691-1992410?ie=UTF8&s=books or http://shrinkster.com/mdg), I find I can’t resist mentioning it.

David S. Platt is a software developer, author, and teacher at Harvard University Extension. However this book is not targeted at the experienced software developer, but instead at the average computer user. He gives the reader a basic knowledge of how software works, so they will know what is possible and what is not. Armed with knowledge about the possibilities of software development, the average joe can then determine when software sucks as opposed to just bumping into current limitations.

One reviewer on Amazon said he “…didn’t find anything new in the book for seasoned UI developers.” That’s a shame, as it shows he clearly didn’t get the point of the book. This book is not targeted at developers. It’s for users, so they will know when you’ve written good software, and when you’re handing them crap.

While it’s true this book is not packed with development techniques, it’s still an important read for any programmer. As a developer with over twenty years experience, what Mr. Platt’s book gave me was insight. To be reminded that the code I write is to be used by people other than developers. He helped me to see my application through the eyes of an average user, or to quote Mr. Platt, “Your users are not you!”

This was not a thick or expensive book, and was filled with enough humor to keep it a quick yet enjoyable read. At the same time it was serious enough to deal with the subject of user interfaces in a meaningful way. After reading this book, I think the best compliment someone will be able to give me about my applications is “it just works!”

For more information see the authors site at http://whysoftwaresucks.com/.

Standard disclaimer, I make no money from book sales, nor have I any financial affiliation with Amazon, the author, David S. Platt, the publisher, the guys who grew the trees that got turned into paper the book was printed on, the truck drivers that delivered the books, the company that hosts the authors website, nor am I the father of Anna Nicole Smith’s baby. Just so that’s all clear.

SSIS, BIDS, and TNSNAMES

Today’s alphabet soup has to deal with an issue we struggled over this week at work. For those unfamiliar, SSIS is SQL Server 2005 Integration Services. It’s the rewrite of SQL Server 2000 DTS (Data Transformation Services). You use SSIS to pull data from one database and put it into another.

You develop SSIS in BIDS, Business Intelligence Developers Studio. BIDS is Visual Studio with the BI tools added in. The issue we’ve been fighting had to do with getting our SSIS packages to use Oracle 10g drivers to talk to the Oracle 9i data source that was the beginning point for our packages.

Over and over we got an error that the OLEDB provider could not “Acquire” the database, yet the data source kept passing the “Test Connection” test. It was one of my associates who came upon the clue.

In our environment, we don’t normally use a TNSNAMES.ORA file. TNSNAMES is where Oracle normally stores information about a schema name. Schema names are kind of like URLs. You use a human readable schema name, something like WAREHOUSE1. Oracle driver then goes into TNSNAMES to find the server information so it knows where to route the data to.

As I said, in our environment we don’t use TNSNAMES, instead we have another file. The data driver looks there to get the server that TNS info is stored at for the whole company. This allows us to have a single place to store (and update) TNS data instead of thousands of workstations.

The problem was, BIDS didn’t like that. Even though we had it redirected, BIDS didn’t recognize that and kept going to the TNSNAMES file to find schema info, and in our case it couldn’t find it because it wasn’t there. Once we added a TNSNAMES file BIDS was able to acquire it’s schema info, connect to the database and get whatever data it needed.

The moral of the story is, if you are having problems in BIDS connecting to an Oracle data source verify that you do indeed have a valid TNSNAMES.ORA file.

Collections in C# – The Stack

Yesterday we looked at the Queue class. The queue is used when you need a first in, first out (FIFO) way to read through your collection. Sometimes though you need to read so that the first item you retrieve is the most recently added item, much like the computer’s stack, or a Pez candy dispenser (http://www.pez.com).

With the stack class, the most recently added item is the first one you pull out. Stacks have a count property and peek method, much like it’s cousin the queue. However, the stack uses push and pop to get items on and off the stack. Let’s take a look.

Stack myStack = new Stack();

myStack.Push(“1. Carl Franklin”);

myStack.Push(“2. Richard Campbell”);

myStack.Push(“3. Mark Miller”);

myStack.Push(“4. Kimberly Tripp”);

myStack.Push(“5. Billy Hollis”);

while (myStack.Count > 0)

{

Console.WriteLine(myStack.Pop());

}

Console.ReadLine();

[Picture of Stack Output Example 1]

As you can see, the pop operation removed the items from the collection in the reverse order from which they were loaded. In other words, the last item on is the first one you’ll be pulling off.

The peek method works just like it does with the queue. Modifying the while loop above thusly:

while (myStack.Count > 0)

{

Console.WriteLine(“Peek: “ + myStack.Peek());

Console.WriteLine(“Pop : “ + myStack.Pop());

}

Produces this output:

[Picture of Stack Output Example 1]

Stacks are handy when you want to keep track of objects that need to be handled in the reverse order, say for creating and disposing. Like queues, stacks enforce reading your data in a specific order. Whenever you have a requirement to read in a LIFO order, the stack class will add the extra safety you need to make your applications work as you designed.

Collections in C# – The Queue

Most .Net developers are familiar with the ArrayList collection. The ArrayList has become a stable in most .Net applications, replacing in most cases the array. But did you know there are other types of collections?

This will begin a series discussing some of the other types of collections available in C#, and how to use them. Most are pretty straight forward, it’s just a matter of getting to know them. We’ll start things off with the queue.

A queue is a type of first in – first out, or FIFO collection. Unlike an array list, you must read things in order. Queues are very structured, you can’t go sifting or randomly plucking data out of the middle of the collection. OK, I can see you out there, scratching your head and asking “well why would I want to use a queue if it’s not as flexible as an arraylist?”

In a way you’ve answered your own question. Because queues are very structured, you can ensure that your application (or consumers of your application) can’t violate your intent.

Queue’s are simple, they have a grand total of three methods and one property. The property, Count, is almost self explanatory. It tells you how many items are in the Queue.

To get data into the queue, use the Enqueue method. Using the Dequeue method will return the next item, removing it from the collection. What if you want to see what the next item is, but don’t want to remove it? You can use the final method, Peek. Let’s take a look at a sample, done as a Console application.

Queue myQueue = new Queue();

myQueue.Enqueue(“1. Carl Franklin”);

myQueue.Enqueue(“2. Richard Campbell”);

myQueue.Enqueue(“3. Mark Miller”);

myQueue.Enqueue(“4. Kimberly Tripp”);

myQueue.Enqueue(“5. Billy Hollis”);

Console.WriteLine(“Count = “ + myQueue.Count.ToString());

while (myQueue.Count > 0)

{

Console.WriteLine(myQueue.Dequeue());

}

Console.WriteLine(“Count = “ + myQueue.Count.ToString());

Console.ReadLine();

This routine prints the following output to the command window:

[Pic of Queue Output Example 1]

As you can see, the Dequeue method returned the items in the same order they were loaded in. There’s really not much to explain, you load objects into the queue using Enqueue (in this case strings), and remove objects using Dequeue.

I also mentioned a Peek method. This allows you to look at the next item without removing it. Here I’ve modified the while loop to first show the next item on the queue using peek, then actually remove it.

while (myQueue.Count > 0)

{

Console.WriteLine(“The next DNR person is:” + myQueue.Peek());

Console.WriteLine(“Dequeuing them……..:” + myQueue.Dequeue());

}

[Pic of Queue Output Example 2]

There are several instances where you may want to use a queue over an array list. Perhaps you are processing messages, or are reading through a list where it’s important you read them in order, say a list of transactions from a database. Data that needs to be processed chronologically could be placed on a queue.

Any time you have data that must be processed in the order in which it was loaded, use a queue. The rigidity of the queue will add an extra layer of safety to your application, ensuring data is read in the order in which you intended.

Arcane Thoughts: Designing for Use

Last week I traveled on business, and the hotel I stayed in had some interesting features that got me to pondering the dilemma of design versus usability. In the bathroom the sink looked like a piece of furniture. Four wooden legs held up a black marble table, atop of which was a large white bowl which was in fact the sink.

Visually, this was quite pleasing, the colors worked well, the contours were pleasing to my eye. The issue came when I tried to actually use the area. There was virtually no counter top area to work with. I had a very tiny space to put my contact lens stuff and my shaving kit. Further, there was no place to sit the hand towel while I was scraping my whiskers or putting my eyeballs in. This was a classic case where the builder went with a design that was visually pleasing over one that was usable.

Another conflict I found was the frosted glass that divided the bathroom from the bedroom. Where the frosted glass pane was located, if someone got up during the night to, well you know, and turned on the light, the light would hit right in the face of the person remaining in the bed. (Since I was alone it was a non issue, but if I’d been with my wife it could have been a problem.) In this case it was something with a design that looked good having negative side effects when put into use.

Lest you think I’m all whiny, there were some good points to the place, such as the closet. When I opened the closet door, the light came on. Didn’t have to think about it, didn’t have to fumble for a switch, it just worked. Simple yet very effective and pleasing.

My point on this post is not to complain about hotel rooms but to get you to think about design versus usability when it comes to your applications. How many websites have you been to that were confusing or hard to use, but visually stunning.

A good example of a bad example is Brown University. (http://www.brown.edu/). If you try to put your mouse over a menu item in an area that is collapsed, that area pops up to show a pretty picture. You then have to slide your mouse up to be able to click on the item you were just hovering on a second ago, before the page helpfully slid the menu up to show you a pretty picture you probably don’t care about. Visually, the effect is cool and the page looks nice, but if you are trying to actually click on a menu option it sucks.

On the other hand, let me mention my favorite site, Google (http://www.google.com). Yes, I said Google. It’s simple, not too much being thrown at you, and it’s obvious what I’m supposed to do (type something in and click Search). Like the light in my hotel room’s closet, it just works.

Windows Presentation Foundation (WPF) included in the new .Net 3.0 Framework gives us some powerful new tools for designing beautiful applications. Like all new technologies, this can be a double edged sword. I hope this post gets you to spend some time thinking about the user experience. Be sure the pretty pictures and cool effects don’t actually get in the way of getting the job done. Spend some time actually using your app. Key in data, do searches, etc. In short, be sure your program isn’t so pretty it’s ugly.