Replace extension method with member

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 the first argument of [extension members](../../programming-guide/classes-and-structs/extension-methods.md), the parameter with the `this` modifier. Implicit span conversions aren't considered for method group conversions.
 
 ## See also