correct interactive bits.

Use the class type, and declare a `Main` method.

Author: BillWagner

docs/csharp/tour-of-csharp/tutorials/snippets/TuplesAndTypes/PointEvolution.cs

@@ -1,20 +1,15 @@
 namespace PointEvolution;
 
-// <PointVersion2>
-public record Point(int X, int Y)
+public static class SampleTwo
 {
-    public double Slope() => (double)Y / (double)X;
-}
-// </PointVersion2>
+    // <PointVersion2>
+    public record Point(int X, int Y);
 
-public static class Expected
-{
-    public static void Example()
+    public static void Main()
     {
-        // <Version2Usage>
         Point pt = new Point(1, 1);
-        double slope = pt.Slope();
-        Console.WriteLine($"The slope of {pt} is {slope}");
-        // </Version2Usage>
+        var pt2 = pt with { Y = 10 };
+        Console.WriteLine($"The two points are {pt} and {pt2}");
     }
+    // </PointVersion2>
 }

docs/csharp/tour-of-csharp/tutorials/snippets/TuplesAndTypes/PointStruct.cs

@@ -1,8 +1,31 @@
-namespace MoreStruct;
+namespace FinalRecord
+{
+    public static class SampleThree
+    {
+        // <PointVersion3>
+        public record Point(int X, int Y)
+        {
+            public double Slope() => (double)Y / (double)X;
+        }
+        // </PointVersion3>
+        public static void Main()
+        {
+            Point pt = new Point(1, 1);
+            var pt2 = pt with { Y = 10 };
+            // <UseSlope>
+            double slope = pt.Slope();
+            Console.WriteLine($"The slope of {pt} is {slope}");
+            // </UseSlope>
+        }
+    }
+}
 
-// <RecordStruct>
-public record struct Point(int X, int Y)
+namespace MoreStruct
 {
-    public double Slope() => (double) Y / (double) X;
+    // <RecordStruct>
+    public record struct Point(int X, int Y)
+    {
+        public double Slope() => (double) Y / (double) X;
+    }
+    // </RecordStruct>
 }
-// </RecordStruct>

docs/csharp/tour-of-csharp/tutorials/snippets/TuplesAndTypes/Program.cs

@@ -35,14 +35,3 @@ void FirstExample()
     // </TupleTypes>
 }
 
-// <CreateRecord>
-Point pt = new Point(1, 1);
-var pt2 = pt with { Y = 10 };
-// </CreateRecord>
-
-PointEvolution.Expected.Example();
-
-// <DeclareRecord>
-public record Point(int X, int Y);
-// </DeclareRecord>
-

docs/csharp/tour-of-csharp/tutorials/tuples-and-types.md

@@ -49,19 +49,15 @@ Tuples are easy to create, but they are limited in their capabilities. Tuple typ
 
 Tuples are great for those times when you want multiple values in the same structure. They're lightweight, and can be declared as they are used. As your program goes, you might find that you use the same tuple type throughout your code. If your app does work in the 2D graph space, the tuples that represent points might be common. Once you find that, you can declare a `record` type that stores those values and provides more capabilities:
 
-:::code language="csharp" interactive="try-dotnet-program" source="./snippets/TuplesAndTypes/Program.cs" id="DeclareRecord":::
+:::code language="csharp" interactive="try-dotnet-class" source="./snippets/TuplesAndTypes/PointEvolution.cs" id="PointVersion2":::
 
-The preceding single line of code declares a named *record* type that stores the values `X` and `Y` in readonly properties. You use the name `Point` wherever you use that type. Using a named type makes it clear how the type is used. Unlike tuples, you can't change the value of a property in a record, but you can still make a new copy using a `with` expression:
+The preceding single line of code declares a named *record* type that stores the values `X` and `Y` in readonly properties. You use the name `Point` wherever you use that type. Using a named type makes it clear how the type is used. Unlike tuples, you can't change the value of a property in a record, but you can still make a new copy using a `with` expression. Record types can include behavior as well as data. In C#, any type declaration starts with `{` and ends with `}`. Replace the record declaration you made with the following:
 
-:::code language="csharp" source="./snippets/TuplesAndTypes/Program.cs" id="CreateRecord":::
+:::code language="csharp" source="./snippets/TuplesAndTypes/PointStruct.cs" id="PointVersion3":::
 
-Record types can include behavior as well as data. In C#, any type declaration starts with `{` and ends with `}`. Replace the record declaration you made with the following:
+:::code language="csharp" source="./snippets/TuplesAndTypes/PointStruct.cs" id="UseSlope":::
 
-:::code language="csharp" source="./snippets/TuplesAndTypes/PointEvolution.cs" id="PointVersion2":::
-
-You can call it like the following:
-
-:::code language="csharp" source="./snippets/TuplesAndTypes/PointEvolution.cs" id="Version2Usage":::
+The `Main` method shows how you can create and use this record type.
 
 You've added a bit of formality to the *tuple* representing an `X` and `Y` value. You made it a `record` that defined a named type, and included a member to calculate the slope. A `record` type is a shorthand for a `record class`: A `class` type where some types are generated by the compiler. You can modify the `Point` type to make it a `record struct` as well: