06-extension-methods.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Extension methods\n",
    "\n",
    "Extensions methods allows to add additional methods to an existing type without actually modifying or extending that type. The method is added to the different actual class, but the method can be used as being in the extended class.\n",
    "\n",
    "This is useful when dealing with `sealed` classes, the types that are coming from external libraries or when there is some shared behavior between group of types, that is not well represented in the inheritance hierarchy."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Extension method is created by prepending `this` keyword to first argument to the `static` method in the `static` class. The first argument with the prepended `this` keyword indicates which to what type this extension method is being added to. Extension method can have any additional following arguments, just like any other regular method could."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "internal sealed class SealedClass\n",
    "{\n",
    "    public void Method()\n",
    "    {\n",
    "        Console.WriteLine(\"Hello, World!\");\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "// Imagine that the following commented out lines are actually uncommented.\n",
    "// Static classes must be defined at the top level. Because of how these interactive\n",
    "// notebooks work, there is already \"hidden\" class wrapping these cells, so it is not\n",
    "// possible to define a static class here.\n",
    "\n",
    "// The example with the uncommended class declaration would work perfectly fine in a\n",
    "// regular C# project.\n",
    "\n",
    "// internal static sealed class SealedStaticClass\n",
    "// {\n",
    "    public static void ExtensionMethod(this SealedClass sealedClass)\n",
    "    {\n",
    "        Console.WriteLine(\"Hello, World! (from extension method)\");\n",
    "    }\n",
    "// }\n",
    "\n",
    "var sealedClass = new SealedClass();\n",
    "sealedClass.ExtensionMethod();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "// Basic types can be extended as well.\n",
    "\n",
    "public static int Increment(this int value)\n",
    "{\n",
    "    return value + 1;\n",
    "}\n",
    "\n",
    "int number = 5;\n",
    "int incrementedNumber = number.Increment();\n",
    "\n",
    "Console.WriteLine(incrementedNumber);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "// Extension method can be used on derived types as well.\n",
    "\n",
    "internal class TopLevelClass\n",
    "{\n",
    "    public void Method()\n",
    "    {\n",
    "        Console.WriteLine(\"Hello, World!\");\n",
    "    }\n",
    "}\n",
    "\n",
    "internal class DerivedClass : TopLevelClass\n",
    "{\n",
    "}\n",
    "\n",
    "public static void ExtensionMethod(this DerivedClass derivedClass)\n",
    "{\n",
    "    Console.WriteLine(\"Hello, World! (from extension method)\");\n",
    "}\n",
    "\n",
    "var derivedClass = new DerivedClass();\n",
    "derivedClass.ExtensionMethod();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "// Same would work by adding extension mehtod on the object class.\n",
    "\n",
    "public static void ExtensionMethod(this object obj)\n",
    "{\n",
    "    Console.WriteLine(\"Hello, World! (from extension method)\");\n",
    "}\n",
    "\n",
    "var str = \"Hello, World!\";\n",
    "str.ExtensionMethod();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Extensions methods are also useful in cases only when an interface is shared between types, but there is no inheritance hierarchy. Interfaces are usually more lightweight than inheritance and it is easier to add them if needed. For example, let's say there was an interface `IGeometricShape`:\n",
    "\n",
    "```csharp\n",
    "interface IGeometricShape\n",
    "{\n",
    "    double[] GetSideLengths();\n",
    "}\n",
    "```\n",
    "\n",
    "There might be many different geometrical shapes, which might not have all that many behavior in common with each other for the inheritance hierarchy to make sense, but the small interface might be sensible.\n",
    "\n",
    "In such case a extension method could be added, that makes use of public methods available from that interface:\n",
    "```csharp\n",
    "public static class GeometricShapeExtensions\n",
    "{\n",
    "    public static double GetPerimeter(this IGeometricShape shape)\n",
    "    {\n",
    "        return shape.GetSideLengths().Sum();\n",
    "    }\n",
    "}\n",
    "```"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".NET (C#)",
   "language": "C#",
   "name": ".net-csharp"
  },
  "language_info": {
   "name": "csharp"
  },
  "polyglot_notebook": {
   "kernelInfo": {
    "defaultKernelName": "csharp",
    "items": [
     {
      "aliases": [],
      "name": "csharp"
     }
    ]
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}