Granville Barnett : C#

Data Structures and Algorithms book flying out (again!)

Granville Barnett — Mon, 22 Dec 2008 02:48:27 GMT

The updated version of the Data Structures and Algorithms book that Luca and I wrote is flying out once more! We are really very happy to see how many people are downloading our book. In total (counting the previous release) the book has had nearly 16,000 downloads! Amazing.

If you haven’t already got a copy what are you waiting for?! Its free so you don’t have to reach into those empty pockets at this time of year.

Download the updated version of the Data Structures and Algorithms book here!

Enjoy. Merry Christmas and a Happy New Year.

Updated version of the free Data Structures and Algorithms book available!

Granville Barnett — Fri, 19 Dec 2008 00:40:41 GMT

Just in time for Christmas ;-)

You can download a revised version of the book Data Structures and Algorithms: Annotated Reference with Examples here!

The last version of the book has had just under 14,000 downloads since we released it.

Download the book now!

Data Structures and Algorithms: Annotated Reference with Examples

Design Patterns – Part 7 published

Granville Barnett — Mon, 13 Oct 2008 11:43:13 GMT

The 7^th part of the design patterns series was published today. This part covers the template pattern.

View it – Design Patterns – Part 7

Design Patterns – Part 6 published

Granville Barnett — Thu, 09 Oct 2008 11:30:00 GMT

Part 6 of the design patterns series has just been published on DotNetSlackers. This part covers the adapter pattern.

View it – Design Patterns – Part 6

Design Patterns – Part 5 published

Granville Barnett — Tue, 07 Oct 2008 11:37:59 GMT

In this part of the series we look at the command pattern.

I've also seen that Sonu has posted in the article quick links to the previous articles in the series as well. While the articles are not written in any specific order I would recommend that you read the first part before you read any of the others if only for motivation to learn more about design patterns.

View it – Design Patterns – Part 5

Results: Using a dark theme in VS for a week

Granville Barnett — Fri, 26 Sep 2008 17:20:35 GMT

As I mentioned several days ago I’ve been seeing if a dark theme in VS would help my eyes a little. The short of it is – no, no it didn’t. The major sore point is that if you use a dark theme in VS then you find yourself constantly swapping between dark (VS) and light (web content, content in general). The latter of course doesn’t sound like its particularly good for you and I’d definitely concur with that.

I actually found that my background was slightly off-white in my VS settings and since changing it to pure white around 3 or so days ago I’ve found that my eye strain has just disappeared. Funny thing is I can never remember changing the background colour.

I’ve no doubt that the colour schemes used in VS are very subjective so I won’t announce that light themes are the best, but it seems to work well for me.

Experiment: Using a dark theme in VS for a week

Granville Barnett — Sat, 20 Sep 2008 14:03:28 GMT

I've been highly critical of using dark themes in Visual Studio particularly because the UI of VS is light in its very nature. The combination of the two proving to be an interesting proposition when using VS for large durations of time.

I digress. Recently I have suffered a few eye issues and I'm pretty much willing to try and use a dark theme now for more than an hour and then dismissing it in the hope that it may help me out a little. I have tried a few other minor solutions prior to this experiment, the most of which revolve around making the background colour of VS a slightly off-white colour. If anything that approach made things worse.

I'll be using the theme for all my coding which spans from C++ to C# and see how it goes. The theme I will use is Vibrant Ink by Rob Conery.

Hopefully this may help my eyes a little? ...

Design Patterns - Part 4 published

Granville Barnett — Wed, 17 Sep 2008 13:14:01 GMT

Part 4 of the design patterns series I have been writing has just been published on DotNetSlackers. This part covers the singleton pattern.

View it - Design Patterns - Part 4

Data Structures and Algorithms 0.6 released!

Granville Barnett — Fri, 12 Sep 2008 10:35:14 GMT

We have just released 0.6 of the Data Structures and Algorithms library. Notable new features include (amongst many other little changes not listed):

AVL Tree
Deque
Radix sort

Download Data Structures and Algorithms 0.6!

Using Pex in a TDD fashion...

Granville Barnett — Tue, 09 Sep 2008 11:23:02 GMT

Peli has just posted a good post on using Pex in a TDD fashion to create a binary heap.

In case you don't know, Peli is actually one of the guys working on Pex at MSR so if you have a chance do give it a look ;-)

"Pex (Program EXploration) is an intelligent assistant to the programmer. From a parameterized unit test, it automatically produces a traditional unit test suite with high code coverage. In addition, it suggests to the programmer how to fix the bugs."

By the way Pex is not tied to MSTest. See the Pex Extensions project on CodePlex for other framework support like NUnit.

Design Patterns - Part 3 published

Granville Barnett — Fri, 05 Sep 2008 13:39:31 GMT

The third part of this series covers the factory pattern.

View it - Design Patterns - Part 3

You may also be interested in part 1 (strategy), and part 2 (observer).

Setting up a build environment article published

Granville Barnett — Mon, 01 Sep 2008 10:03:38 GMT

An article I wrote for DotNetSlackers has just been published entitled Setting up a build environment. The article is based upon a pretty simple example that uses Subversion, TortoiseSVN, MSBuild, MSBuild Community Tasks, and TeamCity.

Give it a read - Setting up a build environment.

Note: I give a brief mention also to the SDC Tasks Library project which contains some very helpful tasks.

Visual Studio and TeamCity integration

One thing I didn't really have space to mention in the article is the integration that TeamCity provides for Visual Studio. Its a little plugin that allows you to view the results of builds, as well as being able to run a local build. There are a few more features and I suggest you view this video on the JetBrains web site to get up to speed with all of them.

DSA book on 'This Week on C9'

Granville Barnett — Sat, 30 Aug 2008 11:42:18 GMT

First off thank you to all who have downloaded the first draft of Data Structures and Algorithms: Annotated Reference with Examples. At the time of writing this post there have been more than 3200 downloads within around 3 days of it being put up on DotNetSlackers which is great!

Thanks to all those who have helped spread the word by linking to the posts I made and to the actual project page. I'd also like to thank Dan Fernandez who gave the book a mention on This Week on C9 (a weekly review program on the popular Channel9 site). You can view the episode here.

If you haven't checked it out already then go give the first draft of Data Structures and Algorithms: Annotated Reference with Examples a look.

Data Structures and Algorithms book (free) first preview available!

Granville Barnett — Wed, 27 Aug 2008 13:55:27 GMT

This is a little project that myself and Luca have been working on in our spare (spare) time in the last month or so. The book is no where near complete but we wanted to get it out there now and progress with it in view of the public eye rather than just sit on it and wait months until it was a lot more thorough.

As this is just a preview don't expect it to be all finely polished, we know what we are lacking in terms of explanations. No chapter in the preview is the final version of that respective chapter. It's also worth mentioning that this is not the final list of chapters.

Our intended target audience are those who know how to use their respective language of choice, other than that you should be OK to follow the book. We have intentionally tried to keep the book compact and to the point.

The book is language independent. We use a form of pseudocode for all algorithms as such these algorithms can be easily ported to most imperative languages like C++, C#, and Java.

Why is it free? Because we want it to be. At this present moment in time all suggestions etc have come from a small number of reviewers, for which we are incredibly grateful. But we felt the time was right to throw it out to the larger audience so we can get more feedback on what we have thus far.

The book is hosted for us on DotNetSlackers, you can view the page dedicated to the book here.

Go check out the first preview of Data Structures and Algorithms: Annotated Reference with Examples now!!!

EDIT: if you could help spread the word we would be incredibly grateful ;-)

Design Patterns - Part 2 published

Granville Barnett — Fri, 22 Aug 2008 22:43:35 GMT

In the first part we looked at the strategy pattern, in part 2 of this design patterns series we take a look at the observer pattern.

As I mentioned in a previous post this series is aimed more at developers that are relatively new to design patterns rather than the seasoned pro's.

View it - Design Patterns - Part 2

StyleCop and FxCop released

Granville Barnett — Thu, 21 Aug 2008 15:56:02 GMT

I am a massive fan of both these tools. Now StyleCop 4.3 and FxCop 1.36 have been released.

For a long time now FxCop 1.36 has been in Beta. I thought that maybe the standalone tool had been dropped or something but alas I am wrong, and thankful for it.

StyleCop, formerly C# Code Analysis (? I seem to remember the version prior to this was called that, may be wrong) fixes a tonne of bugs. The previous version broke several things in Visual Studio like the properties window for a project, this is no longer the case. There are a few rules that I don't really like. One no more so than the naming of member variables, I believe it will give you abuse if you use a pattern like m_myVar, or _myVar - the tool by default will tell you it should be myVar. This is a very subjective rule though. I tend to just customize the rules for a few things and go from there. Still only works for C# code.

Design Patterns - Part 1 published

Granville Barnett — Tue, 19 Aug 2008 14:23:29 GMT

I recently started writing a series on design patterns for DotNetSlackers. The series is aimed squarely at those who are new to design patterns. In the first part we cover the strategy pattern.

At this moment in time I am not sure of how many parts the series will consist of but I have an idea so if there is a design pattern you would like me to cover then do let me know.

View it - Design Patterns - Part 1

Hang on! I've been mentioned on This Week on C9!

Granville Barnett — Sat, 09 Aug 2008 18:39:31 GMT

I think I'm almost famous. I'm mentioned 10:47 - 12:25. The mentioning was in response to my Visual Studio vNext wish list.

Check out the video.

My Visual Studio vNext wish list

Granville Barnett — Mon, 04 Aug 2008 10:20:57 GMT

My wish list for Visual Studio vNext isn't that long. The things I would like to see in Visual Studio vNext (I'm not that hopeful) are the following:

A filtering intellisense members list box
Some intelligent suggestions
More refactoring options

Unfortunately I am going to do the unmentionable and compare VS to Eclipse.

A filtering intellisense members list box

As the number of classes in the BCL grows, and with newer technologies arriving all the time I don't think there has ever been a better time to implement this feature. Eclipse does a good job of it and is incredibly handy:

There are some products out there that you can actually install to do this, they include:

Resharper (Using the native Resharper intellisense stuff)
Visual Assist X

Some intelligent suggestions

This is a lame example, but its a pretty common one. Today in VS suggestions for the most part are non-existent. I know that in VS 2008 SP1 background compilation for C# is here (warnings, errors) but it still doesn't give you what Eclipse does with respect to suggestions.

I know that there are probably a tonne of people reading this now shouting "You can remove unused using directives now!" True, but its never emphasised to you by the IDE. Again I find myself uttering the word Resharper for this stuff, but should we really have to buy into a 3rd party product for something like this? We could also extend this to something like variables that are never referenced.

More refactoring options

Eclipse offers an absolute tonne of refactoring options which are integrated really great into the IDE.

While I don't have any major gripes about what is offered in VS 2008 with respect to refactoring, I do think it lacks somewhat. Some of the refactoring options in VS could do with a more streamlined approach as well. A great example of this is the rename option. Invoking rename will open a big goofy dialogue box which would be appropriate if you were renaming a field or something - in place renaming would be much more appropriate for local renaming's though.

Final thoughts

I really like VS and all that it gives you but I can't help feel that we are losing out on some of this stuff. I'm sure that the VS team are incredibly busy building new designers, but if anyone on the VS team happen's to stumble across this post then please give these features consideration.

Purposely I have not mentioned C++, they have enough trouble getting intellisense working as it is. If you are interested in this though then check out Intellisense History, Part 1 and Intellisense, Part 2 (The Future). Both blog posts are from the VC++ blog. Visual Assist X is a nice tool though if you want a more rounded experience in VC++ land right now.

Partial classes - they have only one real use, right?

Granville Barnett — Tue, 29 Jul 2008 16:23:45 GMT

Over the years I have heard that some folk actually use partial classes to help assist in-team collaboration efforts, yet I have yet to meet such people. If you have a standard source control system that allows you to merge then surely this is just as good?

The reason I bring this up is that I was recently extending some code that is designer driven, well that's not really true there is no designer but what the program generates is some generic code that is partial so you can cleanly extend it without wading through all the nonsensical automated comments and clear lack of sane code formatting.

If you were to look on MSDN there are two major points which are mentioned about the partial keyword (shamelessly lifted from the MSDN site):

When working on large projects, spreading a class over separate files allows multiple programmers to work on it simultaneously.
When working with automatically generated source, code can be added to the class without having to recreate the source file. Visual Studio uses this approach when creating Windows Forms, Web Service wrapper code, and so on. You can create code that uses these classes without having to edit the file created by Visual Studio.

Now I can totally see that partial classes for designer driven code is very good, e.g. WinForms which if you use the designer to build just throws in a tonne of glue for you that you really don't want to damage your eyes by looking at - but do we really use partial classes in these large projects?

I'd be interested to know if folk have actually used partial classes in the way in which the first point alludes to from MSDN.

p.s. (final reminder) please post any comments on my new blog - http://msmvps.com/blogs/gbarnett