First pass of Tuples and types

First edit pass on tuples and types.

Author: BillWagner

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

@@ -1,37 +1,56 @@
-
-using System.Xml.Linq;
-
-FirstExample();
+// <CreateTuple>
+var pt = (X: 1, Y: 2);
+
+var slope = (double)pt.Y / (double)pt.X;
+Console.WriteLine($"A line from the origin to the point {pt} has a slope of {slope}.");
+// </CreateTuple>
+
+// <Modify>
+pt.X = pt.X + 5;
+Console.WriteLine($"The point is now at {pt}.");
+// </Modify>
+
+// <Wither>
+var pt2 = pt with { Y = 10 };
+Console.WriteLine($"The point 'pt2' is at {pt2}.");
+// </Wither>
+
+// <NamedAssignment>
+var subscript = (A: 0, B: 0);
+subscript = pt;
+Console.WriteLine(subscript);
+// </NamedAssignment>
+
+// <TupleTypes>
+var namedData = (Name: "Morning observation", Temp: 17, Wind: 4);
+var person = (FirstName: "", LastName: "");
+var order = (Product: "guitar picks", style: "triangle", quantity: 500, UnitPrice: 0.10m);
+// </TupleTypes>
+
+// <UsePointRecord>
+Point pt3 = new Point(1, 1);
+var pt4 = pt3 with { Y = 10 };
+Console.WriteLine($"The two points are {pt} and {pt2}");
+// </UsePointRecord>
+
+// <UseSlope>
+double slopeResult = pt4.Slope();
+Console.WriteLine($"The slope of {pt4} is {slopeResult}");
+// </UseSlope>
+
+// <RecordStructPoint>
+public record struct Point(int X, int Y)
+// </RecordStructPoint>
+// <AddSlopeMethod>
+{
+    public double Slope() => (double)Y / (double)X;
+}
+// </AddSlopeMethod>
 
-void FirstExample()
+namespace PrimaryRecord
 {
-    // <CreateTuple>
-    var pt = (X: 1, Y: 2);
-
-    var slope = (double)pt.Y / (double)pt.X;
-    Console.WriteLine($"A line from the origin to the point {pt} has a slope of {slope}.");
-    // </CreateTuple>
-
-    // <Modify>
-    pt.X = pt.X + 5;
-    Console.WriteLine($"The point is now at {pt}.");
-    // </Modify>
-
-    // <Wither>
-    var pt2 = pt with { Y = 10 };
-    Console.WriteLine($"The point 'pt2' is at {pt2}.");
-    // </Wither>
-
-    // <NamedAssignment>
-    var subscript = (A: 0, B: 0);
-    subscript = pt;
-    Console.WriteLine(subscript);
-    // </NamedAssignment>
-
-    // <TupleTypes>
-    var namedData = (Name: "Morning observation", Temp: 17, Wind: 4);
-    var person = (FirstName: "", LastName: "");
-    var order = (Product: "guitar picks", style: "triangle", quantity: 500, UnitPrice: 0.10m);
-    // </TupleTypes>
+    // <PointRecord>
+    public record Point(int X, int Y);
+    // </PointRecord>
 }
 

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

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

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

@@ -1,37 +1,36 @@
 ---
-title: Tuples and types - Introductory interactive tutorial
-description: In this tutorial about creating types, you use your browser to learn C# interactively. You're going to write C# code and see the results of compiling and running your code directly in the browser.
-ms.date: 04/03/2025
+title: Tuples and types - Introductory tutorial
+description: This tutorial teaches you to create types in C#. You write C# code and see the results of compiling and running your code as you learn the structure of types.
+ms.date: 12/03/2025
 ---
 # Create types in C\#
 
 This tutorial teaches you about creating types in C#. You write small amounts of code, then you compile and run that code. The tutorial contains a series of lessons that explore different kinds of types in C#. These lessons teach you the fundamentals of the C# language.
 
-> [!TIP]
-> When a code snippet block includes the "Run" button, that button opens the interactive window, or replaces the existing code in the interactive window. When the snippet doesn't include a "Run" button, you can copy the code and add it to the current interactive window.
-
 The preceding tutorials worked with text and numbers. Strings and Numbers are *simple types*: They each store one single value. As your programs grow larger, you need to work with more sophisticated data structures. C# provides different kinds of types you can define when you need data structures with more fields, properties, or behavior. Let's start to explore those types.
 
+TODO: Create sample.
+
 ## Tuples
 
-*Tuples* are an ordered sequence of values with a fixed length. Each element of a tuple has a type and an optional name. The following code declares a tuple that represents a 2D point. Select the "Run" button to paste the following code into the interactive window and run it.
+*Tuples* are an ordered sequence of values with a fixed length. Each element of a tuple has a type and an optional name. The following code declares a tuple that represents a 2D point. Copy the following code to your file and type `dotnet run`.
 
-:::code language="csharp" interactive="try-dotnet-method" source="./snippets/TuplesAndTypes/Program.cs" id="CreateTuple":::
+:::code language="csharp" source="./snippets/TuplesAndTypes/Program.cs" id="CreateTuple":::
 
 > [!TIP]
-> As you explore C# (or any programming language), you make mistakes when you write code. The **compiler** finds those errors and reports them to you. When the output contains error messages, look closely at the example code and the code in the interactive window to see what to fix. That exercise helps you learn the structure of C# code.
+> As you explore C# (or any programming language), you make mistakes when you write code. The **compiler** finds those errors and reports them to you. When the output contains error messages, look closely at the example code and your code to see what to fix. That exercise helps you learn the structure of C# code. You can also ask Copilot to find differences or spot any mistakes.
 
-You can reassign any member of a tuple. Add the following code in the interactive window after the existing code. Press "Run" again to see the results.
+You can reassign any member of a tuple. Add the following code after the existing code. Type `dotnet run` again to see the results.
 
 :::code language="csharp" source="./snippets/TuplesAndTypes/Program.cs" id="Modify":::
 
-You can also create a new tuple that's a modified copy of the original using a `with` expression. Add the following code after the code already in the interactive window and press "Run" to see the results:
+You can also create a new tuple that's a modified copy of the original using a `with` expression. Add the following code after the existing code and type `dotnet run` to see the results:
 
 :::code language="csharp" source="./snippets/TuplesAndTypes/Program.cs" id="Wither":::
 
 The tuple `pt2` contains the `X` value of `pt` (6), and `pt2.Y` is 10.
 
-Tuples are structural types. In other words, tuple types don't have names like `string` or `int`. A tuple type is defined by the number of members, referred to as *arity*, and the types of those members. The member names are for convenience. You can assign a tuple to a tuple with the same arity and types even if the members have different names. You can add the following code after the code you already wrote in the interactive window and try it:
+Tuples are structural types. In other words, tuple types don't have names like `string` or `int`. A tuple type is defined by the number of members, referred to as *arity*, and the types of those members. The member names are for convenience. You can assign a tuple to a tuple with the same arity and types even if the members have different names. You can add the following code after the code you already wrote and try it:
 
 :::code language="csharp" source="./snippets/TuplesAndTypes/Program.cs" id="NamedAssignment":::
 
@@ -41,32 +40,35 @@ Tuples are easy to create: You declare multiple members enclosed in parentheses.
 
 :::code language="csharp" source="./snippets/TuplesAndTypes/Program.cs" id="TupleTypes":::
 
-Tuples are easy to create, but they're limited in their capabilities. Tuple types don't have names, so you can't convey meaning to the set of values. Tuple types can't add behavior. C# has other kinds of types you can create when your type defines behavior.
+While tuples are easy to create, they're limited in their capabilities. Tuple types don't have names, so you can't convey meaning to the set of values. Tuple types can't add behavior. C# has other kinds of types you can create when your type defines behavior.
 
 ## Create record types
 
 Tuples are great for those times when you want multiple values in the same structure. They're lightweight, and can be declared as they're 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. The following code sample uses a `Main` method to represent the entry point for the program. That way, you can declare a `record` type preceding the entry point in the code. Press the "Run" button on the following code to replace your existing sample with the following code.
 
-> [!WARNING]
-> Don't copy and paste. The interactive window must be reset to run the following sample. If you make a mistake, the window hangs, and you need to refresh the page to continue.
+The following code declares and uses a `record` type to represent a `Point`:
+
+:::code language="csharp" source="./snippets/TuplesAndTypes/PointEvolution.cs" id="PointRecord":::
+
+The preceding code must be at the bottom of your source file. Type declarations like `record` declarations must follow executable statements in a file-based app.
 
-The following code declares and uses a `record` type to represent a `Point`, and then uses that `Point` structure in the `Main` method:
+Add the following code preceding the `record` declaration:
 
-:::code language="csharp" interactive="try-dotnet-class" source="./snippets/TuplesAndTypes/PointEvolution.cs" id="PointVersion2":::
+:::code language="csharp" source="./snippets/TuplesAndTypes/PointEvolution.cs" id="UsePointRecord":::
 
-The `record` declaration is a single line of code for the `Point` type that stores the values `X` and `Y` in readonly properties. You use the name `Point` wherever you use that type. Properly named types, like `Point`, provide information about how the type is used. The `Main` method shows how to use a `with` expression to create a new point that's a modified copy of the existing point. The line `pt2 = pt with { Y = 10 }` says "`pt2` has the same values as `pt` except that `Y` is assigned to 10." You can add any number of properties to change in a single `with` expression.
+The `record` declaration is a single line of code for the `Point` type that stores the values `X` and `Y` in readonly properties. You use the name `Point` wherever you use that type. Properly named types, like `Point`, provide information about how the type is used. The additional code shows how to use a `with` expression to create a new point that's a modified copy of the existing point. The line `pt4 = pt3 with { Y = 10 }` says "`pt4` has the same values as `pt3` except that `Y` is assigned to 10." You can add any number of properties to change in a single `with` expression.
 
-The preceding `record` declaration is a single line of code that ends in `;`, like all C# statements. You can add behavior to a `record` type by declaring *members*. A record member can be a function, or more data elements. The members of a type are in the type declaration, between `{` and  `}` characters. Replace the record declaration you made with the following code:
+The preceding `record` declaration is a single line of code that ends in `;`. You can add behavior to a `record` type by declaring *members*. A record member can be a function, or more data elements. The members of a type are in the type declaration, between `{` and  `}` characters. Delete the `;` and add the following lines of code after the `record` declaration:
 
-:::code language="csharp" source="./snippets/TuplesAndTypes/PointStruct.cs" id="PointVersion3":::
+:::code language="csharp" source="./snippets/TuplesAndTypes/PointStruct.cs" id="AddSlopeMethod":::
 
-Then, add the following code to the `Main` method after the line containing the `with` expression:
+Then, add the following code before the `record` declaration, after the line containing the `with` expression:
 
 :::code language="csharp" source="./snippets/TuplesAndTypes/PointStruct.cs" id="UseSlope":::
 
 You added 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 that includes extra behavior. You can modify the `Point` type to make it a `record struct` as well:
 
-:::code language="csharp" source="./snippets/TuplesAndTypes/PointStruct.cs" id="RecordStruct":::
+:::code language="csharp" source="./snippets/TuplesAndTypes/PointStruct.cs" id="RecordStructPoint":::
 
 A `record struct` is a `struct` type that includes the extra behavior added to all `record` types.
 
@@ -86,7 +88,7 @@ You can also define `interface` types to declare behavioral contracts that diffe
 
 You typically use all these types in larger programs and libraries. Once you install the .NET SDK, you can explore those types using tutorials on [classes](../../fundamentals/tutorials/classes.md) in the fundamentals section.
 
-You completed the "Create types in C#" interactive tutorial. You can select the **Branches and Loops** link to start the next interactive tutorial, or you can visit the [.NET site](https://dotnet.microsoft.com/learn/dotnet/hello-world-tutorial/intro) to download the .NET SDK, create a project on your machine, and keep coding. The "Next steps" section brings you back to these tutorials.
+You completed the "Create types in C#" tutorial. You can select the **Branches and Loops** link to start the next tutorial.
 
 You can learn more about types in C# in the following articles: