Extending List<T> and Violating The Open/Closed Principle

Question

I just created the following method in one of my classes

public static bool Assimilate(this List<Card> first, List<Card> second)
{
    // Trivial
    if (first.Count == 0 || second.Count == 0)
    {
        return false;
    }

    // Sort the lists, so I can do a binarySearch
    first.Sort();
    second.Sort();

    // Copia only the new elements
    int index;
    for (int i = 0; i < second.Count; i++)
    {
        index = first.BinarySearch(second[i]);
        if (index < 0)
        {
            first.Insert(~index, second[i]);
        }
    }

    // Edit
    second = null;

    return true;
}

And a friend of mine, reviewing my code, said that I shouldn't create methods that 'extend the List class', since that violates the open/closed principle. If I want to extend the class List I should create a new class that inherits from List and implement my "merge" method in that new class. Is he right? Extending the List class violates the Open/Closed principle?

Answer 1

I don't think this violates open/close principle. I think about it in terms of if I have to 'change' existing code to add functionality to an object then I'm violating open/close, but extending an object is exactly what you should do to add functionality.

You can extend the object in different ways in different languages, inheritance is just one way; c# provides you the ability to add extension methods to an existing class.

Remember 'open for extension - close for modification'

Answer 2

If using an extension method rather than a subclass violates the open/closed principle, then by that logic all extension methods would violate it, but they are a feature that has been intentionally added to C# and widely used throughout the .NET framework itself, to much benefit. (Without extension methods, we wouldn't have LINQ, and that would be a real shame.)

An extension method does not modify the class itself (in terms of modifying its code) or any of its existing functionality, so it does not violate the open/closed principle.

Answer 3

The open / close principle is a principle, not a mandate of what that principle should look like in a particular language.

The underlying principle is that, to create a robust, flexible object hierarchy, the base interface can be extended but should not be arbitrarily modified.

In most languages, inheritance is the only way to do this kind of extension, so the open / closed principle requires using inheritance. C# happens to give you two techniques for extension: inheritance and extension methods. There's nothing wrong with using them both.