add samples

Author: BillWagner

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

@@ -0,0 +1,20 @@
+namespace PointEvolution;
+
+// <PointVersion2>
+public record Point(int X, int Y)
+{
+    public double Slope() => (double)Y / (double)X;
+}
+// </PointVersion2>
+
+public static class Expected
+{
+    public static void Example()
+    {
+        // <Version2Usage>
+        Point pt = new Point(1, 1);
+        double slope = pt.Slope();
+        Console.WriteLine($"The slope of {pt} is {slope}");
+        // </Version2Usage>
+    }
+}

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

@@ -1,10 +1,48 @@
-// See https://aka.ms/new-console-template for more information
-Console.WriteLine("Hello, World!");
-
-// 1. Use tuples. Consider a point?
-// 2. Convert tuple to a record.
-// 3. Make it a record, add some method, like distance?
-// 4. discuss struct and class. Those add more behavior.2nd project?
-  // arbitrary distance between two points.
-  // slope?
+
+using System.Xml.Linq;
+
+FirstExample();
+
+void 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>
+}
+
+// <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

@@ -17,77 +17,51 @@ The preceding tutorials worked with text and numbers. Strings and Numbers are *s
 
 *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:
 
-```csharp
-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}");
-```
+:::code language="csharp" interactive="try-dotnet-method" 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 report 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.
 
-Tuples are structural types. In other words, different 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 shape even if the members have different names:
-
-```csharp
-var subscript(A, B) = pt;
-```
-
-The variable `subscript` has two members, but of which are integers. Both `subscript` and `pt` represent instances of the same tuple type: a tuple containing 2 `int` members. You can reassign any member of a tuple:
+You can reassign any member of a tuple:
 
-```csharp
-pt.X = pt.X + 5;
-```
+:::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:
 
-```csharp
-var pt2 = pt with { Y = 10 };
-```
+:::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:
+
+:::code language="csharp" source="./snippets/TuplesAndTypes/Program.cs" id="NamedAssignment":::
+
+The variable `subscript` has two members, both of which are integers. Both `subscript` and `pt` represent instances of the same tuple type: a tuple containing 2 `int` members. 
+
 Tuples are easy to create: You declare multiple members enclosed in parentheses. All the following declare different tuples of different arites and member types:
 
-```csharp
-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);
-```
+:::code language="csharp" source="./snippets/TuplesAndTypes/Program.cs" id="TupleTypes":::
 
 Tuples are easy to create, but they are limited in their capabilities. Tuple types don't have names, so you can convey meaning to the set of values. Tuple types can't add behavior. For that, C# has other kinds of types you can create.
 
 ## 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 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:
 
-```csharp
-public record Point(int X, int Y);
-```
+:::code language="csharp" interactive="try-dotnet-program" source="./snippets/TuplesAndTypes/Program.cs" id="DeclareRecord":::
 
 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:
 
-```csharp
-Point pt = new Point {X = 1, Y = 1};
-var pt2 = pt with { Y = 10 };
-```
+:::code language="csharp" source="./snippets/TuplesAndTypes/Program.cs" id="CreateRecord":::
 
 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:
 
-```csharp
-public record Point(int X, int Y)
-{
-    public double Slope() => (double) Y / (double) X;
-}
-```
+:::code language="csharp" source="./snippets/TuplesAndTypes/Program.cs" id="PointVersion2":::
 
 You can call it like the following:
 
-```csharp
-double slope = pt.Slope();
-Console.WriteLine($"The slope of {pt} is {slope}");
-```
+:::code language="csharp" source="./snippets/TuplesAndTypes/Program.cs" id="Version2Usage":::
 
 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: