Attributes that make methods extensible

This article describes the various attributes that can be used to control extensibility capabilities for methods.

The following table provides an overview of the default support for extensibility and accessibility on methods. The table also provides guidance on the method signature changes.

Attribute	Hookable	Wrappable	Replaceable	Accessibility	Signature
private	No	N/A	N/A	Accessible from within class it is defined in.	Signature can be changed
protected internal	No	Yes, from Platform update 25 onward	No	Accessible from with the class it is defined, from derived classes, and from classes in the same model.	Signature must remain compatible
internal	No	No	No	Accessible in the same model.	Signature can be changed
protected	No	Yes, unless marked final	No	Accessible from with the class it is defined and from derived classes.	Signature must remain compatible
public	Yes	Yes, unless marked final	No	Accessible from within the class it is defined, derived classes, and other classes that have access to the defining class.	Signature must remain compatible

Hookable

If a method is hookable, extenders can subscribe to pre-events and post-events.

For public methods, you can opt out by adding [Hookable(false)] to the method.

You can opt in for private and protected methods by adding [Hookable(true)] to the method.

If a method is explicitly marked as [Hookable(false)], then it is not wrappable.

Best practices when you write code

When a method is hookable, the compiler generates extra intermediate language (IL) code to enable the method as an extension point. Although the extra code has performance overhead, this overhead is negligible in most cases. However, for performance-critical methods, consider marking the method as non-hookable.

Wrappable

If a method is wrappable, extenders can wrap it by using Chain of Command (CoC). Extenders must call next, because they aren't allowed to break the CoC.

For protected and public methods, you can opt out by adding [Wrappable(false)] to the method.

You can't opt in for private methods.

Best practices when you write code

CoC resembles inheritance in many ways. Typically, if you want other people to be able to call your method but not change it, you mark the method as final. Consider marking these methods as non-wrappable or non-hookable.

Replaceable

If a method is replaceable, extenders can wrap it by using CoC, but they don't have to unconditionally call next. Although extenders can break the CoC, the expectation is that they will only conditionally break it. The compiler doesn't enforce calls to next.

To be replaceable, a method must also be wrappable.

For wrappable methods, you can opt in by adding [Replaceable] to the method.

Best practices when you write code

When a method is replaceable, it can be extended by using CoC, and the execution of next can be skipped. Before you enable a method to be replaceable, you should thoroughly assess the functional impact if an extender skips the execution of the method.

• Do make sure that methods that have [Replaceable] have XML documentation that describes the responsibility of the method.

• Don't use [Replaceable] to let consumers skip the replaced logic and do nothing.

• Don't use [Replaceable] for factory methods when SysExtension can be used instead.

• Avoid using [Replaceable] when the method changes databases or class state.

• Avoid using [Replaceable] if the method performs multiple operations and has multiple responsibilities. Instead, refactor the method into separate methods, each of which has a single responsibility, and consider which methods should actually be replaceable.

• Consider using [Replaceable] to solve transformations.

  Example: Enum conversion that uses a switch statement over enum values, where the default block has a throw.

• Consider using [Replaceable] to override lookups and jumprefs.

Best practices for extenders

• Don't write logic that has a different responsibility than the logic that is being replaced.
• Do call the base functionality (call next) when the replacement logic doesn't apply.
• Avoid replacing logic completely by not calling the base functionality (call next).