Create "common-tasks"

Create the common tasks section for what had been "How to" articles.

Author: BillWagner

.openpublishing.redirection.csharp.json

@@ -648,6 +648,10 @@
       "source_path_from_root": "/docs/csharp/features.md",
       "redirect_url": "/dotnet/csharp/programming-guide/concepts"
     },
+    {
+      "source_path_from_root": "/docs/csharp/fundamentals/null-safety/resolve-warnings.md",
+      "redirect_url": "/dotnet/csharp/fundamentals/null-safety/common-tasks/resolve-warnings"
+    },
     {
       "source_path_from_root": "/docs/csharp/generics.md",
       "redirect_url": "/dotnet/csharp/fundamentals/types/generics"

docs/csharp/advanced-topics/update-applications/nullable-migration-strategies.md

@@ -9,7 +9,7 @@ ai-usage: ai-assisted
 # Nullable migration strategies
 
 > [!TIP]
-> **Starting a new project?** New projects created from .NET 6 or later templates already have `<Nullable>enable</Nullable>` set. You don't need a migration strategy: skip to [Resolve nullable warnings](../../fundamentals/null-safety/resolve-warnings.md).
+> **Starting a new project?** New projects created from .NET 6 or later templates already have `<Nullable>enable</Nullable>` set. You don't need a migration strategy: skip to [Resolve nullable warnings](../../fundamentals/null-safety/common-tasks/resolve-warnings.md).
 >
 > **Maintaining an existing codebase?** Read [Nullable reference types](../../fundamentals/null-safety/nullable-reference-types.md) first to understand contexts, annotations, and null-state. This article assumes you're familiar with those concepts and ready to plan a rollout.
 
@@ -49,7 +49,7 @@ The most predictable way to migrate a large project is to enable warnings or ann
 
 1. Pick a file. Start with the deepest leaf types in your dependency graph, then move outward. Annotating a type causes new warnings in its callers, so working bottom-up minimizes rework.
 1. Add the `#nullable` directive that opts the file into the new behavior. Use `#nullable enable` if you want both flags. Use `#nullable enable warnings` for warning-only.
-1. Address the warnings in the file using the techniques in [Resolve nullable warnings](../../fundamentals/null-safety/resolve-warnings.md).
+1. Address the warnings in the file using the techniques in [Resolve nullable warnings](../../fundamentals/null-safety/common-tasks/resolve-warnings.md).
 1. Repeat for the next file.
 1. When every file in the project has its directive, remove the directives and set `<Nullable>enable</Nullable>` at the project level.
 
@@ -71,7 +71,7 @@ Lead with warnings when fixing latent <xref:System.NullReferenceException?displa
 Lead with annotations when stabilizing the public API surface is the priority. This sequence suits libraries: you can ship annotated signatures so consumers see the right contracts, then close out the internal warnings on your own schedule.
 
 1. **Phase 1: Add annotations.** Set the project default to `annotations`. Reference types become non-nullable by default, but the compiler doesn't emit warnings, so the noise stays out of your way. Walk the public API and add `?` to every member that may legitimately return or accept `null`. Tighten the signatures that shouldn't. Because warnings are off, you can settle the API shape in focused commits without untangling the implementation at the same time.
-1. **Phase 2: Address warnings.** Switch the project default to `enable`. The annotations you added in phase 1 now feed null-state analysis, so the warnings the compiler emits are higher quality from the start: each one points at code whose behavior doesn't match the contract you already published. Resolve them with the techniques in [Resolve nullable warnings](../../fundamentals/null-safety/resolve-warnings.md).
+1. **Phase 2: Address warnings.** Switch the project default to `enable`. The annotations you added in phase 1 now feed null-state analysis, so the warnings the compiler emits are higher quality from the start: each one points at code whose behavior doesn't match the contract you already published. Resolve them with the techniques in [Resolve nullable warnings](../../fundamentals/null-safety/common-tasks/resolve-warnings.md).
 
 ### Choosing between the orderings
 
@@ -96,11 +96,11 @@ After every file participates in the project default and the `<Nullable>enable</
 - Remove `null!` and `default!` initializers that you added only to silence warnings during migration. Replace them with proper initialization, or make type a nullable reference type.
 - Spot-check the public API. Every member that returns or accepts `null` should be annotated with `?`. The annotations are part of your contract once the package ships.
 
-You're now in the same state as new projects: nullable reference types are part of the type system, and any new warnings reflect a real mismatch between declarations and code. Use [Resolve nullable warnings](../../fundamentals/null-safety/resolve-warnings.md) to address them as they come up.
+You're now in the same state as new projects: nullable reference types are part of the type system, and any new warnings reflect a real mismatch between declarations and code. Use [Resolve nullable warnings](../../fundamentals/null-safety/common-tasks/resolve-warnings.md) to address them as they come up.
 
 ## Related content
 
 - [Nullable reference types](../../fundamentals/null-safety/nullable-reference-types.md)
-- [Resolve nullable warnings](../../fundamentals/null-safety/resolve-warnings.md)
+- [Resolve nullable warnings](../../fundamentals/null-safety/common-tasks/resolve-warnings.md)
 - [Nullable static analysis attributes](../../language-reference/attributes/nullable-analysis.md)
 - [Working with nullable reference types in EF Core](/ef/core/miscellaneous/nullable-reference-types)

…amentals/null-safety/resolve-warnings.md …-safety/common-tasks/resolve-warnings.mddocs/csharp/fundamentals/null-safety/resolve-warnings.md renamed to docs/csharp/fundamentals/null-safety/common-tasks/resolve-warnings.md docs/csharp/fundamentals/null-safety/resolve-warnings.md renamed to docs/csharp/fundamentals/null-safety/common-tasks/resolve-warnings.md

@@ -9,9 +9,9 @@ ai-usage: ai-assisted
 # Resolve nullable warnings
 
 > [!TIP]
-> **New to nullable reference types?** Read [Nullable reference types](nullable-reference-types.md) first to understand annotations and null-state analysis. This article assumes you're seeing warnings in a project where the feature is enabled.
+> **New to nullable reference types?** Read [Nullable reference types](../nullable-reference-types.md) first to understand annotations and null-state analysis. This article assumes you're seeing warnings in a project where the feature is enabled.
 >
-> **Looking for a specific compiler error code?** The [Resolve nullable warnings](../../language-reference/compiler-messages/nullable-warnings.md) reference article catalogs every CS86xx warning with the matching technique.
+> **Looking for a specific compiler error code?** The [Resolve nullable warnings](../../../language-reference/compiler-messages/nullable-warnings.md) reference article catalogs every CS86xx warning with the matching technique.
 
 When you enable nullable reference types, the compiler issues warnings everywhere your code's behavior doesn't match its annotations. Most warnings fall into a small set of patterns. Once you recognize the pattern, the fix is usually one of five techniques:
 
@@ -42,13 +42,13 @@ The fix is usually a *guard clause*. A *guard clause* is a check at the top of a
 
 :::code language="csharp" source="snippets/resolve-warnings/Program.cs" id="DereferenceFixed":::
 
-[Pattern matching](../../language-reference/operators/patterns.md) (expressions such as `is null` or `is { }` that test the shape of a value), `??`, and `??=` include null checks:
+[Pattern matching](../../../language-reference/operators/patterns.md) (expressions such as `is null` or `is { }` that test the shape of a value), `??`, and `??=` include null checks:
 
 :::code language="csharp" source="snippets/resolve-warnings/Program.cs" id="NullOperatorsFix":::
 
 The property pattern `{ Length: > 0 }` matches only when `message` is non-null *and* its `Length` property is greater than zero, so the compiler treats `message` as *not-null* inside the `if` block. A simpler `is not null` test produces the same null-state narrowing without inspecting any properties.
 
-For an in-depth tour of the operators, see [Null operators](null-operators.md).
+For an in-depth tour of the operators, see [Null operators](../null-operators.md).
 
 ## Adjust annotations
 
@@ -73,7 +73,7 @@ Sometimes the right fix isn't at the call site. A method's signature doesn't cap
 
 :::code language="csharp" source="snippets/resolve-warnings/Program.cs" id="MissingAttribute":::
 
-The body of `IsPresent` proves the argument isn't null when the method returns `true`, but the signature doesn't say so. Add a [nullable analysis attribute](../../language-reference/attributes/nullable-analysis.md) to make the contract part of the API:
+The body of `IsPresent` proves the argument isn't null when the method returns `true`, but the signature doesn't say so. Add a [nullable analysis attribute](../../../language-reference/attributes/nullable-analysis.md) to make the contract part of the API:
 
 :::code language="csharp" source="snippets/resolve-warnings/Program.cs" id="WithAttribute":::
 
@@ -84,21 +84,21 @@ Common attributes include:
 - <xref:System.Diagnostics.CodeAnalysis.MemberNotNullAttribute> — the listed members are *not-null* after the method returns.
 - <xref:System.Diagnostics.CodeAnalysis.DoesNotReturnAttribute> — the method never returns normally (for example, it always throws).
 
-The full list is in [Nullable static analysis attributes](../../language-reference/attributes/nullable-analysis.md).
+The full list is in [Nullable static analysis attributes](../../../language-reference/attributes/nullable-analysis.md).
 
 ## Initialize non-nullable members
 
-A constructor warning means a non-nullable field, property, or [auto-property](../../programming-guide/classes-and-structs/auto-implemented-properties.md) (a property that uses the compiler-generated backing field, such as `public string Name { get; set; }`) exits the constructor without being assigned a non-null value:
+A constructor warning means a non-nullable field, property, or [auto-property](../../../programming-guide/classes-and-structs/auto-implemented-properties.md) (a property that uses the compiler-generated backing field, such as `public string Name { get; set; }`) exits the constructor without being assigned a non-null value:
 
 :::code language="csharp" source="snippets/resolve-warnings/Program.cs" id="UninitializedMember":::
 
 You have several ways to address it. Pick the one that best matches your design intent.
 
-**Require the value as a constructor argument.** Use a [primary constructor](../../whats-new/tutorials/primary-constructors.md) (parameters declared on the type itself, available throughout the body) or a regular constructor that initializes the property:
+**Require the value as a constructor argument.** Use a [primary constructor](../../../whats-new/tutorials/primary-constructors.md) (parameters declared on the type itself, available throughout the body) or a regular constructor that initializes the property:
 
 :::code language="csharp" source="snippets/resolve-warnings/Program.cs" id="ConstructorInjected":::
 
-**Make the property `required`.** The caller must initialize it through an [object initializer](../../programming-guide/classes-and-structs/object-and-collection-initializers.md) (the `{ Property = value }` syntax that follows `new`):
+**Make the property `required`.** The caller must initialize it through an [object initializer](../../../programming-guide/classes-and-structs/object-and-collection-initializers.md) (the `{ Property = value }` syntax that follows `new`):
 
 :::code language="csharp" source="snippets/resolve-warnings/Program.cs" id="RequiredMember":::
 
@@ -123,18 +123,18 @@ New C# projects enable nullable reference types by default, so most code you wri
 
 The common supported values are `enable` (the default for new projects) and `disable`. If the element is missing, the project uses whatever default the SDK and target framework set.
 
-If you need to enable nullable for only part of a file with `#nullable` directives, or use the partial `warnings` and `annotations` modes when migrating an existing codebase, see [Nullable migration strategies](../../advanced-topics/update-applications/nullable-migration-strategies.md).
+If you need to enable nullable for only part of a file with `#nullable` directives, or use the partial `warnings` and `annotations` modes when migrating an existing codebase, see [Nullable migration strategies](../../../advanced-topics/update-applications/nullable-migration-strategies.md).
 
 ## Where to go next
 
-When a warning doesn't fit any of these patterns, the [Resolve nullable warnings](../../language-reference/compiler-messages/nullable-warnings.md) reference article lists the technique for every CS86xx warning the compiler emits.
+When a warning doesn't fit any of these patterns, the [Resolve nullable warnings](../../../language-reference/compiler-messages/nullable-warnings.md) reference article lists the technique for every CS86xx warning the compiler emits.
 
-To plan a migration that progressively enables nullable reference types in an existing codebase, see [Nullable migration strategies](../../advanced-topics/update-applications/nullable-migration-strategies.md).
+To plan a migration that progressively enables nullable reference types in an existing codebase, see [Nullable migration strategies](../../../advanced-topics/update-applications/nullable-migration-strategies.md).
 
 ## Related content
 
-- [Nullable reference types](nullable-reference-types.md)
-- [Null operators](null-operators.md)
-- [Nullable migration strategies](../../advanced-topics/update-applications/nullable-migration-strategies.md)
-- [Nullable static analysis attributes](../../language-reference/attributes/nullable-analysis.md)
-- [Resolve nullable warnings (compiler reference)](../../language-reference/compiler-messages/nullable-warnings.md)
+- [Nullable reference types](../nullable-reference-types.md)
+- [Null operators](../null-operators.md)
+- [Nullable migration strategies](../../../advanced-topics/update-applications/nullable-migration-strategies.md)
+- [Nullable static analysis attributes](../../../language-reference/attributes/nullable-analysis.md)
+- [Resolve nullable warnings (compiler reference)](../../../language-reference/compiler-messages/nullable-warnings.md)

…ety/snippets/resolve-warnings/Program.cs …sks/snippets/resolve-warnings/Program.csdocs/csharp/fundamentals/null-safety/snippets/resolve-warnings/Program.cs renamed to docs/csharp/fundamentals/null-safety/common-tasks/snippets/resolve-warnings/Program.cs docs/csharp/fundamentals/null-safety/snippets/resolve-warnings/Program.cs renamed to docs/csharp/fundamentals/null-safety/common-tasks/snippets/resolve-warnings/Program.cs

@@ -110,7 +110,7 @@ Initialize array elements as part of creating the array. [Collection expressions
 ## Related content
 
 - [Tutorial: Express your design intent with nullable and non-nullable reference types](../tutorials/nullable-reference-types.md)
-- [Resolve nullable warnings](resolve-warnings.md)
+- [Resolve nullable warnings](./common-tasks/resolve-warnings.md)
 - [Nullable migration strategies](../../advanced-topics/update-applications/nullable-migration-strategies.md)
 - [Nullable static analysis attributes](../../language-reference/attributes/nullable-analysis.md)
 - [Resolve nullable warnings (compiler reference)](../../language-reference/compiler-messages/nullable-warnings.md)

…ets/resolve-warnings/project-snippet.xml …ets/resolve-warnings/project-snippet.xmldocs/csharp/fundamentals/null-safety/snippets/resolve-warnings/project-snippet.xml renamed to docs/csharp/fundamentals/null-safety/common-tasks/snippets/resolve-warnings/project-snippet.xml docs/csharp/fundamentals/null-safety/snippets/resolve-warnings/project-snippet.xml renamed to docs/csharp/fundamentals/null-safety/common-tasks/snippets/resolve-warnings/project-snippet.xml

@@ -9,7 +9,7 @@ ai-usage: ai-assisted
 # Search strings in C\#
 
 > [!TIP]
-> This article is part of the **Fundamentals** section for developers who already know at least one programming language and are learning C#. If you're new to programming, start with the [Get started](../../tour-of-csharp/tutorials/index.md) tutorials first.
+> This article is part of the **Fundamentals** section for developers who already know at least one programming language and are learning C#. If you're new to programming, start with the [Get started](../../../tour-of-csharp/tutorials/index.md) tutorials first.
 >
 > **Coming from another language?** C# `string` methods such as `Contains`, `StartsWith`, and `IndexOf` parallel methods in Java's `String` and JavaScript's `String.prototype`. The key difference is that some C# searches default to **ordinal, case-sensitive** comparison. Others default to the current culture's semantics. For user-facing searches, you might want to pass a <xref:System.StringComparison> value.
 
@@ -18,7 +18,7 @@ The <xref:System.String> class includes methods that answer two everyday questio
 - *Does this string contain that text?* — use <xref:System.String.Contains*>, <xref:System.String.StartsWith*>, or <xref:System.String.EndsWith*>.
 - *Where does that text occur?* — use <xref:System.String.IndexOf*> or <xref:System.String.LastIndexOf*>.
 
-For regular expressions, span-based search over `ReadOnlySpan<char>`, and performance considerations, see [String operations](../../language-reference/builtin-types/string-operations.md). For an in-depth treatment of culture-aware comparison, see [Best practices for comparing strings](../../../standard/base-types/best-practices-strings.md).
+For regular expressions, span-based search over `ReadOnlySpan<char>`, and performance considerations, see [String operations](../../../language-reference/builtin-types/string-operations.md). For an in-depth treatment of culture-aware comparison, see [Best practices for comparing strings](../../../../standard/base-types/best-practices-strings.md).
 
 ## Check whether a string contains text
 
@@ -54,8 +54,8 @@ Ordinal comparison is the fastest option and the right default for anything that
 
 ## See also
 
-- [String operations: pattern matching, performance, and span-based search](../../language-reference/builtin-types/string-operations.md)
-- [Best practices for comparing strings in .NET](../../../standard/base-types/best-practices-strings.md)
-- [Comparing strings](../../../standard/base-types/comparing.md)
+- [String operations: pattern matching, performance, and span-based search](../../../language-reference/builtin-types/string-operations.md)
+- [Best practices for comparing strings in .NET](../../../../standard/base-types/best-practices-strings.md)
+- [Comparing strings](../../../../standard/base-types/comparing.md)
 - <xref:System.String?displayProperty=nameWithType>
 - <xref:System.StringComparison?displayProperty=nameWithType>