Replace extension method with member (dotnet#50113)

* Replace extension method with member

Where samples use `this` extension methods, except where explaining the `this` syntax, convert to the C# 14 extension member syntax,

* Fix build issues

* Add updates in the advanced-topics section

* Add other C# folders

This adds all the folders *except* tutorials and LINQ. (Those will be in separate PRs)

* Add the fundamentals folder

* Apply suggestions from code review

Co-authored-by: Copilot <[email protected]>

* Apply suggestions from code review

Co-authored-by: Genevieve Warren <[email protected]>

* Respond to feedback.

---------

Co-authored-by: Copilot <[email protected]>
Co-authored-by: Genevieve Warren <[email protected]>

Author: 3 people

docs/csharp/advanced-topics/interface-implementation/mixins-with-default-interface-methods.md

@@ -1,7 +1,7 @@
 ---
 title: Create mixin types using default interface methods
 description: Using default interface members you can extend interfaces with optional default implementations for implementors.
-ms.date: 07/31/2024
+ms.date: 11/24/2025
 ---
 # Tutorial: Mix functionality in when creating classes using interfaces with default interface methods
 
@@ -19,13 +19,13 @@ In this tutorial, you learn how to:
 
 You need to set up your machine to run .NET, including the C# compiler. The C# compiler is available with [Visual Studio 2022](https://visualstudio.microsoft.com/downloads), or the [.NET SDK](https://dotnet.microsoft.com/download/dotnet).
 
-## Limitations of extension methods
+## Limitations of extensions
 
-One way you can implement behavior that appears as part of an interface is to define [extension methods](../../programming-guide/classes-and-structs/extension-methods.md) that provide the default behavior. Interfaces declare a minimum set of members while providing a greater surface area for any class that implements that interface. For example, the extension methods in <xref:System.Linq.Enumerable> provide the implementation for any sequence to be the source of a LINQ query.
+One way you can implement behavior that appears as part of an interface is to define [extension members](../../programming-guide/classes-and-structs/extension-methods.md) that provide the default behavior. Interfaces declare a minimum set of members while providing a greater surface area for any class that implements that interface. For example, the extension members in <xref:System.Linq.Enumerable> provide the implementation for any sequence to be the source of a LINQ query.
 
-Extension methods are resolved at compile time, using the declared type of the variable. Classes that implement the interface can provide a better implementation for any extension method. Variable declarations must match the implementing type to enable the compiler to choose that implementation. When the compile-time type matches the interface, method calls resolve to the extension method. Another concern with extension methods is that those methods are accessible wherever the class containing the extension methods is accessible. Classes can't declare if they should or shouldn't provide features declared in extension methods.
+Extension members are resolved at compile time, using the declared type of the variable. Classes that implement the interface can provide a better implementation for any extension member. Variable declarations must match the implementing type to enable the compiler to choose that implementation. When the compile-time type matches the interface, method calls resolve to the extension member. Another concern with extension members is that those members are accessible wherever the class containing the extension member is accessible. Classes can't declare if they should or shouldn't provide features declared in extension members.
 
-You can declare the default implementations as interface methods. Then, every class automatically uses the default implementation. Any class that can provide a better implementation can override the interface method definition with a better algorithm. In one sense, this technique sounds similar to how you could use [extension methods](../../programming-guide/classes-and-structs/extension-methods.md).
+You can declare the default implementations as interface methods. Then, every class automatically uses the default implementation. Any class that can provide a better implementation can override the interface method definition with a better algorithm. In one sense, this technique sounds similar to how you could use [extension members](../../programming-guide/classes-and-structs/extension-methods.md).
 
 In this article, you learn how default interface implementations enable new scenarios.
 
@@ -38,7 +38,7 @@ Consider a home automation application. You probably have many different types o
 
 Some of these extended capabilities could be emulated in devices that support the minimal set. That indicates providing a default implementation. For those devices that have more capabilities built in, the device software would use the native capabilities. For other lights, they could choose to implement the interface and use the default implementation.
 
-Default interface members provide a better solution for this scenario than extension methods. Class authors can control which interfaces they choose to implement. Those interfaces they choose are available as methods. In addition, because default interface methods are virtual by default, the method dispatch always chooses the implementation in the class.
+Default interface members provide a better solution for this scenario than extension members. Class authors can control which interfaces they choose to implement. Those interfaces they choose are available as methods. In addition, because default interface methods are virtual by default, the method dispatch always chooses the implementation in the class.
 
 Let's create the code to demonstrate these differences.
 

docs/csharp/advanced-topics/interface-implementation/snippets/mixins-with-default-interface-methods/mixins-with-interfaces.csproj

@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <Nullable>enable</Nullable>
     <ImplicitUsings>enable</ImplicitUsings>
     <RootNamespace>mixins_with_interfaces</RootNamespace>

docs/csharp/fundamentals/functional/snippets/deconstructing-tuples/deconstruct-extension1.cs

@@ -4,84 +4,87 @@
 
 public static class ReflectionExtensions
 {
-    public static void Deconstruct(this PropertyInfo p, out bool isStatic,
-                                   out bool isReadOnly, out bool isIndexed,
-                                   out Type propertyType)
+    extension(PropertyInfo propertyInfo)
     {
-        var getter = p.GetMethod;
+        public void Deconstruct(out bool isStatic,
+                                out bool isReadOnly, out bool isIndexed,
+                                out Type propertyType)
+        {
+            var getter = propertyInfo.GetMethod;
 
-        // Is the property read-only?
-        isReadOnly = ! p.CanWrite;
+            // Is the property read-only?
+            isReadOnly = ! propertyInfo.CanWrite;
 
-        // Is the property instance or static?
-        isStatic = getter.IsStatic;
+            // Is the property instance or static?
+            isStatic = getter.IsStatic;
 
-        // Is the property indexed?
-        isIndexed = p.GetIndexParameters().Length > 0;
+            // Is the property indexed?
+            isIndexed = propertyInfo.GetIndexParameters().Length > 0;
 
-        // Get the property type.
-        propertyType = p.PropertyType;
-    }
+            // Get the property type.
+            propertyType = propertyInfo.PropertyType;
+        }
 
-    public static void Deconstruct(this PropertyInfo p, out bool hasGetAndSet,
-                                   out bool sameAccess, out string access,
-                                   out string getAccess, out string setAccess)
-    {
-        hasGetAndSet = sameAccess = false;
-        string getAccessTemp = null;
-        string setAccessTemp = null;
+        public void Deconstruct(out bool hasGetAndSet,
+                                out bool sameAccess, out string access,
+                                out string getAccess, out string setAccess)
+        {
+            hasGetAndSet = sameAccess = false;
+            string getAccessTemp = null;
+            string setAccessTemp = null;
 
-        MethodInfo getter = null;
-        if (p.CanRead)
-            getter = p.GetMethod;
+            MethodInfo getter = null;
+            if (propertyInfo.CanRead)
+                getter = propertyInfo.GetMethod;
 
-        MethodInfo setter = null;
-        if (p.CanWrite)
-            setter = p.SetMethod;
+            MethodInfo setter = null;
+            if (propertyInfo.CanWrite)
+                setter = propertyInfo.SetMethod;
 
-        if (setter != null && getter != null)
-            hasGetAndSet = true;
+            if (setter != null && getter != null)
+                hasGetAndSet = true;
 
-        if (getter != null)
-        {
-            if (getter.IsPublic)
-                getAccessTemp = "public";
-            else if (getter.IsPrivate)
-                getAccessTemp = "private";
-            else if (getter.IsAssembly)
-                getAccessTemp = "internal";
-            else if (getter.IsFamily)
-                getAccessTemp = "protected";
-            else if (getter.IsFamilyOrAssembly)
-                getAccessTemp = "protected internal";
-        }
+            if (getter != null)
+            {
+                if (getter.IsPublic)
+                    getAccessTemp = "public";
+                else if (getter.IsPrivate)
+                    getAccessTemp = "private";
+                else if (getter.IsAssembly)
+                    getAccessTemp = "internal";
+                else if (getter.IsFamily)
+                    getAccessTemp = "protected";
+                else if (getter.IsFamilyOrAssembly)
+                    getAccessTemp = "protected internal";
+            }
 
-        if (setter != null)
-        {
-            if (setter.IsPublic)
-                setAccessTemp = "public";
-            else if (setter.IsPrivate)
-                setAccessTemp = "private";
-            else if (setter.IsAssembly)
-                setAccessTemp = "internal";
-            else if (setter.IsFamily)
-                setAccessTemp = "protected";
-            else if (setter.IsFamilyOrAssembly)
-                setAccessTemp = "protected internal";
-        }
+            if (setter != null)
+            {
+                if (setter.IsPublic)
+                    setAccessTemp = "public";
+                else if (setter.IsPrivate)
+                    setAccessTemp = "private";
+                else if (setter.IsAssembly)
+                    setAccessTemp = "internal";
+                else if (setter.IsFamily)
+                    setAccessTemp = "protected";
+                else if (setter.IsFamilyOrAssembly)
+                    setAccessTemp = "protected internal";
+            }
 
-        // Are the accessibility of the getter and setter the same?
-        if (setAccessTemp == getAccessTemp)
-        {
-            sameAccess = true;
-            access = getAccessTemp;
-            getAccess = setAccess = String.Empty;
-        }
-        else
-        {
-            access = null;
-            getAccess = getAccessTemp;
-            setAccess = setAccessTemp;
+            // Are the accessibility of the getter and setter the same?
+            if (setAccessTemp == getAccessTemp)
+            {
+                sameAccess = true;
+                access = getAccessTemp;
+                getAccess = setAccess = String.Empty;
+            }
+            else
+            {
+                access = null;
+                getAccess = getAccessTemp;
+                setAccess = setAccessTemp;
+            }
         }
     }
 }

docs/csharp/fundamentals/functional/snippets/deconstructing-tuples/deconstruction.csproj

@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <Nullable>enable</Nullable>
     <StartupObject>deconstruction.Program</StartupObject>
   </PropertyGroup>

docs/csharp/how-to/index.md

@@ -15,8 +15,8 @@ There are several tips and tricks that are common C# developer practices:
 
 - [Initialize objects using an object initializer](../programming-guide/classes-and-structs/how-to-initialize-objects-by-using-an-object-initializer.md).
 - [Use operator overloading](../language-reference/operators/operator-overloading.md).
-- [Implement and call a custom extension method](../programming-guide/classes-and-structs/how-to-implement-and-call-a-custom-extension-method.md).
-- [Create a new method for an `enum` type using extension methods](../programming-guide/classes-and-structs/how-to-create-a-new-method-for-an-enumeration.md).
+- [Implement and call a custom extension member](../programming-guide/classes-and-structs/how-to-implement-and-call-a-custom-extension-method.md).
+- [Create a new method for an `enum` type using extension member](../programming-guide/classes-and-structs/how-to-create-a-new-method-for-an-enumeration.md).
 
 ### Class, record, and struct members
 

docs/csharp/language-reference/attributes/caller-information.md

@@ -58,7 +58,7 @@ The compiler injects the expression used for `condition` into the `message` argu
 Argument failed validation: <func is not null>
 ```
 
-This attribute enables you to write diagnostic utilities that provide more details. Developers can more quickly understand what changes are needed. You can also use the <xref:System.Runtime.CompilerServices.CallerArgumentExpressionAttribute> to determine what expression was used as the receiver for extension methods. The following method samples a sequence at regular intervals. If the sequence has fewer elements than the frequency, it reports an error:
+This attribute enables you to write diagnostic utilities that provide more details. Developers can more quickly understand what changes are needed. You can also use the <xref:System.Runtime.CompilerServices.CallerArgumentExpressionAttribute> to determine what expression was used as the receiver for extension members. The following method samples a sequence at regular intervals. If the sequence has fewer elements than the frequency, it reports an error:
 
 :::code language="csharp" source="./snippets/CallerInformation.cs" id="ExtensionMethod":::
 

docs/csharp/language-reference/attributes/snippets/CallerInformation.cs

@@ -56,16 +56,19 @@ public static void ValidateArgument(string parameterName, bool condition, [Calle
 public static class Extensions
 {
     // <ExtensionMethod>
-    public static IEnumerable<T> Sample<T>(this IEnumerable<T> sequence, int frequency, 
-        [CallerArgumentExpression(nameof(sequence))] string? message = null)
+    extension<T>(IEnumerable<T> sequence)
     {
-        if (sequence.Count() < frequency)
-            throw new ArgumentException($"Expression doesn't have enough elements: {message}", nameof(sequence));
-        int i = 0;
-        foreach (T item in sequence)
+        public IEnumerable<T> Sample(int frequency, 
+            [CallerArgumentExpression(nameof(sequence))] string? message = null)
         {
-            if (i++ % frequency == 0)
-                yield return item;
+            if (sequence.Count() < frequency)
+                throw new InvalidOperationException($"Expression doesn't have enough elements: {message}");
+            int i = 0;
+            foreach (T item in sequence)
+            {
+                if (i++ % frequency == 0)
+                    yield return item;
+            }
         }
     }
     // </ExtensionMethod>

docs/csharp/language-reference/attributes/snippets/attributes.csproj

@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <Nullable>enable</Nullable>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <ImplicitUsings>enable</ImplicitUsings>

docs/csharp/language-reference/builtin-types/built-in-types.md

@@ -1,7 +1,7 @@
 ---
 title: "Built-in types"
 description: "Learn C# built-in value and reference types"
-ms.date: 03/07/2025
+ms.date: 11/24/2025
 helpviewer_keywords:
   - "types [C#], built-in"
   - "built-in C# types"
@@ -62,7 +62,7 @@ The C# language includes specialized rules for the <xref:System.Span`1?displayPr
 - From `System.ReadOnlySpan<E>` to `System.ReadOnlySpan<U>`, when `E` has a covariance conversion or an identity conversion to `U`
 - From `string` to `System.ReadOnlySpan<char>`
 
-The compiler never ignores any user defined conversion where an applicable *implicit span conversion* exists. Implicit span conversions can be applied to the first argument of [extension methods](../../programming-guide/classes-and-structs/extension-methods.md), the parameter with the `this` modifier. Implicit span conversions aren't considered for method group conversions.
+The compiler never ignores any user defined conversion where an applicable *implicit span conversion* exists. Implicit span conversions can be applied to receiver parameter of [extension members](../../programming-guide/classes-and-structs/extension-methods.md). The receiver parameter is specified by the [`extension`](../keywords/extension.md) keyword in an extension member. The receiver parameter is the first parameter of an extension method using the `this` modifier. Implicit span conversions aren't considered for method group conversions.
 
 ## See also
 

docs/csharp/language-reference/builtin-types/enum.md

@@ -1,7 +1,7 @@
 ---
 title: "Enumeration types"
 description: "Learn about C# enumeration types that represent a choice or a combination of choices"
-ms.date: 12/13/2019
+ms.date: 11/24/2025
 f1_keywords:
   - "enum"
   - "enum_CSharpKeyword"
@@ -10,7 +10,6 @@ helpviewer_keywords:
   - "enum type [C#]"
   - "enumeration type [C#]"
   - "bit flags [C#]"
-ms.assetid: bbeb9a0f-e9b3-41ab-b0a6-c41b1a08974c
 ---
 # Enumeration types (C# reference)
 
@@ -38,7 +37,7 @@ enum ErrorCode : ushort
 }
 ```
 
-You cannot define a method inside the definition of an enumeration type. To add functionality to an enumeration type, create an [extension method](../../programming-guide/classes-and-structs/extension-methods.md).
+You can't define a method inside the definition of an enumeration type. To add functionality to an enumeration type, create an [extension member](../../programming-guide/classes-and-structs/extension-methods.md).
 
 The default value of an enumeration type `E` is the value produced by expression `(E)0`, even if zero doesn't have the corresponding enum member.
 
@@ -50,7 +49,7 @@ C# allows implicit conversions from the literal value `0` to any enum type, and
 
 In the preceding example, both `port1` and `port2` are assigned the value `0`, but `GpioPort` has no member with that value. The <xref:System.Enum.IsDefined%2A?displayProperty=nameWithType> method confirms these are invalid enum values.
 
-This implicit conversion exists because the 0 bit pattern is the default for all struct types, including all enum types. However, it can introduce bugs in your code. To avoid these issues:
+This implicit conversion exists because the 0-bit pattern is the default for all struct types, including all enum types. However, it can introduce bugs in your code. To avoid these issues:
 
 - You should almost always define a member with value `0` in your enums.
 - Use <xref:System.Enum.IsDefined%2A?displayProperty=nameWithType> to validate enum values when converting from numeric types.
@@ -62,7 +61,7 @@ You use an enumeration type to represent a choice from a set of mutually exclusi
 
 If you want an enumeration type to represent a combination of choices, define enum members for those choices such that an individual choice is a bit field. That is, the associated values of those enum members should be the powers of two. Then, you can use the [bitwise logical operators `|` or `&`](../operators/bitwise-and-shift-operators.md#enumeration-logical-operators) to combine choices or intersect combinations of choices, respectively. To indicate that an enumeration type declares bit fields, apply the [Flags](xref:System.FlagsAttribute) attribute to it. As the following example shows, you can also include some typical combinations in the definition of an enumeration type.
 
-[!code-csharp[enum flags](snippets/shared/EnumType.cs#Flags)]
+:::code language="csharp" source="snippets/shared/EnumType.cs" id="SnippetFlags":::
 
 For more information and examples, see the <xref:System.FlagsAttribute?displayProperty=nameWithType> API reference page and the [Non-exclusive members and the Flags attribute](../../../fundamentals/runtime-libraries/system-enum.md#non-exclusive-members-and-the-flags-attribute) section of the <xref:System.Enum?displayProperty=nameWithType> API reference page.
 
@@ -76,7 +75,7 @@ You can use `System.Enum` in a base class constraint (that is known as the [enum
 
 For any enumeration type, there exist explicit conversions between the enumeration type and its underlying integral type. If you [cast](../operators/type-testing-and-cast.md#cast-expression) an enum value to its underlying type, the result is the associated integral value of an enum member.
 
-[!code-csharp[enum conversions](snippets/shared/EnumType.cs#Conversions)]
+:::code language="csharp" source="snippets/shared/EnumType.cs" id="SnippetConversions":::
 
 Use the <xref:System.Enum.IsDefined%2A?displayProperty=nameWithType> method to determine whether an enumeration type contains an enum member with the certain associated value.