Edit for using codespaces

Author: BillWagner

docs/csharp/tour-of-csharp/tutorials/branches-and-loops.md

@@ -7,22 +7,29 @@ ms.date: 12/03/2025
 
 This tutorial teaches you how to write C# code that examines variables and changes the execution path based on those variables. You write C# code and see the results of compiling and running it. The tutorial contains a series of lessons that explore branching and looping constructs in C#. These lessons teach you the fundamentals of the C# language.
 
-TODO:  Build an app, create a file.
+To use codespaces, you need a GitHub account. If you don't already have one, you can create a free account at [GitHub.com](https://github.com).
 
-Open *branches-loops.cs* in your favorite editor, and replace the contents with the following code:
+Open a browser window to [GitHub codespaces](https://github.com/codespaces). Create a new codespace from the *.NET Template*. If you've done other tutorials in this series, you can open that codespace. Once your codespace loads, create a new file in the *tutorials* folder named *branches-loops.cs*. Open your new file. Type or copy the following code into *branches-loops.cs*:
 
 :::code language="csharp" source="./snippets/BranchesAndLoops/branches-loops.cs" id="FirstIf":::
 
-Try this code by typing `dotnet run` in your console window. You should see the message "The answer is greater than 10." printed to your console. Modify the declaration of `b` so that the sum is less than 10:
+Try this code by typing the following in the integrated terminal:
+
+```dotnetcli
+cd tutorials
+dotnet branches-loops.cs
+```
+
+You should see the message "The answer is greater than 10." printed to your console. Modify the declaration of `b` so that the sum is less than 10:
 
 ```csharp
 int b = 3;
 ```
 
-Type `dotnet run` again. Because the answer is less than 10, nothing is printed. The **condition** you're testing is false. You don't have any code to execute because you've only written one of the possible branches for an `if` statement: the true branch.
+Type `dotnet branches-loops.cs` again in the terminal window. Because the answer is less than 10, nothing is printed. The **condition** you're testing is false. You don't have any code to execute because you've only written one of the possible branches for an `if` statement: the true branch.
 
 > [!TIP]
-> As you explore C# (or any programming language), you'll make mistakes when you write code. The compiler will find and report the errors. Look closely at the error output and the code that generated the error. The compiler error can usually help you find the problem.
+> As you explore C# (or any programming language), you'll make mistakes when you write code. The compiler will find and report the errors. Look closely at the error output and the code that generated the error. You can also ask Copilot to find differences or spot any mistakes. The compiler error can usually help you find the problem.
 
 This first sample shows the power of `if` and Boolean types. A *Boolean* is a variable that can have one of two values: `true` or `false`. C# defines a special type, `bool` for Boolean variables. The `if` statement checks the value of a `bool`. When the value is `true`, the statement following the `if` executes. Otherwise, it's skipped. This process of checking conditions and executing statements based on those conditions is powerful. Let's explore more.
 

docs/csharp/tour-of-csharp/tutorials/hello-world.md

@@ -7,15 +7,22 @@ ms.date: 12/02/2025
 
 This tutorial teaches you C#. You write your first C# and see the results of compiling and running your code. It contains a series of lessons that begin with a "Hello World" program. These lessons teach you the fundamentals of the C# language.
 
-## Run your first program
+To use codespaces, you need a GitHub account. If you don't already have one, you can create a free account at [GitHub.com](https://github.com).
 
-TODO:  `dotnet new` or create a file.
+## Run your first program
 
-Type the following code in your new `cs` file:
+Open a browser window to [GitHub codespaces](https://github.com/codespaces). Create a new codespace from the *.NET Template*. Once your codespace loads, create a new file in the *tutorials* folder named *hello-world.cs*. Open your new file. Type or copy the following code into *hello-world.cs*:
 
 :::code language="csharp" source="./snippets/HelloWorld/hello-world.cs" id="HelloWorld":::
 
-TODO: To run the program, type `dotnet run` (or) `dotnet file.cs` at the command prompt. Congratulations! You ran your first C# program. It's a simple program that prints the message "Hello World!" It used the <xref:System.Console.WriteLine%2A?displayProperty=nameWithType> method to print that message. `Console` is a type that represents the console window. `WriteLine` is a method of the `Console` type that prints a line of text to that text console.
+In the integrated terminal window, make the *tutorials* folder the current folder, and run your program:
+
+```dotnetcli
+cd tutorials
+dotnet hello-world.cs
+```
+
+Congratulations! You ran your first C# program. It's a simple program that prints the message "Hello World!" It used the <xref:System.Console.WriteLine%2A?displayProperty=nameWithType> method to print that message. `Console` is a type that represents the console window. `WriteLine` is a method of the `Console` type that prints a line of text to that text console.
 
 Let's move on and explore more. The rest of this lesson explores working with the `string` type, which represents text in C#. Like the `Console` type, the `string` type has methods. The `string` methods work with text.
 
@@ -25,7 +32,7 @@ Your first program printed the `string` "Hello World!" on the screen.
 
 > [!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 your `.cs` file 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 report them to you. When the output contains error messages, look closely at the example code, and the code in your `.cs` file 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 mistakes.
 
 Your first program is limited to printing one message. You can write more useful programs by using *variables*. A *variable* is a symbol you can use to run the same code with different values. Let's try it! Start with the following code:
 
@@ -46,7 +53,7 @@ You might notice that the word "Hello" was missing in the last two messages. Let
 
 :::code language="csharp" source="./snippets/HelloWorld/hello-world.cs" id="ConcatMessage":::
 
-TODO: Run the app again using `dotnet run` (or) `dotnet file.cs` to see the results.
+Run the app again using `dotnet hello-world.cs` to see the results.
 
 You've been using `+` to build strings from **variables** and **constant** strings. There's a better way. You can place a variable between `{` and `}` characters to tell C# to replace that text with the value of the variable.
 
@@ -56,7 +63,7 @@ If you add a `$` before the opening quote of the string, you can then include va
 
 :::code language="csharp" source="./snippets/HelloWorld/hello-world.cs" id="Interpolation":::
 
-TODO: Run the app again using `dotnet run` (or) `dotnet file.cs` to see the results. Instead of "Hello {aFriend}", the message should be "Hello Maira".
+Run the app again using `dotnet hello-world.cs` to see the results. Instead of "Hello {aFriend}", the message should be "Hello Maira".
 
 ## Work with strings
 
@@ -124,7 +131,7 @@ Did you come up with something like the following (expand to see the answer):
 </details>
 <!-- markdownlint-enable MD033 -->
 
-You completed the "Hello C#" introduction to C# tutorial. You can select the **Numbers in C#** tutorial to start the next 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 "Hello C#" introduction to C# tutorial. You can select the [Numbers in C#](./numbers-in-csharp.md) tutorial to start the next 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.
 
 For further reading on the `string` type:
 

docs/csharp/tour-of-csharp/tutorials/index.md

@@ -1,25 +1,22 @@
 ---
 title: Interactive tutorials
 description: Learn C# in your browser, and get started with your own development environment
-ms.date: 04/23/2025
+ms.date: 12/05/2025
 ---
 # Introduction to C\#
 
-Welcome to the introduction to C# tutorials. These lessons start with interactive code that you can run in your browser. You can learn the basics of C# from the [C# for Beginners video series](https://aka.ms/dotnet/beginnervideos/youtube/csharp) before starting these interactive lessons.
+Welcome to the introduction to C# tutorials. These lessons start with interactive code that you can run in GitHub codespaces. You can learn the basics of C# from the [C# for Beginners video series](https://aka.ms/dotnet/beginnervideos/youtube/csharp) before starting these interactive lessons.
 
 <!--markdownlint-disable-next-line MD034 -->
 > [!VIDEO https://www.youtube.com/embed/9THmGiSPjBQ?si=3kUKFtOMLpEzeq7J]
 
 The first lessons explain C# concepts using small snippets of code. You'll learn the basics of C# syntax and how to work with data types like strings, numbers, and booleans. It's all interactive, and you'll be writing and running code within minutes. These first lessons assume no prior knowledge of programming or the C# language. Each lesson builds on the prior lessons. You should do them in order. However, if you have some programming experience, you can skip or skim the first lessons and start with any new concepts.
 
-You can try these tutorials in different environments. The concepts you'll learn are the same. The difference is which experience you prefer:
-
-- [In your browser, on the docs platform](hello-world.md): This experience embeds a runnable C# code window in docs pages. You write and execute C# code in the browser.
-- [In the Microsoft Learn training experience](/training/paths/csharp-first-steps/). This learning path contains several modules that teach the basics of C#.
+To use GitHub codespaces, you need to create a free [GitHub](https://github.com) account.
 
 ## Hello world
 
-In the [Hello world](hello-world.md) tutorial, you'll create the most basic C# program. You'll explore the `string` type and how to work with text. You can also use the path on [Microsoft Learn training](/training/paths/csharp-first-steps/).
+In the [Hello world](hello-world.md) tutorial, you'll create the most basic C# program. You'll explore the `string` type and how to work with text.
 
 ## Numbers in C\#
 

docs/csharp/tour-of-csharp/tutorials/list-collection.md

@@ -5,18 +5,25 @@ ms.date: 03/07/2025
 ---
 # Learn to manage data collections using List\<T> in C\#
 
-This introductory tutorial provides an introduction to the C# language and the basics of the  class.
+This introductory tutorial provides an introduction to the C# language and the basics of the <xref:System.Collections.Generic.List`1?displayProperty=nameWithType> class.
 
 This tutorial teaches you C#. You write C# code and see the results of compiling and running that code. It contains a series of lessons that create, modify, and explore collections and arrays. You work primarily with the <xref:System.Collections.Generic.List%601> class.
 
-<< TODO Create the app>>
+To use codespaces, you need a GitHub account. If you don't already have one, you can create a free account at [GitHub.com](https://github.com).
 
 ## A basic list example
 
-Add the following code to your source file. Replace `<name>` with your name. Then, type `dotnet run` to run the code:
+Open a browser window to [GitHub codespaces](https://github.com/codespaces). Create a new codespace from the *.NET Template*. If you've done other tutorials in this series, you can open that codespace. Once your codespace loads, create a new file in the *tutorials* folder named *lists.cs*. Open your new file. Type or copy the following code into *lists.cs*:
 
 :::code language="csharp" source="./snippets/ListCollection/list.cs" id="BasicList":::
 
+Run the code by typing the following in the terminal window:
+
+```dotnetcli
+cd tutorials
+dotnet lists.cs
+```
+
 You created a list of strings, added three names to that list, and printed the names in all CAPS. You're using concepts that you learned in earlier tutorials to loop through the list.
 
 The code to display names makes use of the [string interpolation](../../language-reference/tokens/interpolated.md) feature. When you precede a `string` with the `$` character, you can embed C# code in the string declaration. The actual string replaces that C# code with the value it generates. In this example, it replaces the `{name.ToUpper()}` with each name, converted to capital letters, because you called the <xref:System.String.ToUpper%2A?displayProperty=nameWithType> method.
@@ -41,7 +48,7 @@ You're not allowed to access past the end of the list. You can check how long th
 
 :::code language="csharp" source="./snippets/ListCollection/list.cs" id="Property":::
 
-Type `dotnet run` again to see the results. In C#, indices start at 0, so the largest valid index is one less than the number of items in the list.
+Type `dotnet lists.cs` again in the terminal window to see the results. In C#, indices start at 0, so the largest valid index is one less than the number of items in the list.
 
 For more information about indices, see the [Explore indexes and ranges](../../tutorials/ranges-indexes.md) article.
 
@@ -67,7 +74,7 @@ That creates a list of integers, and sets the first two integers to the value 1.
 
 :::code language="csharp" source="./snippets/ListCollection/list.cs" id="Fibonacci":::
 
-Type `dotnet run` to see the results.
+Type `dotnet lists` in the terminal window to see the results.
 
 ## Challenge
 

docs/csharp/tour-of-csharp/tutorials/numbers-in-csharp.md

@@ -7,20 +7,20 @@ ms.date: 12/02/2025
 
 This tutorial teaches you about the numeric 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 numbers and math operations in C#. These lessons teach you the fundamentals of the C# language.
 
-## Explore integer math
-
-Create a directory named *numbers-quickstart*. Make it the current directory and run the following command:
+To use codespaces, you need a GitHub account. If you don't already have one, you can create a free account at [GitHub.com](https://github.com).
 
-```dotnetcli
-dotnet new console -n NumbersInCSharp -o .
-```
+## Explore integer math
 
-Open *numbers.cs* in your favorite editor, and replace the contents of the file with the following code:
+Open a browser window to [GitHub codespaces](https://github.com/codespaces). Create a new codespace from the *.NET Template*. If you've done the [hello world](./hello-world.md) tutorial, you can open that codespace. Once your codespace loads, create a new file in the *tutorials* folder named *numbers.cs*. Open your new file. Type or copy the following code into *numbers.cs*:
 
 :::code language="csharp" source="./snippets/NumbersInCsharp/numbers.cs" id="Addition":::
-Addition
 
-Run this code by typing `dotnet run` in your command window.
+Run this code by typing the following commands in the integrated terminal:
+
+```dotnetcli
+cd ./tutorials
+dotnet numbers.cs
+```
 
 You've seen one of the fundamental math operations with integers. The `int` type represents an **integer**, a zero, positive, or negative whole number. You use the `+` symbol for addition. Other common mathematical operations for integers include:
 
@@ -32,12 +32,12 @@ Start by exploring those different operations. Add these lines after the line th
 
 :::code language="csharp" source="./snippets/NumbersInCsharp/numbers.cs" id="OtherOperations":::
 
-Run this code by typing `dotnet run` in your command window.
+Run this code by typing `dotnet numers.cs` in the terminal window.
 
 You can also experiment by writing multiple mathematics operations in the same line, if you'd like. Try `c = a + b - 12 * 17;` for example. Mixing variables and constant numbers is allowed.
 
 > [!TIP]
-> As you explore C# (or any programming language), you'll make mistakes when you write code. The **compiler** will find those errors and report them to you. When the output contains error messages, look closely at the example code and the code in your window to see what to fix. That exercise will help you learn the structure of C# code.
+> As you explore C# (or any programming language), you'll make mistakes when you write code. The **compiler** will find those errors and report them to you. When the output contains error messages, look closely at the example code and the code in your window to see what to fix. You can also ask Copilot to find differences or spot mistakes. That exercise will help you learn the structure of C# code.
 
 You've finished the first step. Before you start the next section, let's move the current code into a separate *method*. A method is a series of statements grouped together and given a name. You call a method by writing the method's name followed by `()`. Organizing your code into methods makes it easier to start working with a new example. When you finish, your code should look like this:
 
@@ -76,7 +76,7 @@ Comment out the call to `WorkingWithIntegers()`. It will make the output less cl
 
 The `//` starts a **comment** in C#. Comments are any text you want to keep in your source code but not execute as code. The compiler doesn't generate any executable code from comments. Because `WorkWithIntegers()` is a method, you need to only comment out one line.
 
-The C# language defines the precedence of different mathematics operations with rules consistent with the rules you learned in mathematics. Multiplication and division take precedence over addition and subtraction. Explore that by adding the following code after the call to `WorkWithIntegers()`, and executing `dotnet run`:
+The C# language defines the precedence of different mathematics operations with rules consistent with the rules you learned in mathematics. Multiplication and division take precedence over addition and subtraction. Explore that by adding the following code after the call to `WorkWithIntegers()`, and typing `dotnet numbers.cs` in the terminal window:
 
 :::code language="csharp" source="./snippets/NumbersInCsharp/numbers.cs" id="Precedence":::
 
@@ -86,7 +86,7 @@ You can force a different order of operation by adding parentheses around the op
 
 :::code language="csharp" source="./snippets/NumbersInCsharp/numbers.cs" id="Parentheses":::
 
-Explore more by combining many different operations. Add something like the following lines. Try `dotnet run` again.
+Explore more by combining many different operations. Add something like the following lines. Try `dotnet numbers` again in the terminal window.
 
 :::code language="csharp" source="./snippets/NumbersInCsharp/numbers.cs" id="CompoundExpression":::
 
@@ -96,7 +96,7 @@ If you haven't seen this behavior, try the following code:
 
 :::code language="csharp" source="./snippets/NumbersInCsharp/numbers.cs" id="Truncation":::
 
-Type `dotnet run` again to see the results.
+Type `dotnet numbers` again in the terminal window to see the results.
 
 Before moving on, let's take all the code you've written in this section and put it in a new method. Call that new method `OrderPrecedence`. Your code should look something like this: