Using Extensions: Weighing The Pros vs Cons

Question

Recently I asked a question about how to clean up what I considered ugly code. One recommendation was to create an Extension Method that would perform the desired function

Answer 1

C# Extensions is an additional "tool" provided by .Net in order to help you write your code a little bit nicer. Another advantage of them is, that they handle null. Although they seem very usable, I try to use them only in certain cases that will really tidy up my code, because they are not standard coding methods and they stand a little bit seperate from other classes as they have to be in static classes and are static themselves.

Let's say their implementation is a little bit untidy, but their use is made tidier.

It is also important to mention that they only exist in C# and VB.Net (Java doesn't have Extensions). Another important fact is that Extensions have no priority over standard methods, meaning that if a method is implemented in a class with the same name as an extension method on the same class, then the first method is the one that will be called and not the extension method.

Below there are three cases where I often use them, why I use them and alternative solutions that would solve the same problem:

1. To implement specific methods for generic classes: I have a generic type, let's say a collection List. I want to do a method that applies only to a specific kind of list. Let's say a method that creates a union from a list of strings using a seperator ("A", "B", "C", " sep " --> "A sep B sep C"):

public static string union(this List stringList, String seperator)
{
   String unionString = "";
   foreach (string stringItem in stringList) {
      unionString += seperator + stringItem; }
   if (unionString != "") { 
      unionString = unionString.Substring(seperator.Length); }
   return unionString;
}

In case I didn't want to use an extension, I would have to create a new class "StringCollection : List" and implement my method there. This is mainly not a problem and it is actually better in most cases, but not in all cases. If for example you are receiving all your data in lists of strings in many cases, you don't have to convert those lists in StringCollections each time you want to use union, but use an extension instead.

2. To implement methods that need to handle null: I need a method to convert an object to a string without throwing an exception in case the object is null

public static String toStringNullAllowed(this Object inputObject)
{
   if (inputObject == null) { return null; }
   return inputObject.ToString();
}

In case I didn't want to use an extension, I would have to create a class (probably static), for example StringConverter, which will do the same job, with more words than a simple myObject.toStringNullAllowed();

3. To extend value types or sealed classes: Value types such as int, float, string, etc as well as sealed classes (classes that cannot be inherited) cannot be extended through inheritance. Below you can see an example of extending integers to be able to be converted to x-digit Strings (for example integer 34, digits 5 --> "00034"):

public static String toXDigit(this int inputInteger, int x)
{
   String xDigitNumber = inputInteger.ToString();
   while (xDigitNumber.Length < x) { xDigitNumber = "0" + xDigitNumber; }
   return xDigitNumber;
}

Again an alternative solution would be a static class (like a toolbox), let's say "Math".

• In that case you would write: Math.toXDigit(a, x);
• While with the extension method: a.toXDigit(x);

The extension method looks better and is more understandable, like speaking English

To conclude, I guess the disadvantage of extensions is that their implementation is seperated from standard classes and looks a little bit odd or difficult to programmers that are not used to them, while their advantage is that they offer a more understandable, tidier and encapsulated use of the language.