update samples on enums

Author: BillWagner

docs/csharp/programming-guide/classes-and-structs/extension-methods.md

@@ -76,9 +76,17 @@ You can use extension methods to extend a class or interface, but not to overrid
 
 ## Extension members and instance members
 
-Overload resolution prefers members declared in a type over extension members. Extension members can't override an existing method. The following example demonstrates the rules that the C# compiler follows in determining whether to bind to an instance member on the type, or to an extension member. The static class `Extensions` contains extension members defined for any type that implements `IMyInterface`. Classes `A`, `B`, and `C` all implement the interface. The `MethodB` extension method is never called because its name and signature exactly match methods already implemented by the classes. When the compiler can't find an instance method with a matching signature, it will bind to a matching extension method if one exists.
+Overload resolution prefers members declared in a type over extension members. Extension members can't override an existing method. The following example demonstrates the rules that the C# compiler follows in determining whether to bind to an instance member on the type, or to an extension member. The static class `Extensions` contains extension members defined for any type that implements `IMyInterface`:
 
-:::code language="csharp" source="./snippets/ExtensionMembers/CustomExtensionMethods.cs" id="MegaDemoBreakThisUp":::
+:::code language="csharp" source="./snippets/ExtensionMembers/CustomExtensionMethods.cs" id="InterfaceAndExtensions":::
+
+Classes `A`, `B`, and `C` all implement the interface:
+
+:::code language="csharp" source="./snippets/ExtensionMembers/CustomExtensionMethods.cs" id="Classes":::
+
+The `MethodB` extension method is never called because its name and signature exactly match methods already implemented by the classes. When the compiler can't find an instance method with a matching signature, it will bind to a matching extension method if one exists.
+
+:::code language="csharp" source="./snippets/ExtensionMembers/CustomExtensionMethods.cs" id="CallExtensionMethods":::
 
 ## Common usage patterns
 

docs/csharp/programming-guide/classes-and-structs/how-to-create-a-new-method-for-an-enumeration.md

@@ -12,11 +12,22 @@ ms.topic: how-to
 
 You can use extension methods to add functionality specific to a particular enum type. In the following example, the `Grades` enumeration represents the possible letter grades that a student might receive in a class. An extension method named `Passing` is added to the `Grades` type so that each instance of that type now "knows" whether it represents a passing grade or not.
 
-<<TODO: New extension members style too>>
+:::code language="csharp" source="./snippets/ExtensionMembers/CustomExtensionMethods.cs" id="ExtendEnumType":::
 
-:::code language="csharp" source="./snippets/ExtensionMembers/CustomExtensionMethods.cs" id="EnumMethods":::
+You can call the extension method as though it was declared on the `enum` type:
+
+:::code language="csharp" source="./snippets/ExtensionMembers/CustomExtensionMethods.cs" id="ExampleExtendEnum":::
+
+Beginning with C# 14, you can declare *extension members* in an extension block. The new syntax enables you to add *extension properties*. You can also add extension members that appear to be new static methods or properties. You're no longer limited to extensions that appear to be instance methods. The following example shows an extension block that adds an instance extension property for `Passing`, and a static extension property for `MinimumPassingGrade`:
+
+:::code language="csharp" source="./snippets/ExtensionMembers/CustomExtensionMembers.cs" id="EnumExtensionMembers":::
+
+You call these new extension properties as though they are declared on the extended type:
+
+:::code language="csharp" source="./snippets/ExtensionMembers/CustomExtensionMembers.cs" id="EnumExtensionMembers":::
+
+You can learn more about the new extension members in the article on [extension members](./extension-methods.md) and in the language reference article on the ['extension` keyword](../../language-reference/keywords/extension.md).
 
-The `Extensions` class also contains a static variable that is updated dynamically and that the return value of the extension method reflects the current value of that variable. The preceding code demonstrates that, behind the scenes, extension methods are invoked directly on the static class in which they're defined.
 
 ## See also
 

docs/csharp/programming-guide/classes-and-structs/snippets/ExtensionMembers/CustomExtensionMembers.cs

@@ -0,0 +1,57 @@
+using CustomExtensionMethods;
+
+namespace CustomExtensionMembers;
+
+public enum Grades
+{
+    F = 0,
+    D = 1,
+    C = 2,
+    B = 3,
+    A = 4
+};
+
+// <EnumExtensionMembers>
+public static class EnumExtensions
+{
+    private static Grades minimumPassingGrade = Grades.D;
+
+    extension(Grades grade)
+    {
+        public static Grades MinimumPassingGrade
+        {
+            get => minimumPassingGrade;
+            set => minimumPassingGrade = value;
+        }
+
+        public bool Passing => grade >= minimumPassingGrade;
+    }
+}
+// </EnumExtensionMembers>
+
+public static class ExtensionMemberUsage
+{
+    public static void Examples()
+    {
+        // <ExampleExtendEnum>
+        Grades g1 = Grades.D;
+        Grades g2 = Grades.F;
+        Console.WriteLine($"First {(g1.Passing ? "is" : "is not")} a passing grade.");
+        Console.WriteLine($"Second {(g2.Passing ? "is" : "is not")} a passing grade.");
+
+        Grades.MinimumPassingGrade = Grades.C;
+        Console.WriteLine($"\r\nRaising the bar. Passing grade is now {Grades.MinimumPassingGrade}!\r\n");
+        Console.WriteLine($"First {(g1.Passing ? "is" : "is not")} a passing grade.");
+        Console.WriteLine($"Second {(g2.Passing ? "is" : "is not")} a passing grade.");
+        /* Output:
+            First is a passing grade.
+            Second is not a passing grade.
+
+            Raising the bar!
+
+            First is not a passing grade.
+            Second is not a passing grade.
+        */
+        // </ExampleExtendEnum>
+    }
+}

docs/csharp/programming-guide/classes-and-structs/snippets/ExtensionMembers/CustomExtensionMethods.cs

@@ -8,12 +8,9 @@ public static int WordCount(this string str) =>
 }
 //</ClassicExtensionMethod>
 
-//<MegaDemoBreakThisUp>
-// Define an interface named IMyInterface.
+//<InterfaceAndExtensions>
 public interface IMyInterface
 {
-    // Any class that implements IMyInterface must define a method
-    // that matches the following signature.
     void MethodB();
 }
 
@@ -23,28 +20,21 @@ public interface IMyInterface
 // class that implements IMyInterface.
 public static class Extension
 {
-    public static void MethodA(this IMyInterface myInterface, int i)
-    {
-        Console.WriteLine
-            ("Extension.MethodA(this IMyInterface myInterface, int i)");
-    }
+    public static void MethodA(this IMyInterface myInterface, int i) =>
+        Console.WriteLine("Extension.MethodA(this IMyInterface myInterface, int i)");
 
-    public static void MethodA(this IMyInterface myInterface, string s)
-    {
-        Console.WriteLine
-            ("Extension.MethodA(this IMyInterface myInterface, string s)");
-    }
+    public static void MethodA(this IMyInterface myInterface, string s) =>
+        Console.WriteLine("Extension.MethodA(this IMyInterface myInterface, string s)");
 
     // This method is never called in ExtensionMethodsDemo1, because each
     // of the three classes A, B, and C implements a method named MethodB
     // that has a matching signature.
-    public static void MethodB(this IMyInterface myInterface)
-    {
-        Console.WriteLine
-            ("Extension.MethodB(this IMyInterface myInterface)");
-    }
+    public static void MethodB(this IMyInterface myInterface) =>
+        Console.WriteLine("Extension.MethodB(this IMyInterface myInterface)");
 }
+//<InterfaceAndExtensions>
 
+// <Classes>
 // Define three classes that implement IMyInterface, and then use them to test
 // the extension methods.
 class A : IMyInterface
@@ -66,11 +56,31 @@ public void MethodA(object obj)
         Console.WriteLine("C.MethodA(object obj)");
     }
 }
+// </Classes>
+
+//<ExtendEnumType>
+public enum Grades
+{
+    F = 0,
+    D = 1,
+    C = 2,
+    B = 3,
+    A = 4
+};
+
+// Define an extension method in a non-nested static class.
+public static class Extensions
+{
+    public static bool Passing(this Grades grade, Grades minPassing = Grades.D) =>
+        grade >= minPassing;
+}
+//</ExtendEnumType>
 
-class ExtMethodDemo
+public static class ExtensionMethodUsage
 {
-    static void Main(string[] args)
+    public static void Examples()
     {
+        // <CallExtensionMethods>
         // Declare an instance of class A, class B, and class C.
         A a = new A();
         B b = new B();
@@ -104,36 +114,20 @@ static void Main(string[] args)
         c.MethodA(1);           // C.MethodA(object)
         c.MethodA("hello");     // C.MethodA(object)
         c.MethodB();            // C.MethodB()
-    }
-}
-/* Output:
-    Extension.MethodA(this IMyInterface myInterface, int i)
-    Extension.MethodA(this IMyInterface myInterface, string s)
-    A.MethodB()
-    B.MethodA(int i)
-    B.MethodB()
-    Extension.MethodA(this IMyInterface myInterface, string s)
-    C.MethodA(object obj)
-    C.MethodA(object obj)
-    C.MethodB()
- */
-//</MegaDemoBreakThisUp>
-
-//<EnumMethods>
-// Define an extension method in a non-nested static class.
-public static class Extensions
-{
-    public static bool Passing(this Grades grade, Grades minPassing = Grades.D)
-    {
-        return grade >= minPassing;
-    }
-}
-
-public enum Grades { F = 0, D = 1, C = 2, B = 3, A = 4 };
-class Program
-{
-    static void Main(string[] args)
-    {
+        /* Output:
+            Extension.MethodA(this IMyInterface myInterface, int i)
+            Extension.MethodA(this IMyInterface myInterface, string s)
+            A.MethodB()
+            B.MethodA(int i)
+            B.MethodB()
+            Extension.MethodA(this IMyInterface myInterface, string s)
+            C.MethodA(object obj)
+            C.MethodA(object obj)
+            C.MethodB()
+         */
+        // </CallExtensionMethods>
+
+        // <ExampleExtendEnum>
         Grades g1 = Grades.D;
         Grades g2 = Grades.F;
         Console.WriteLine($"First {(g1.Passing() ? "is" : "is not")} a passing grade.");
@@ -142,15 +136,15 @@ static void Main(string[] args)
         Console.WriteLine("\r\nRaising the bar!\r\n");
         Console.WriteLine($"First {(g1.Passing(Grades.C) ? "is" : "is not")} a passing grade.");
         Console.WriteLine($"Second {(g2.Passing(Grades.C) ? "is" : "is not")} a passing grade.");
-    }
-    /* Output:
-        First is a passing grade.
-        Second is not a passing grade.
+        /* Output:
+            First is a passing grade.
+            Second is not a passing grade.
 
-        Raising the bar!
+            Raising the bar!
 
-        First is not a passing grade.
-        Second is not a passing grade.
-    */
+            First is not a passing grade.
+            Second is not a passing grade.
+        */
+        // </ExampleExtendEnum>
+    }
 }
-//</EnumMethods>

docs/csharp/programming-guide/classes-and-structs/snippets/ExtensionMembers/ExtensionMembers.csproj

@@ -5,6 +5,7 @@
     <TargetFramework>net10.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
+    <LangVersion>preview</LangVersion>
   </PropertyGroup>
 
 </Project>

docs/csharp/programming-guide/classes-and-structs/snippets/ExtensionMembers/ExtensionMethods.cs

@@ -1,4 +1,4 @@
-namespace ExtensionMembers;
+ namespace ExtensionMethods;
 public static class ExtensionMethods
 {
     public static void Examples()

docs/csharp/programming-guide/classes-and-structs/snippets/ExtensionMembers/Program.cs

@@ -1,2 +1,4 @@
-// See https://aka.ms/new-console-template for more information
-Console.WriteLine("Hello, World!");
+
+ExtensionMethods.ExtensionMethods.Examples();
+CustomExtensionMethods.ExtensionMethodUsage.Examples();
+CustomExtensionMembers.ExtensionMemberUsage.Examples();