What is difference between extension method and static method?

Question

What is the difference between an extension method and a static method ?

I have two classes like this :

public static class AClass {
    public static int AMethod(string ....)
    {
    }
}

and

public static class BClass {
    public static int BMethod(this string ....)
    {
    }
}

I can use these like

AClass.AMethod('...');

or

'...'.BMethod();

Which is proposed ?

Answer 1

An extension method is still a static method. You can use it exactly as you'd use a normal static method.

The only difference is that an extension method allows you to use the method in a way that looks like it's part of the type, so you can write:

int result = stringValue.BMethod();

Instead of:

int result = BClass.BMethod(stringValue);

This works purely as a compile "trick" - the compiler sees the first form, and if the BClass is usable (it has a proper using and is in a referenced assembly), then it will turn it into the second method's IL for you. It's purely a convenience.

Which is proposed ?

This really depends. If you control the type, I'd recommend putting the methods on the type itself. This is typically more maintainable.

If you don't control the type, or you're trying to "extend" a common type (such as IEnumerable<T>), then extension methods may be a reasonable approach.

However, if the type is a very common type, I'd typically avoid extension methods, as they become "noise" in intellisense, which in turn can cause extra confusion. For example, I would personally not recommend adding extension methods on System.Object or System.String, etc.

Answer 2

You cannot override an extension method. Only if the method has a different signature, then it can be overloaded.

Off course there are some limitations: Extension Methods have to be implemented as static methods and in static classes (inside a non-nested, non-generic static class to be more precise). You can use extension methods to extend a class or interface, but not to override them. An extension method with the same name and signature as an interface or class method will never be called. At compile time, extension methods always have lower priority than instance methods defined in the type itself. Extension methods cannot access private variables in the type they are extending. You can consider Extension Methods as a 'legal' way to add more static methods to existing classes without actually inheriting them. But the funny thing is that unlike regular static methods of the class, you cannot call Extension Methods on a class level (you will get an compile time error if you try this), but instead you must invoke them on a instance of the class (as if they were some regular methods of the instance of that class, which they are not!!!).

Also, inside the Extension Method you can freely use public properties of the passed object instance on which the method is being invoked, you are by no means limited only to static object data. Only the Extension Method is static method, but the object on which is called is full, regular object instance.