Archive

Posts Tagged ‘Extensions’

Extension methods in .NET


In many occasions a developer wants to extend classes, but cannot as those classes were either Sealed (Not Inheritable) or it would require considerable time with refactoring existing code to use the inherited classes. In other occasions, a developer may want to have a default implementation for an interface method without repeating the same code in the classes that implement the interface. Both of those scenarios weren’t possible without the Extension Methods feature.

In this post, I will explain how to implement Extension Methods in C# and VB.NET and the pros and cons of using them.

Life before the era of extension methods

Within this section, I will be referring to the following code snippets:

Shape class:


namespace ODNC_Shapes
{
    public abstract class Shape
    {
    }

}

IParallelogram and IEqualSides Interfaces:


namespace ODNC_Shapes

{

    public interface IParallelogram
    {
        
        double Height{ get; set; }
        double Width{ get; set; }
        double Area();
    }
public interface IEqualSides: IParallelogram
    {
    }
}

Rectangle class:


namespace ODNC_Shapes

{
    public class Rectangle : Shape, IParallelogram
    {
        public double Height { get; set; }
        public double Width { get; set; }

        public double Area()
        {
            return Height * Width;
        }
    }
}

Square class:

namespace ODNC_Shapes
{
    public sealed class Square : Rectangle, IEqualSides
    {
    }
}

Rhombus class:

namespace ODNC_Shapes
{
    public class Rhombus:Shape,IEqualSides
    {

        public double Height { get; set; }

        public double Width { get; set; }

        public double Area()
        {
            return Height * Width;
        }
    }
}

Triangle class:


namespace ODNC_Shapes

{

    public sealed class Triangle : Shape

    {

        public double Base { get; set; }

        public double Height { get; set; }

    }

}

The following is the class diagram for the above classes

The above may not be a practical example, but it is good enough to explain the problem we have. Let’s assume that we don’t have the source code or we can’t modify the code for any other reason. And we want to add a function to calculate the area to the Triangle class. We notice that the Triangle class is a sealed class and can’t be inherited (i.e. extended). As a work around, we have to do the following:

  1. Create a static method that accepts a triangle object as a parameter and returns a double type
  2. Write the code to calculate the area in that function
  3. Call function from your code

The following code snippet illustrates the above steps:

using System;
using ODNC_Shapes;

namespace ODNC_ConsoleApplication
{
    public class ShapesHelper
    {
        public static double CalculateArea(Triangle triangle)
        {
            if (triangle == null)
                throw new NullReferenceException("Triangle object is null.");

            return 0.5*(triangle.Base + triangle.Height);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Triangle triangle = new Triangle { Base = 5, Height = 10 };
            double area = ShapesHelper.CalculateArea(triangle);
            Console.WriteLine(String.Format("Area: {0}", area));
            Console.ReadKey();
        }
    }
}

 

What are extension methods

 MSDN defines extension methods as

“Extension methods enable you to “add” methods to existing types without creating a new derived type, recompiling, or otherwise modifying the original type”

“Extension methods are a special kind of static methods, but they are called as if they were instance methods on the extended type”

How to Create Extension Methods

the following are the steps to create extension methods for the classes that implement IEqualSides interface

  1. Create new class library project, name it ShapeExtensions
  2. Add new class, call it IEqualSidesExtensions
  3. Make it a static class
  4. Create a static function, name it Perimeter with the following signature and code
  5. 
    namespace ShapesExtensions
    {
        public static class IEqualSidesExtensions
        {
            public static double Perimeter(this IEqualSides iEqualSide)
            {
                if (IEqualSide == null)
                {
                    throw new NullReferenceException();
                }
    
                return 4 * iEqualSide.Height;
            }
        }
    }
    
    Imports System.Runtime.CompilerServices
    
    Public Module IEqualSides
        <Extension()>
        Public Function Perimeter(ByVal iEqualSides As ODNC_Shapes.IEqualSides) As Double
    
            If iEqualSides Is Nothing Then
                'Do something
            End If
    
            Return 4 * iEqualSides.Width
    
        End Function
    End Module
    

    Notice the signature of the above function. As wiered as it looks, but that is the syntax of an extension method in C#. You need to have “this” keyword, type of the class you are writing the extension for and a parameter. In VB, you need to create a Module, declare the method with a paremeter of type IEqualSides, and decorate the function with Extension attribute.

  6. Build the project
  7. Add a reference to this project to the project where you want to use this extension method
  8. Add a using statement for that namespace
  9. Create a new instance of square
  10. Notice that you will find that Perimeter function was detected by intellisense, as if it were an instance method. You don’t need to pass it any parameters in this case. You will get the same result if you create a new instance of Rhombus

In the above example we added an extension method for all types that implement the IEqualSides interface. We created the extension method on a separate project to reuse the method on multiple projects. We could have added the extension method on a the same project where we want to use it.

Pro’s & Con’s

Extension methods are special type of static methods. When .NET compiler find them, it binds them to the instances of that class type. In the above example, we could have called the Perimeter method with the following syntax:

double perimeter = IEqualSidesExtensions.Perimeter(square);

Although it was advertised that extension methods extends or add new functionality to sealed classes and classes we don’t own, it actually doesn’t do so. Extension methods are still static methods but we get better readability and intellisense support when using them.

To summarize the advantages of using extension methods, they:

  1. make your code more readable
  2. give you intellisense support
  3. can be defined for interfaces, classes and abstract classes to have default behaviour
  4. adhere to the encapsolution rule of OOP; extension methods can only access public properties and methods for that type

Let’s now jump into some disadvantages for using extension methods

  1. Maintainability: imagine every developer write his own extension method library. Developers in a team need to make sure that their extension methods don’t have the same name. The maintainablility issue still exist when using static methods in helper classes
  2. No compiler error when methods are declared in classes. When the same method is declared in the class (e.g. in the Square class), the compiler doesn’t warn you that the function is already declared as an extension method. In this case the compiler binds the caller to the method that is declared in the class. For example, if we declare a Perimeter function in the Square class, that function will be executed instead of the one that was declared as an extension method
  3. Extension methods are not virtual (overridable) methods. For instance if we add square instances to a list <IEqualSides> (i.e. list(of IEqualSides) or you cast a square object to IEqualSides then execute the Perimeter function, the extension method is called not the one in the square class!
  4. You need to make sure that you check for null exception in your extension method. One may think that he is calling an instance method when calling SquareInstance.Perimeter(). Remember that extension methods are still static methods.
  5. namespace ShapesExtensions
    {
        public static class IEqualSidesExtensions
        {
            public static double Perimeter(this IEqualSides iEqualSide)
            {
                if (iEqualSide == null) // <-----
                {
                    //do something   
                }
    
                return 4 * iEqualSide.Height;
            }
        }
    }
    
  6. Confusing syntax. Many will get intimidated when they see the syntax of an extension method for the first time
  7. Inconsistent syntax between C# and VB. I don’t like the inconsistency between C# and VB

Conclusion

  1. Neat feature to “extend” class
  2. Extension methods are not instance methods
  3. An extension method with the same name and signature as an interface or class method will never be called
  4. Could be maintenance chaos
  5. Watch for Null Exceptions
Categories: .NET, C#, VB Tags: , , , ,