Read-through and update

I made a few editorial changes while doing a final proofread.

Author: BillWagner

docs/csharp/fundamentals/program-structure/index.md

@@ -10,7 +10,7 @@ helpviewer_keywords:
 
 You build C# programs from these core building blocks: namespaces organize your types, types (classes, structs, interfaces, enums, and delegates) define behavior and data, and statements and expressions perform work at run time. The way you structure the entry point - where your program starts running - depends on which application style you choose.
 
-The following example shows a modern C# program that uses [file-scoped namespaces](namespaces.md), [top-level statements](top-level-statements.md), and everyday C# features:
+The following example shows a modern C# program that uses [namespaces](namespaces.md), [top-level statements](top-level-statements.md), and typical C# features:
 
 :::code language="csharp" source="snippets/toplevel-structure/Program.cs":::
 
@@ -84,12 +84,12 @@ For detailed information about statements, see [Statements](../../programming-gu
 
 Learn about these program elements in the [types](../types/index.md) section of the fundamentals guide:
 
-- [Classes](../types/classes.md).
-- [Structs](../../language-reference/builtin-types/struct.md).
-- [Namespaces](namespaces.md).
-- [Interfaces](../types/interfaces.md).
-- [Enums](../../language-reference/builtin-types/enum.md).
-- [Delegates](../../delegates-overview.md).
+- [Classes](../types/classes.md)
+- [Structs](../../language-reference/builtin-types/struct.md)
+- [Namespaces](namespaces.md)
+- [Interfaces](../types/interfaces.md)
+- [Enums](../../language-reference/builtin-types/enum.md)
+- [Delegates](../../delegates-overview.md)
 
 ## C# language specification
 

docs/csharp/fundamentals/program-structure/namespaces.md

@@ -18,6 +18,8 @@ The following example shows how namespaces work together with `using` directives
 
 :::code language="csharp" source="snippets/namespaces/Basics.cs" id="NamespaceBasics":::
 
+In the preceding sample, the `using` directive means you can use the <xref:System.Globalization.CultureInfo?displayProperty=nameWithType> by the name `CultureInfo` without specifying the full name of `System.Globalization.CultureInfo`. The `namespace` directive declares that the `Greeter` class is part of the `MyApp.Services` namespace. Its fully qualified name is `MyApp.Services.Greeter`.
+
 ## Using directives
 
 Without a `using` directive, you must refer to every type by its *fully qualified name*: the complete namespace path plus the type name:
@@ -43,7 +45,7 @@ The older block-scoped syntax wraps all types in braces. This style is still val
 :::code language="csharp" source="snippets/namespaces/BlockScoped.cs" id="BlockScopedNamespace":::
 
 > [!TIP]
-> Use file-scoped namespaces in new code. Most .NET templates and code analyzers recommend this style.
+> Use file-scoped namespaces in new code when all types in the file should be declared in the same samespace. Most .NET templates and code analyzers recommend this style.
 
 ## Global using directives
 

docs/csharp/fundamentals/program-structure/preprocessor-directives.md

@@ -12,12 +12,12 @@ helpviewer_keywords:
 ---
 # Preprocessor directives
 
-C# preprocessor directives tell the compiler what code to include, exclude, or treat differently when it builds your app, which can change the resulting program's run-time behavior. They always start with `#` and must appear as a directive on their own line (ignoring leading whitespace), although you can add a trailing comment after the directive. While the [language reference](../../language-reference/preprocessor-directives.md) documents all available directives, four groups cover the vast majority of everyday use:
+C# preprocessor directives tell the compiler what code to include, exclude, or treat differently when it builds your app, which can change the resulting program. Preprocessor directives always start with `#` and must appear on their own line (ignoring leading whitespace). You can add a trailing comment after the directive. While the [language reference](../../language-reference/preprocessor-directives.md) documents all available directives, three groups cover the vast majority of everyday use:
 
 - **Conditional compilation** (`#if` / `#elif` / `#else` / `#endif`) — include or exclude code based on build configuration or target framework.
-- **Regions** (`#region` / `#endregion`) — mark collapsible sections in your editor.
 - **Nullable context** (`#nullable`) — control nullable reference type analysis at a fine-grained level.
 - **Warning suppression** (`#pragma warning`) — suppress or restore specific compiler warnings.
+- **File-based apps** (`#:`) - configure file-based apps.
 
 ## Conditional compilation
 
@@ -33,14 +33,6 @@ You can combine symbols with logical operators: `&&` (and), `||` (or), and `!` (
 
 Use `#define` at the top of a file to define your own symbols. You can also define symbols for the entire project by using the [`DefineConstants`](../../language-reference/compiler-options/language.md#defineconstants) property in your project file.
 
-## Regions
-
-Use `#region` and `#endregion` to mark collapsible sections of code in your editor. Regions don't affect compilation—they're purely an organizational tool:
-
-:::code language="csharp" source="snippets/preprocessor-directives/Regions.cs" id="RegionExample":::
-
-Use regions to group related members. For example, you might use regions to define members of an interface when a type implements multiple interfaces.
-
 ## Nullable context
 
 The `#nullable` directive controls nullable reference type analysis within a file. While you typically enable nullable analysis project-wide in your `.csproj` file by using `<Nullable>enable</Nullable>`, use the `#nullable` directive to fine-tune the setting for specific sections of code:

…program-structure/organizing-programs.md …rogram-structure/program-organization.mddocs/csharp/fundamentals/program-structure/organizing-programs.md renamed to docs/csharp/fundamentals/program-structure/program-organization.md docs/csharp/fundamentals/program-structure/organizing-programs.md renamed to docs/csharp/fundamentals/program-structure/program-organization.md

@@ -1,5 +1,5 @@
 ---
-title: "Organizing programs"
+title: "Program organization"
 description: Learn how to organize C# programs using solutions, projects, assemblies, namespaces, and types to build maintainable, well-structured applications.
 ms.date: 03/04/2026
 ai-usage: ai-assisted
@@ -9,7 +9,7 @@ helpviewer_keywords:
   - "namespaces [C#], organizing"
   - "solutions [C#]"
 ---
-# Organizing programs
+# Program organization
 
 As a C# application grows, you need a clear strategy for organizing code. .NET provides a hierarchy of organizational tools—solutions, projects, assemblies, namespaces, and types—that work together to keep large codebases manageable.
 
@@ -53,7 +53,7 @@ By convention, namespace names follow the folder structure of your project. This
 
 :::code language="csharp" source="snippets/organizing-programs/OrderService.cs" id="NamespaceMirroring":::
 
-The .NET SDK supports this convention automatically. When you set `<RootNamespace>` in your project file (or accept the default, which matches the project name), the compiler uses it as the base namespace. Types in subfolders don't automatically get sub-namespaces—you declare the namespace explicitly in each file. However, following the convention makes source easier to find.
+The .NET SDK supports this convention. When you set `<RootNamespace>` in your project file (or accept the default, which matches the project name), the compiler uses it as the base namespace. Types in subfolders don't automatically get sub-namespaces—you declare the namespace explicitly in each file. However, following the convention makes source easier to find.
 
 ## Choosing how to split namespaces
 

docs/csharp/fundamentals/program-structure/top-level-statements.md

@@ -8,19 +8,17 @@ helpviewer_keywords:
 ---
 # Top-level statements - programs without `Main` methods
 
-You don't have to explicitly include a `Main` method in a console application project. Instead, you can use the *top-level statements* feature to minimize the code you have to write.
+You can use the *top-level statements* feature to minimize the code you have to write. You don't have to explicitly include a [`Main` method](./main-command-line.md) in a console application project.
 
-Top-level statements allow you to write executable code directly at the root of a file, eliminating the need for wrapping your code in a class or method.
-This means you can create programs without the ceremony of a `Program` class and a `Main` method.
-In this case, the compiler generates a `Program` class with an entry point method for the application. The name of the generated method isn't `Main`, it's an implementation detail that your code can't reference directly.
+Top-level statements allow you to write executable code directly at the root of a file, eliminating the need for wrapping your code in a class or method. This means you can create programs without the ceremony of a `Program` class and a `Main` method. In this case, the compiler generates a `Program` class with an entry point method for the application. The name of the generated method isn't `Main`, it's an implementation detail that your code can't reference directly.
 
 Here's a *Program.cs* file that is a complete C# program:
 
 ```csharp
 Console.WriteLine("Hello World!");
 ```
 
-Top-level statements let you write simple programs for small utilities such as Azure Functions and GitHub Actions. They also make it simpler for new C# programmers to get started learning and writing code.
+Top-level statements let you write simple programs for small utilities such as Azure Functions and GitHub Actions. They provide a natural evolution as file-based apps grow to include more files.
 
 The following sections explain the rules on what you can and can't do with top-level statements.
 

docs/csharp/toc.yml

@@ -41,12 +41,12 @@ items:
       href: fundamentals/program-structure/namespaces.md
     - name: Preprocessor directives
       href: fundamentals/program-structure/preprocessor-directives.md
-    - name: Organizing programs
-      href: fundamentals/program-structure/organizing-programs.md
-    - name: Main method
-      href: fundamentals/program-structure/main-command-line.md
+    - name: Program organization
+      href: fundamentals/program-structure/program-organization.md
     - name: Top-level statements
       href: fundamentals/program-structure/top-level-statements.md
+    - name: Main method
+      href: fundamentals/program-structure/main-command-line.md
   - name: Type system
     items:
     - name: Overview