The Simple Fundamentals we Forget

A little while ago a frustrated co-worker asked me for some help, he was working on consuming a web service and needed to add an array of strings to the request based on user input and he couldn't figure out how to add a new item to the array. He could find lots of examples of how to create the array, and how to populate it at initialization, etc. but he couldn't find out how to just add a new item. When i explained to him that you couldn't he was a little shocked, all of the other collection type let you add new items, why wouldn't an array? In his defense he came from a dynamic language background, where an array is more like an ArrayList in c#.

This got me thinking about some of the simple fundamentals and basic language features that I don't remember exactly how to use, mostly because I never use them. A good example would be the Conditional Operator

   1: string fileName = tempFileName != null ? tempFileName : "Untitled";

it's purely a personal preference, but I don't like the way they look in code and I think they make it harder to debug, having said that they are a fundamental part of the language and as a good developer I should know how to use them. This is got me thinking about how I should use parts of language/framework that I don't normally use just to keep in practice.

I think this could be beneficial in a couple of ways, primarily it would require me to look for things I'm not using and force me to think about how to use them. Second it would make me think why I don't use them. A prime example is an abstract classes, I know how to use them I just don't like to. Maybe if I forced myself to use them on occasion I would find a place where they are better suited then an interface or I'm just going to prove why I like interfaces better, but the important part is that I reaffirm why I like interfaces more then abstract classes.

At times I think the hardest part of learning new things is not forgetting what I already know, maybe I need to take some time to write some practice code or proof of concepts just for the practice.

Technorati Tags: c# Fundamentals,Software Developemnt

An elegant solution that was completely unnecessary

Working on a web form that would email someone when it was submitted, one of the methods looked like it could use a little refactoring.

   1: private string BuildMessageBody()

   2: {

   3:     StringBuilder messageBuilder = new StringBuilder();

   4:     messageBuilder.Append("Account Number: ");

   5:     messageBuilder.Append(textAccountNumber.Text);

   6:     messageBuilder.Append("\n");

   7: }

It looks kind of ugly and takes up a fair amount of space, I could do string concatenation,

   1: private string BuildMessageBody()

   2: {

   3:     messageBuilder.Append("Account Number: " + textAccountNumber.Text + "\n"

   4: );

but that can get ugly fast and in my opinion it's hard to maintain. So I came up with a brilliant and elegant solution, I would use an extension method!

   1: public static void AppendLine(this StringBuilder builder, string title, string value)

   2: { 

   3:     builder.Append(title); 

   4:     builder.Append(value); 

   5:     builder.Append("\n");        

   6: }

and now my could would look something like this

   1: private string BuildMessageBody()

   2: {

   3:     StringBuilder messageBuilder = new StringBuilder(); 

   4:     messageBuilder.AppendLine("Account Number: ", textAccountNumber.Text);

   5: }

and just as I was thinking how cool Extender methods are it hit me? I could just use StringBuilder.AppendFormat to do basically the same thing like this

   1: private string BuildMessageBody()

   2: {

   3:     StringBuilder messageBuilder = new StringBuilder();

   4:     messageBuilder.AppendFormat("Account Number: {0}\n", textAccountNumber.Text);  

   5: }

Oh well, but just proves that sometimes a cool new way to handle a problem isn't always the right way, and this was a reminder for me to look at existing functionality before I try to create my own.