Chapter 48: Extension Methods

The object passed as the first argument of an extension method (which is accompanied by the this keyword) is the instance the extension method is called upon.

For example, when this code is executed:

"some string".Shorten(5);

The values of the arguments are as below:

text: "some string" length: 5

Note that extension methods are only usable if they are in the same namespace as their definition, if the namespace is imported explicitly by the code using the extension method, or if the extension class is namespace-less. The .NET framework guidelines recommend putting extension classes in their own namespace. However, this may lead to discovery issues.

This results in no conflicts between the extension methods and the libraries being used, unless namespaces which might conflict are explicitly pulled in. For example LINQ Extensions:

using System.Linq; // Allows use of extension methods from the System.Linq namespace

class Program

{

static void Main()

{

var ints = new int[] {1, 2, 3, 4};

// Call Where() extension method from the System.Linq namespace var even = ints.Where(x => x % 2 == 0);

}

}

Live Demo on .NET Fiddle

Since C# 6.0, it is also possible to put a using static directive to the class containing the extension methods. For example, using static System.Linq.Enumerable;. This makes extension methods from that particular class available without bringing other types from the same namespace into scope.

When a class method with the same signature is available, the compiler prioritizes it over the extension method call. For example:

class Test

{

public void Hello()

{

Console.WriteLine("From Test");

}

}

static class TestExtensions

{

public static void Hello(this Test test)

{

Console.WriteLine("From extension method");

}

}

Section 48.3: Explicitly using an extension method

Extension methods can also be used like ordinary static class methods. This way of calling an extension method is more verbose, but is necessary in some cases.

static class StringExtensions

{

public static string Shorten(this string text, int length)

{

return text.Substring(0, length);

}

}

Usage:

var newString = StringExtensions.Shorten("Hello World", 5);

When to call extension methods as static methods

There are still scenarios where you would need to use an extension method as a static method:

Resolving conflict with a member method. This can happen if a new version of a library introduces a new member method with the same signature. In this case, the member method will be preferred by the compiler.

Resolving conflicts with another extension method with the same signature. This can happen if two libraries include similar extension methods and namespaces of both classes with extension methods are used in the same file.

Passing extension method as a method group into delegate parameter. Doing your own binding through Reflection.

Using the extension method in the Immediate window in Visual Studio.

Using static

If a using static directive is used to bring static members of a static class into global scope, extension methods are skipped. Example:

using static OurNamespace.StringExtensions; // refers to class in previous example

//OK: extension method syntax still works.

"Hello World".Shorten(5);

//OK: static method syntax still works.

OurNamespace.StringExtensions.Shorten("Hello World", 5);

// Compile time error: extension methods can't be called as static without specifying class.

Shorten("Hello World", 5);

If you remove the this modifier from the first argument of the Shorten method, the last line will compile.

Section 48.4: Generic Extension Methods

Just like other methods, extension methods can use generics. For example:

static class Extensions

{

public static bool HasMoreThanThreeElements<T>(this IEnumerable<T> enumerable)

{

return enumerable.Take(4).Count() > 3;

}

}

and calling it would be like:

IEnumerable<int> numbers = new List<int> {1,2,3,4,5,6};

var hasMoreThanThreeElements = numbers.HasMoreThanThreeElements();

View Demo

Likewise for multiple Type Arguments:

public static TU GenericExt<T, TU>(this T obj)

{

TU ret = default(TU);

// do some stuff with obj return ret;

}

Calling it would be like:

IEnumerable<int> numbers = new List<int> {1,2,3,4,5,6};

var result = numbers.GenericExt<IEnumerable<int>,String>();

View Demo

You can also create extension methods for partially bound types in multi generic types:

class MyType<T1, T2>

{

}

static class Extensions

{

public static void Example<T>(this MyType<int, T> test)

{

}

}

Calling it would be like:

MyType<int, string> t = new MyType<int, string>(); t.Example();

View Demo

You can also specify type constraints with where :

public static bool IsDefault<T>(this T obj) where T : struct, IEquatable<T>

{

return EqualityComparer<T>.Default.Equals(obj, default(T));

}

Calling code:

int number = 5;

var IsDefault = number.IsDefault();