Finish edits on extension members

Author: BillWagner

docs/csharp/language-reference/keywords/extension.md

@@ -1,5 +1,5 @@
 ---
-title: "extension member declarations"
+title: "Extension member declarations"
 description: "Learn the syntax to declare extension members in C#. Extension members enable you to add functionality to types and interfaces in those instances where you don't have the source for the original type. Extensions are often paired with generic interfaces to implement a common set of functionality across all types that implement that interface."
 ms.date: 04/17/2025
 f1_keywords:
@@ -8,13 +8,13 @@ f1_keywords:
 ---
 # Extension declaration (C# Reference)
 
-Beginning with C# 14, top level, non-generic `static class` declarations can use `extension` containers to declare *extension members*. Extension members are methods or properties and can appear to be instance or static members. Earlier versions of C# enable *extension methods* by adding `this` as a modifier to the first parameter of a static method declared in a top-level, non-generic static class.
+Beginning with C# 14, top level, nongeneric `static class` declarations can use `extension` containers to declare *extension members*. Extension members are methods or properties and can appear to be instance or static members. Earlier versions of C# enable *extension methods* by adding `this` as a modifier to the first parameter of a static method declared in a top-level, nongeneric static class.
 
 The `extension` block specifies the type and receiver for extension members. You can declare methods and properties inside the `extension` declaration. The following example declares a single extension block that defines an instance extension method and an instance property.
 
 :::code language="csharp" source="./snippets/extensions.cs" id="ExtensionMembers":::
 
-The `extension` defines the receiver: `sequence`, which is the an `IEnumerable<int>`. The receiver type can be non-generic, an open generic, or a closed generic type. The name `sequence` is in scope in every instance member declared in that extension. The extension method and property both access `sequence`.
+The `extension` defines the receiver: `sequence`, which is an `IEnumerable<int>`. The receiver type can be nongeneric, an open generic, or a closed generic type. The name `sequence` is in scope in every instance member declared in that extension. The extension method and property both access `sequence`.
 
 Any of the extension members can be accessed as though they were members of the receiver type:
 
@@ -24,7 +24,7 @@ You can declare any number of members in a single container, as long as they sha
 
 :::code language="csharp" source="./snippets/extensions.cs" id="StaticExtensions":::
 
-Static extensions can be called as though they are static members of the receiver type:
+Static extensions can be called as though they're static members of the receiver type:
 
 :::code language="csharp" source="./snippets/extensions.cs" id="UseStaticExtensions":::
 
@@ -41,10 +41,23 @@ The `Add` method can be called from any other method as though it was a member o
 
 Both forms of extension methods generate the same intermediate language (IL). Callers can't make a distinction between them. In fact, you can convert existing extension methods to the new member syntax without a breaking change. The formats are both binary and source compatible.
 
-TODO:  Add Generic extension members.
-- Type parameter on receiver
-- Type parameter that's not the receiver on a member
-- Type parameter on receiver + additional
+## Generic extension blocks
+
+Where you specify the type parameters for an extension member declared in an extension block depends on where that type parameter is required:
+
+- You add the type parameter to the `extension` declaration when the type parameter is used in the receiver.
+- You add the type parameter to the member declaration when the type is distinct from any type parameter specified on the receiver.
+- You can't specify the same type parameter in both locations.
+
+The following example shows an extension block for `IEnumerable<T>` where two of the extension members require a second type parameter:
+
+:::code language="csharp" source="./snippets/extensions.cs" id="GenericExtension":::
+
+The members `Append` and `Prepend` specify the *extra* type parameter for the conversion. None of the members repeat the type parameter for the receiver.
+
+The equivalent extension method declarations demonstrate how those type parameters are encoded:
+
+:::code language="csharp" source="./snippets/ExtensionMethods.cs" id="GenericExtensionMethods":::
 
 ## See also
 

docs/csharp/language-reference/keywords/snippets/ExtensionMethods.cs

@@ -26,3 +26,36 @@ public static void BasicExample()
     }
 }
 
+// <GenericExtensionMethod>
+public static class GenericExtensions
+{
+    public static IEnumerable<T> Spread<T>(this IEnumerable<T> source, int start, int count)
+        => source.Skip(start).Take(count);
+
+    public static IEnumerable<T1> Append<T1, T2>(this IEnumerable<T1> source, IEnumerable<T2> second, Func<T2, T1> Converter)
+    {
+        foreach (T1 item in source)
+        {
+            yield return item;
+        }
+        foreach (T2 item in second)
+        {
+            yield return Converter(item);
+        }
+    }
+
+    public static IEnumerable<T1> Prepend<T1, TArg>(this IEnumerable<T1> source, IEnumerable<T2> second, Func<T2, T1> Converter)
+    {
+        foreach (T2 item in second)
+        {
+            yield return Converter(item);
+        }
+        foreach (T1 item in source)
+        {
+            yield return item;
+        }
+    }
+}
+// </GenericExtensionMethod>
+
+

docs/csharp/language-reference/keywords/snippets/Extensions.cs

@@ -58,6 +58,41 @@ public static IEnumerable<int> Generate(int low, int count, int increment)
     // </StaticExtensions>
 }
 
+// <GenericExtension>
+public static class GenericExtensions
+{
+    extension<TReceiver>(IEnumerable<TReceiver> source)
+    {
+        public IEnumerable<TReceiver> Spread(int start, int count)
+            => source.Skip(start).Take(count);
+
+        public IEnumerable<TReceiver> Append<TArg>(IEnumerable<TArg> second, Func<TArg, TReceiver> Converter)
+        {
+            foreach(TReceiver item in source)
+            {
+                yield return item;
+            }
+            foreach (TArg item in second)
+            {
+                yield return Converter(item);
+            }
+        }
+
+        public IEnumerable<TReceiver> Prepend<TArg>(IEnumerable<TArg> second, Func<TArg, TReceiver> Converter)
+        {
+            foreach (TArg item in second)
+            {
+                yield return Converter(item);
+            }
+            foreach (TReceiver item in source)
+            {
+                yield return item;
+            }
+        }
+    }
+}
+// </GenericExtension>
+
 public static class ExtensionExamples
 {
     public static void BasicExample()