C#

Some time ago I wrote blog posting Extension method for enumerators where I showed how to use extension methods to make using of enumerators more convenient. Today I found very interesting posting from Grant Barrington blog where he describes the class called EnumHelper.

It is not a miracle that during coding developers produce code that is later not needed anymore. It is also not a miracle that unneeded code will stay in project files waiting for the day when somebody finds this code useful (again). But this far this code is just sitting there and causing problems to people who look at these modules first time.

You may discover sometimes that some of your classes have method you would like to use without creating new instance of that class. In this case we have to use expose static method refactoring to make this method static.

Extract method is one of the most popular refactoring method when dealing with legacy code. In legacy code we can often find methods that are very long. My favorite findings methods about 2000 lines of code. Cool, isn’t it? Those methods have usually many responsibilities and they are hard to debug. Having more than one responsibility in one method leads also to duplicated code because some responsibility is required in more than one place in code.

I want to tell you about List.ForEach method and one of my famous blonde moments when I was debugging faulty code. LINQ makes it easy to query collections and that’s why I like it a lot. Today is friday and weekend is coming. Let’s relax and have some fun on me. Here’s one proof how n00b I can be :)

Keyword var is cool thing we can use to make our code more readable for other programmers and why not – reviewers. But var can also be used to make our code difficult to understand. In this case, lte’s say, we are overusing var. So, var is like wine – if one takes glass of it then everything is okay in the morning, but if somebody takes it couple of bottles then the morning will be awful. Or let’s say – too much var will kill you?

.Net 2.0 provided us with new feature called partial classes. Using partial classes we can use multiple files to keep the code of same class. Yes – we can put some methods to one file and the others to another file. Although partial classes may be extremely useful they can be also used to ruin system’s technical design if developers don’t know what happens behind the compiler.

This is rewrite of my old post about bullet-proof foreach loops. The post covers internals and functioning of foreach. It also shows how to write safe loops and how to modify collections that foreach is stepping through. This post is excellent reading for those who want to have better understanding of foreach loops.

When dealing with version numbers we often need to convert them to string and vice versa. There is lot of code where versions are handled manually in code. I don’t know why. But I know for sure there is class called Version and I’m sure this class will help us a lot. Let’s see a little example.

One cool operators that C# offers us is ?? But before ?? we should know what does ? after variable type name. So, let’s take both of these question marks and let’s see what they are. Also let’s jump for a while behind compilator to see IL code that compiler produces.

Extensions method introduced with C# 3.0 make it possible to “extend” existing classes with new methods without access to source code of those classes. This blog post is deeper technical introduction to extension methods for those who are making decisions about software design and architecture.

Automatic properties are supported by C# since version 3.0 and as developers we use them almost every day. Sometimes developers have questions about how automatic properties work and how to effectively use them. Also I bust some myths about automatic properties and go deep with internals.