In C# (and F#), one can define extension methods on interfaces. These extension methods can have implementations, which can be used as default implementations for implementors of the extension. I haven't heard a name for this technique.
Example:
[code lang="csharp"]
interface IFoo
{
}
static class IFoo_Extensions
{
public static void Foo(this IFoo self) { Console.WriteLine("Foo"); }
}
class ImplementingClass : IFoo
{
}
class MainClass
{
public static void Main (string[] args)
{
var aFoo = new ImplementingClass ();
aFoo.Foo (); //Prints "Foo" from extension default implementation
}
}
[/code]
Xamarin uses this pattern extensively when binding Objective-C Protocols, which are essentially interfaces with optional methods. For instance, if you have an interface where some methods must be implemented by the library user but some aren't, you can do this:
[code lang="csharp"]
interface IFoo
{
//Methods defined here, as always, must be implemented
void Necessary ();
}
static class IFoo_Extensions
{
//"Optional" methods defined here with default implementations
public static void Optional (this IFoo self)
{
}
}
class ImplementingClass : IFoo
{
public void Necessary ()
{
Console.WriteLine ("Necessary");
}
// public void Optional()
// {
// Console.WriteLine("Overridden");
// }
}
[/code]
Obviously, it's not exactly the same to have a default implementation defined in an extension method as it is to have an optional method that simply does not exist. But conceptually it's close enough that I've started referring to this technique as the "Protocol Pattern."
Thoughts?