Skip to main content

C# Snippet Tutorial - Dictionary Collections [Beginner]


So, we have all used arrays, and even sometimes a nice HashTable to get things sorted and organized. There are so many uses for an array, and even more for a nice HashTable. But, have you ever noticed that a HashTable is all objects? The Key in each Key/Value Pair is an Object, along with the value itself. But what happens if you don't need something so generic as an object? Well, you can get really specific and really crazy with a collection called Dictionary.

A dictionary is actually just another collection of Key/Value pairs, just like a HashTable, except that you declare a type for the Key and Value. These are any type you want. The Key or Value can be a primitive, array, enum, or even a struture. This can open the door for some pretty crazy code. An example of a useful and simple Dictionary would be something like:
Dictionary<int, string> newDict = new Dictionary<int,string>();
 
This is just a collection of Integer Keys and String Values, so you could add to this Dictionary with loop, like so:
for (int i = 0; i < 10; i++)
{
  newDict.Add(i, "String #" + i.ToString());
}
 
Just like a List or HashTable, you use the Add() method to add to a Dictionary, except that you have to provide a valid int and string for the arguments, or whatever types you set the Dictionary to be. Now say we want to get "String #3" from the collection, we simply go with:
Console.WriteLine(newDict[3]);

//Outputs String #3
 
So far we have done nothing that you can do with a List or HashTable, but what about a Dictionary that has a Color as a key and a string that holds a String representation of that color? Well, the code will look like this:
Dictionary<Color, string> colorStrings = new Dictionary<Color, string>();

colorStrings.Add(Color.Black, Color.Black.ToString());
colorStrings.Add(Color.Blue, Color.Blue.ToString());
colorStrings.Add(Color.Red, Color.Red.ToString());

foreach (KeyValuePair<Color, string> color in colorStrings)
{
  Console.WriteLine(color.Key.GetBrightness().ToString());
}

//Outputs: 0 0.5 0.5
 
The same result could have been achieved with an array of Color objects, but this example does show you the dictionary's strong point. When you get the key or value, you are given an actual Object of a specific type. With a HashTable, the Key and Value are just Objects, meaning they have no type and must be converted to something in order to be more than just that. With a dictionary, you can declare the Object types and get back useful Objects or those types, in this case a Color object or a string.

Dictionaries add a little more detailed aspect to the Collections of C#, allowing a specific type of key/value collection. When you know what you want, they are the way to go. And this just about wraps this this tutorial up.
Labels:

Comments

Post a Comment

Popular posts from this blog

C# Snippet - Shuffling a Dictionary [Beginner]

Randomizing something can be a daunting task, especially with all the algorithms out there. However, sometimes you just need to shuffle things up, in a simple, yet effective manner. Today we are going to take a quick look at an easy and simple way to randomize a dictionary, which is most likely something that you may be using in a complex application. The tricky thing about ordering dictionaries is that...well they are not ordered to begin with. Typically they are a chaotic collection of key/value pairs. There is no first element or last element, just elements. This is why it is a little tricky to randomize them. Before we get started, we need to build a quick dictionary. For this tutorial, we will be doing an extremely simple string/int dictionary, but rest assured the steps we take can be used for any kind of dictionary you can come up with, no matter what object types you use. Dictionary < String , int > origin = new Dictionary < string , int >();
1 comment
Read more

C# Snippet - The Many Uses Of The Using Keyword [Beginner]

What is the first thing that pops into your mind when you think of the using keyword for C#? Probably those lines that always appear at the top of C# code files - the lines that import types from other namespaces into your code. But while that is the most common use of the using keyword, it is not the only one. Today we are going to take a look at the different uses of the using keyword and what they are useful for. The Using Directive There are two main categories of use for the using keyword - as a "Using Directive" and as a "Using Statement". The lines at the top of a C# file are directives, but that is not the only place they can go. They can also go inside of a namespace block, but they have to be before any other elements declared in the namespace (i.e., you can't add a using statement after a class declaration). Namespace Importing This is by far the most common use of the keyword - it is rare that you see a C# file that does not h
Post a Comment
Read more

C# WPF Printing Part 2 - Pagination [Intermediate]

About two weeks ago, we had a tutorial here at SOTC on the basics of printing in WPF . It covered the standard stuff, like popping the print dialog, and what you needed to do to print visuals (both created in XAML and on the fly). But really, that's barely scratching the surface - any decent printing system in pretty much any application needs to be able to do a lot more than that. So today, we are going to take one more baby step forward into the world of printing - we are going to take a look at pagination. The main class that we will need to do pagination is the DocumentPaginator . I mentioned this class very briefly in the previous tutorial, but only in the context of the printing methods on PrintDialog , PrintVisual (which we focused on last time) and PrintDocument (which we will be focusing on today). This PrintDocument function takes a DocumentPaginator to print - and this is why we need to create one. Unfortunately, making a DocumentPaginator is not as easy as
Post a Comment
Read more