Proofread and make updates

Author: BillWagner

docs/csharp/fundamentals/tutorials/records.md

@@ -1,7 +1,7 @@
 ---
 title: Use record types tutorial
 description: Build a small app that models temperature data with records, compares record behavior, and uses with expressions for nondestructive mutation.
-ms.date: 04/10/2026
+ms.date: 04/14/2026
 ms.topic: tutorial
 ai-usage: ai-assisted
 ---
@@ -30,9 +30,9 @@ In this tutorial, you learn how to:
 
 Create a folder for your app, run `dotnet new console`, and open the generated project.
 
-Add a file named *InterimSteps.cs*, and add a positional `readonly record struct` for temperature values:
+Add a file named *DailyTemperature.cs*, and add a positional `readonly record struct` for temperature values:
 
-:::code language="csharp" source="./snippets/records/InterimSteps.cs" ID="DailyRecord":::
+:::code language="csharp" source="./snippets/records/DailyTemperature.cs" ID="TemperatureRecord":::
 
 Add a file named *Program.cs*, and create sample temperature data:
 
@@ -42,19 +42,24 @@ This syntax gives you concise data modeling with immutable value semantics.
 
 ## Add behavior to the record struct
 
-Create a file named *DailyTemperature.cs* and add a computed `Mean` property:
+In *DailyTemperature.cs*, you already added a computed `Mean` property to your record struct:
 
-:::code language="csharp" source="./snippets/records/DailyTemperature.cs" ID="TemperatureRecord":::
+```csharp
+public double Mean => (HighTemp + LowTemp) / 2.0;
+```
 
 A record struct works well here because each value is small and self-contained.
 
 ## Build record types for degree-day calculations
 
-Add a hierarchy for heating and cooling degree-day calculations:
+> [!NOTE]
+> **Heating degree-days** and **cooling degree-days** measure how much the daily average temperature deviates from a base temperature (typically 65°F/18°C). Heating degree-days accumulate on cold days when the average is below the base, while cooling degree-days accumulate on warm days when the average is above the base. These calculations help estimate energy consumption for heating or cooling buildings, making them useful for utility companies, building managers, and climate analysis.
+
+Create a file named *DegreeDays.cs* with a hierarchy for heating and cooling degree-day calculations:
 
-:::code language="csharp" source="./snippets/records/InterimSteps.cs" ID="DegreeDaysRecords":::
+:::code language="csharp" source="./snippets/records/DegreeDays.cs" ID="DegreeDaysRecords":::
 
-Now calculate totals from your `Main` method:
+Now calculate totals from your `Main` method in *Program.cs*:
 
 :::code language="csharp" source="./snippets/records/Program.cs" ID="HeatingAndCooling":::
 

docs/csharp/fundamentals/types/conversions.md

@@ -1,7 +1,7 @@
 ---
 title: "Type conversions, casting, and boxing"
 description: Learn how to convert between C# types by using implicit and explicit conversions, safe casting patterns, boxing and unboxing, and Parse and TryParse APIs.
-ms.date: 04/10/2026
+ms.date: 04/14/2026
 ms.topic: concept-article
 ai-usage: ai-assisted
 ---
@@ -13,7 +13,14 @@ ai-usage: ai-assisted
 >
 > **Experienced in another language?** C# conversions work like most statically typed languages: widening conversions are implicit, narrowing conversions need explicit casts, and parsing text should favor `TryParse` in user-facing code.
 
-When you write C# code, you often move values from one type to another. For example, you might convert from `int` to `long`, read text and convert it to a number, or cast a base type to a derived type.
+When you write C# code, you often convert values from one type to another. For example, you might convert from `int` to `long`, read text and convert it to a number, or cast a base type to a derived type.
+
+Understanding key terms:
+
+- A *conversion* is the process of changing a value from one type to another.
+- A *cast* is the explicit syntax for conversion, written with parentheses like `(int)value`.
+- An *implicit cast* is a conversion that happens automatically when the compiler can guarantee it's safe.
+- An *explicit cast* is a conversion you write in code, indicating the conversion might lose information or fail.
 
 Choose the conversion style based on risk:
 
@@ -24,7 +31,7 @@ Choose the conversion style based on risk:
 
 ## Use implicit and explicit numeric conversions
 
-Use implicit conversions when the destination type can represent the full source range. Use explicit casts when the destination type has a smaller range or less precision.
+An *implicit conversion* always succeeds. An *explicit conversion* might fail or lose information.
 
 :::code language="csharp" source="snippets/conversions/Program.cs" ID="ImplicitAndExplicitNumeric":::
 
@@ -34,7 +41,7 @@ For full conversion tables, see [Built-in numeric conversions](../../language-re
 
 ## Convert references safely
 
-For reference types, you often start with a base type and need to access members from a derived type. Prefer pattern matching so the test and assignment happen together.
+Casts on value types typically copy the data to the destination type. Casts on reference types don't copy data; they change how you view the same object. For reference types, you often start with a base type and need to access members from a derived type. Prefer pattern matching so the test and assignment happen together.
 
 :::code language="csharp" source="snippets/conversions/Program.cs" ID="ReferenceConversions":::
 
@@ -56,7 +63,7 @@ Boxing allocates memory on the managed heap, and unboxing requires a type check.
 
 ## Parse text by using Parse and TryParse
 
-When you convert user input or file content, start with `TryParse`. It avoids exceptions for expected invalid input and makes failure handling explicit.
+When you convert user input or file content, start with `TryParse`. It avoids exceptions for expected invalid input and makes failure handling explicit. All parsing APIs create a new object or value type instance from the source string; they don't modify the source.
 
 :::code language="csharp" source="snippets/conversions/Program.cs" ID="ParseAndTryParse":::
 

docs/csharp/fundamentals/types/delegates-lambdas.md

@@ -1,7 +1,7 @@
 ---
 title: "Delegates, lambdas, and events"
 description: Learn how to use Func and Action delegates, write lambda expressions, use static lambdas and discard parameters, and understand the basic event subscription model.
-ms.date: 04/10/2026
+ms.date: 04/14/2026
 ms.topic: concept-article
 ai-usage: ai-assisted
 ---
@@ -13,17 +13,19 @@ ai-usage: ai-assisted
 >
 > **Experienced in another language?** Think of delegates as strongly typed function variables. In modern C#, you usually write them with lambda expressions and `Func` or `Action` types.
 
-Delegates let you pass behavior as data. You use delegates when code needs a callback, a rule, or a transformation that the caller supplies.
+*Delegates* let you pass behavior as data. You use delegates when code needs a callback, a rule, or a transformation that the caller supplies.
 
 In everyday C# code, you most often use:
 
 - `Func<T...>` when a delegate returns a value.
 - `Action<T...>` when a delegate returns `void`.
 - Lambda expressions to create delegate instances.
 
+A *lambda expression* is an anonymous function with a compact syntax. It lets you write a function inline without naming it, using the arrow operator `=>` to separate parameters from the body.
+
 ## Start with Func and Action
 
-`Func` and `Action` cover most delegate scenarios without creating a custom delegate type.
+<xref:System.Func`2?displayProperty=nameWithType> and <xref:System.Action`1?displayProperty=nameWithType> cover most delegate scenarios without creating a custom delegate type.
 
 :::code language="csharp" source="snippets/delegates-lambdas/Program.cs" ID="FuncAndAction":::
 
@@ -39,7 +41,7 @@ This pattern appears throughout LINQ and many .NET APIs.
 
 ## Use static lambdas when capture is unnecessary
 
-A static lambda can't capture local variables. Use it when the logic depends only on parameters.
+A static lambda uses the `static` modifier before the parameter list, for example: `static x => x * 2` or `static (x, y) => x + y`. A static lambda can't capture local variables or instance state from the enclosing scope. *Capturing* means the lambda references variables from the enclosing scope. A *closure* is the combination of the lambda and the captured variables it holds a reference to. A non-static lambda can capture those values, while a static lambda must use only its parameters and values declared inside its body.
 
 :::code language="csharp" source="snippets/delegates-lambdas/Program.cs" ID="StaticLambda":::
 
@@ -49,6 +51,8 @@ Static lambdas make intent clear and prevent accidental captures.
 
 Sometimes a delegate signature includes parameters you don't need. Use discards to signal that choice clearly.
 
+Common examples include event handlers where you don't use `sender` or `EventArgs`, callbacks where you only need some of several inputs, and LINQ overloads that provide an index you don't use.
+
 :::code language="csharp" source="snippets/delegates-lambdas/Program.cs" ID="DiscardParameters":::
 
 Discards improve readability because they show which parameters matter.
@@ -57,6 +61,8 @@ Discards improve readability because they show which parameters matter.
 
 Events expose notifications. You subscribe with a delegate, often a lambda expression.
 
+Subscribing to an event is optional because publishers can raise events even when no listeners are attached. By contrast, APIs that accept a callback usually require that callback so the API can complete its work.
+
 :::code language="csharp" source="snippets/delegates-lambdas/Program.cs" ID="MinimalEventIntro":::
 
 This model lets publishers raise notifications without knowing subscriber implementation details.