Extension method: Difference between revisions

Revision as of 16:59, 24 May 2021

Latest revision as of 09:02, 13 August 2025

(23 intermediate revisions by 14 users not shown)

Line 1:

{{Short description|Computer programming method type}}

{{See also|Monkey patch}}

{{essay|date=May 2013}}

{{More citations needed|date=September 2024}}

In [[object-oriented computer programming]], an '''extension method ''' is a [[Method (computer programming)|method]] added to an object after the original object was [[Compiler|compiled]]. The modified object is often a class, a prototype, or a type. Extension methods are features of some object-oriented programming languages. There is no syntactic difference between calling an extension method and calling a method declared in the type definition.<ref name="ms_ext">{{cite web|url=http://msdn.microsoft.com/en-us/library/bb383977.aspx|title=Extension Methods|publisher=Microsoft|accessdate=2008-11-23}}</ref>

Not all languages implement extension methods in an equally safe manner, however. For instance, languages such as C#, Java (via [http://manifold.systems/docs.html#the-extension-manifold Manifold], [https://projectlombok.org/features/experimental/ExtensionMethod Lombok], or [https://github.com/rogerkeays/fluent Fluent]), and Kotlin don't alter the extended class in any way, because doing so may break [[class hierarchy|class hierarchies]] and interfere with virtual method dispatching. This is whyInstead, these languages strictly implement extension methods statically and use [[static dispatch]]ing to invoke them.

In [[object-oriented computer programming]], an '''extension method ''' is a [[Method (computer programming)|method]] added to an object after the original object was [[Compiler|compiled]]. The modified object is often a class, a prototype or a type. Extension methods are features of some object-oriented programming languages. There is no syntactic difference between calling an extension method and calling a method declared in the type definition.<ref name="ms_ext">{{cite web|url=http://msdn.microsoft.com/en-us/library/bb383977.aspx|title=Extension Methods|publisher=Microsoft|accessdate=2008-11-23}}</ref>

Not all languages implement extension methods in an equally safe manner, however. For instance, languages such as C#, Java (via Manifold), and Kotlin don't alter the extended class in any way, because doing so may break class hierarchies and interfere with virtual method dispatching. This is why these languages strictly implement extension methods statically and use [[static dispatch]]ing to invoke them.

==Support in programming languages==

Extension methods are features of numerous languages including [[C Sharp (programming language)|C#]], [[Java (programming language)|Java]] via [http://manifold.systems/docs.html#the-extension-manifold Manifold] or [https://projectlombok.org/features/experimental/ExtensionMethod Lombok] or [https://github.com/rogerkeays/fluent Fluent], [[Gosu (programming language)|Gosu]], [[JavaScript]], [[Oxygene (programming language)|Oxygene]], [[Ruby (programming language)|Ruby]], [[Smalltalk]], [[Kotlin (programming language)|Kotlin]], [[Dart (programming language)|Dart]], [[VB.NET|Visual Basic.NET]], and [[Xojo]]. In dynamic languages like [[Python (programming language)|Python]], the concept of an extension method is unnecessary because classes (excluding built-in classes) can be extended without any special syntax (an approach known as "[[Monkey patch|monkey-patching]]", employed in libraries such as [[gevent]]).

In VB.NET and Oxygene, they are recognized by the presence of the "<code>extension</code>" keyword or attribute. In Xojo, the "<code>Extends</code>" keyword is used with global methods.

In C#, they're are implemented as static methods in static classes, with the first argument being of extended class and preceded by "<code>this</code>" keyword.

In Java you add, extension methods are added via [http://manifold.systems/ Manifold], a jar file you addadded to yourthe project's classpath. Similar to C#, a Java extension method is declared static in an [http://manifold.systems/docs.html#extension-classes @Extension] class where the first argument has the same type as the extended class and is annotated with <code>@This</code>. Alternatively, the [https://github.com/rogerkeays/fluent Fluent] plugin allows calling any static method as an extension method without using annotations, as long as the method signature matches.

In Smalltalk, any code can add a method to any class at any time, by sending a method creation message (such as <code>methodsFor:</code>) to the class the user wants to extend. The Smalltalk method category is conventionally named after the package that provides the extension, surrounded by asterisks. For example, when Etoys application code extends classes in the core library, the added methods are put in the <code>*etoys*</code> category.

In Ruby, like Smalltalk, there is no special language feature for extension, as Ruby allows classes to be re-opened at any time with the <code>class</code> keyword, in this case, to add new methods. The Ruby community often describes an extension method as a kind of [[monkey patch]]. There is also a newer feature for adding safe/local extensions to the objects, called [https://docs.ruby-lang.org/en/2.5.0/syntax/refinements_rdoc.html Refinements], but it is known to be less used.

In Swift, the <code>extension</code> keyword marks a class-like construct that allows the addition of methods, constructors, and fields to an existing class, including the ability to implement a new interface/protocol to the existing class.<ref>{{Cite web |title=Extensions — The Swift Programming Language (Swift 5.7) |url=https://docs.swift.org/swift-book/LanguageGuide/Extensions.html |access-date=2022-06-12 |website=docs.swift.org}}</ref>

==Extension methods as enabling feature==

Line 39:

<syntaxhighlight lang="csharp">

namespace MyCoolLogger {;

public interface ILogger { void Write(string text); }

public static class LoggerExtensions {

{

public static void Write(this ILogger logger, string format, params object[] args) {

void if Write(logger !=string nulltext);

}

logger.Write(string.Format(format, args));

}

public static class LoggerExtensions {

{

public static void Write(this ILogger logger, string format, params object[] args) {

}{

if (logger != null)

logger.Write(string.Format(format, args));

}

}

Line 88 ⟶ 94:

===Productivity===

Consider for example [http://msdn.microsoft.com/en-us/library/system.collections.ienumerable.aspx IEnumerable] and note its simplicity - there is just one method, yet it is the basis of LINQ more or less. There are many implementionsimplementations of this interface in Microsoft .NET. Nevertheless, obviously, it would have been burdensome to require each of these implementations to implement the whole series of methods that are defined in the [http://msdn.microsoft.com/en-us/library/system.linq.aspx System.Linq namespace] to operate on IEnumerables, even though Microsoft has all the source code. Even worse, this would have required everybody besides Microsoft considering to use IEnumerable themselves to also implement all those methods, which would have been very anti-productive seeing the widespread use of this very common interface. Instead, by implementing the one method of this interface, LINQ can be used more or less immediately. Especially seeing in practically most cases IEnumerable's GetEnumerator method is delegated to a private collection, list or array's GetEnumerator implementation.

<syntaxhighlight lang="csharp">

Line 115 ⟶ 121:

===Alleviating the need for a common base class===

With generic classes, extension methods allow implementation of behavior that is available for all instantiations of the generic type without requiring them to derive from a common base class, and without restricting the type parameters to a specific inheritance branch. This is a big win, since the situations where this argument holds require a non-generic base class just to implement the shared feature - which then requires the generic subclass to perform [[boxing (programming)|boxing]] and/or casts whenever the type used is one of the type arguments.

===Conservative use===

A note should be placed on preferring extension methods over other means of achieving reuse and proper object -oriented design.

Extension methods might 'clutter' the automatic completion features of code editors, such as Visual Studio's IntelliSense, hence they should either be in their own namespace to allow the developer to selectively import them or they should be defined on a type that is specific enough for the method to appear in IntelliSense only when really relevant and given the above, consider that they might be hard to find should the developer expect them, but miss them from IntelliSense due to a missing using statement, since the developer may not have associated the method with the class that defines it, or even the namespace in which it lives - but rather with the type that it extends and the namespace that type lives in.

Line 125 ⟶ 131:

# Inherit the class and then implement the functionality in an instance method in the derived class.

# Implement the functionality in a static method added to a helper class.

# Use [[Object composition#Aggregation|aggregation]] instead of [[inheritance (computerobject-oriented scienceprogramming)|inheritance]].

==Current C# solutions==

Line 144 ⟶ 150:

==Current VB.NET solutions==

In most ways, the VB.NET solution is similar to the C# solution above. However VB.NET has a unique advantage in that it allows members to be passed in to the extension by reference (C# only allows by value). Allowing for the following;

<syntaxhighlight lang="vbvbnet">

Dim x As String = "some string value"

x.Reverse()

Line 202 ⟶ 208:

==See also==

* [[UFCS]], a way to use free functions as extension methods provided in the [[D programming language]]

* [[typeType class]]es

* [[Anonymous type]]s

* [[Anonymous function|Lambda expressions]]

Line 215 ⟶ 221:

*[http://zielonka.codeplex.com/ Open source collection of C# extension methods libraries]. Now archived [https://archive.codeplex.com/?p=zielonka at Codeplex]

*[http://www.codedigest.com/Articles/CSHARP/357_Understanding_Extension_Methods_in_C_.aspx Extension method in C#]

*[httphttps://programmerchoice.blogspot.com/2010/06/extension-methods.html Extension methods]

*[https://csharp-extension.com/ C# Extension Methods]. A collection.

*[https://www.extensionmethod.net/ extensionmethod.net Large database with C#, Visual Basic, F# and Javascript extension methods]

Line 221 ⟶ 227:

*[http://blogs.microsoft.co.il/blogs/basil/archive/2008/09/22/defining-your-own-functions-in-jquery.aspx Defining your own functions in jQuery]

*[http://www.drdobbs.com/cpp/uniform-function-call-syntax/232700394 Uniform function call syntax]

*[httphttps://csharp-software-development.blogspot.com/2014/09/c-extension-methods.html Extension methods in C#]

*[http://manifold.systems/docs.html#the-extension-manifold Extension Methods in Java with Manifold]

*[https://projectlombok.org/features/experimental/ExtensionMethod Extension Methods in Java with Lombok]

*[https://github.com/rogerkeays/fluent Extension Methods in Java with Fluent]

*[https://kotlinlang.org/docs/reference/extensions.html Extension functions in Kotlin]