Fix the env shebang line in file-based app docs. (#52606)

`#!/usr/bin/env dotnet run` doesn't work because `env` treats "dotnet run" as a single command name.

Also change the wording that suggests this is a shell/command-line feature. The executable files are also executable by other apps.

Author: tmds

docs/core/tools/dotnet-run.md

@@ -91,14 +91,20 @@ To run the application, the `dotnet run` command resolves the dependencies of th
 
   The path to the file-based app to run. If a path isn't specified, the current directory is used to find and run the file. For more information on file-based apps, see [Build file-based C# apps](../../csharp/fundamentals/tutorials/file-based-programs.md).
 
-  On Unix, you can run file-based apps directly, using the source file name on the command line instead of `dotnet run`. First, ensure the file has execute permissions. Then, add a shebang line `#!` as the first line of the file, for example:
-  
+  On Unix, you can execute file-based apps directly using the filename. This requires a shebang line `#!` as the first line of the file and the *execute* permission to be set. For example:
+
   ```csharp
-  #!/usr/bin/env dotnet run
+  #!/usr/bin/env dotnet
   ```
-  
-  Then you can run the file directly from the command line:
-  
+
+  Set the execute bit:
+
+  ```bash
+  chmod +x ConsoleApp.cs
+  ```
+
+  Now you can run the file directly from the command line:
+
   ```bash
   ./ConsoleApp.cs
   ```

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

@@ -37,7 +37,7 @@ Starting with C# 14 and .NET 10, *file-based apps* let you run a program contain
 :::code language="csharp" source="./snippets/file-based-program/hello-world.cs":::
 
 > [!NOTE]
-> The `#!` line enables Unix shells to run the file directly. On any Unix system, set the *execute* (`+x`) permission and run the file from the command line.
+> The `#!` line enables Unix operating systems to execute the file directly (for example, `./hello-world.cs`). This requires the *execute* permission to be set (`chmod +x <file>`).
 
 File-based apps support all C# syntax and can use [preprocessor directives](../../language-reference/preprocessor-directives.md#file-based-apps) to configure the build system. Use file-based apps for small command-line utilities, prototypes, and experiments. A file-based app consists of a single file in a directory:
 

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

@@ -24,13 +24,13 @@ C# preprocessor directives tell the compiler what code to include, exclude, or t
 
 Starting with C# 14, [file-based apps](index.md) use two additional directives:
 
-- `#!` — the *shebang* line that lets Unix shells run the file directly (for example, `#!/usr/bin/env dotnet run`).
+- `#!` — the *shebang* line that enables executing the file directly on Unix (for example, `./Program.cs`). This requires the *execute* permission to be set on the file (`chmod +x <file>`).
 - `#:` — build-system directives that configure packages, SDK settings, and other options for single-file programs.
 
 Use `#:package` to add a NuGet package. For example, the following file-based app uses the `Spectre.Console` package to render styled output:
 
 ```csharp
-#!/usr/bin/env dotnet run
+#!/usr/bin/env dotnet
 #:package Spectre.Console@*
 
 AnsiConsole.MarkupLine("[bold green]Hello[/] from a file-based app!");

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

@@ -39,7 +39,7 @@ The compiler generates a method to serve as the program entry point for a projec
 | `return`                | `static int Main(string[] args)`             |
 | No `await` or `return`  | `static void Main(string[] args)`            |
 
-Starting with C# 14, programs can be [*file-based apps*](./index.md#building-and-running-c-programs), where a single file contains the program. You run *file-based apps* by using the command `dotnet <file.cs>`, or by using the `#!/usr/bin/env dotnet` directive as the first line (Unix shells only).
+Starting with C# 14, programs can be [*file-based apps*](./index.md#building-and-running-c-programs), where a single file contains the program. You run *file-based apps* by using the command `dotnet <file.cs>`, or directly using the filename on Unix (for example, `./file.cs`). The latter requires including the `#!/usr/bin/env dotnet` directive as the first line and setting the execute permission (`chmod +x <file>`).
 
 ## `using` directives
 

docs/csharp/fundamentals/tutorials/file-based-programs.md

@@ -69,7 +69,7 @@ File-based apps are regular C# programs. The only limitation is that you must wr
 >
 > Support for `#!` directives applies on Unix platforms only. There's no similar directive for Windows to directly execute a C# program. On Windows, you must use `dotnet` on the command line.
 
-On Unix, run file-based apps directly by typing just the source file name. Instead of using `dotnet AsciiArt.cs`, type the source file name on the command line. You need to make two changes:
+On Unix, you can execute file-based apps directly using just the source file name. You need to make two changes:
 
 1. Set *execute* permissions on the source file:
 
@@ -91,13 +91,13 @@ Alternatively, you can use `#!/usr/bin/env dotnet` to resolve the dotnet path fr
 #!/usr/bin/env dotnet
 ```
 
-After making these two changes, you can run the program from the command line directly:
+After making these two changes, you can run the program directly:
 
 ```bash
 ./AsciiArt.cs
 ```
 
-If you prefer, you can remove the extension so you can type `./AsciiArt` instead. You can add the `#!` to your source file even if you use Windows. The Windows command line doesn't support `#!`, but the C# compiler allows that directive in file-based apps on all platforms.
+If you prefer, you can remove the extension so you can type `./AsciiArt` instead. You can add the `#!` to your source file even if you use Windows. Windows doesn't support `#!`, but the C# compiler allows that directive in file-based apps on all platforms.
 
 ## Read command line arguments
 

docs/csharp/language-reference/preprocessor-directives.md

@@ -53,14 +53,14 @@ Although the compiler doesn't have a separate preprocessor, it processes the dir
 
 The C# compiler ignores any preprocessor directive that starts with `#:` or `#!`.
 
-The `#!` preprocessor directive enables Unix shells to directly execute a C# file by using `dotnet run`. For example:
+The `#!` preprocessor directive enables Unix operating systems to directly execute the C# file using its filename.
 
 ```csharp
-#!/usr/bin/env dotnet run
+#!/usr/bin/env dotnet
 Console.WriteLine("Hello");
 ```
 
-The preceding code snippet informs a Unix shell to execute the file by using `dotnet run`. The `/usr/bin/env` command locates the `dotnet` executable in your PATH, making this approach portable across different Unix and macOS distributions. The `#!` line must be the first line in the file, and the following tokens are the program to run. You need to enable the *execute* (`x`) permission on the C# file for that feature.
+The first line in the file informs a Unix operating system to execute the file using `dotnet`. The `/usr/bin/env` command locates the `dotnet` executable in your PATH, making this approach portable across different Unix and macOS distributions where `dotnet` may be installed at different locations. In addition to including this line in the C# file, you need to set the *execute* (`x`) permission (`chmod +x <file>`).
 
 The `#:` directives that are used in file-based apps are described in the [file based apps reference](../../core/sdk/file-based-apps.md).
 

docs/csharp/tour-of-csharp/overview.md

@@ -49,7 +49,7 @@ Beginning with C# 14 and .NET 10, you can create *file-based apps*, which simpli
 
 :::code language="csharp" source="./snippets/file-based-programs/hello-world.cs":::
 
-The first line of the program contains the `#!` sequence (shebang) for unix shells. The location of the `dotnet` CLI can vary on different distributions. On any unix system, if you set the *execute* (`+x`) permission on such a C# file that contains the shebang directive, you can run the C# file directly from the command line:
+The first line of the program contains the `#!` sequence (shebang) for unix operating systems. This enables executing the file directly using its name when the *execute* (`+x`) permission is set on the file. For example, you can run the C# file directly from the command line:
 
 ```bash
 ./hello-world.cs