Fix incorrect C# compiler option names and broken links in documentation

docs/csharp/fundamentals/program-structure/main-command-line.md

@@ -16,7 +16,7 @@ helpviewer_keywords:
 
 The `Main` method is the entry point of a C# application. When the application is started, the `Main` method is the first method that is invoked.
 
-There can only be one entry point in a C# program. If you have more than one class that has a `Main` method, you must compile your program with the **StartupObject** compiler option to specify which `Main` method to use as the entry point. For more information, see [**StartupObject** (C# Compiler Options)](../../language-reference/compiler-options/advanced.md#mainentrypoint-or-startupobject). The following example displays the number of command line arguments as its first action:
+There can only be one entry point in a C# program. If you have more than one class that has a `Main` method, you must compile your program with the **StartupObject** compiler option to specify which `Main` method to use as the entry point. For more information, see [**StartupObject** (C# Compiler Options)](../../language-reference/compiler-options/advanced.md#startupobject). The following example displays the number of command line arguments as its first action:
 
 :::code language="csharp" source="snippets/main-command-line/TestClass.cs":::
 

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

@@ -38,7 +38,7 @@ You can write a `Main` method explicitly, but it can't function as an entry poin
 
 > CS7022 The entry point of the program is global code; ignoring 'Main()' entry point.
 
-In a project with top-level statements, you can't use the [-main](../../language-reference/compiler-options/advanced.md#mainentrypoint-or-startupobject) compiler option to select the entry point, even if the project has one or more `Main` methods.
+In a project with top-level statements, you can't use the [-main](../../language-reference/compiler-options/advanced.md#startupobject) compiler option to select the entry point, even if the project has one or more `Main` methods.
 
 ## `using` directives
 

docs/csharp/language-reference/compiler-options/advanced.md

@@ -9,7 +9,7 @@ helpviewer_keywords:
   - "ChecksumAlgorithm compiler option [C#]"
   - "CodePage compiler option [C#]"
   - "Utf8Output compiler option [C#]"
-  - "MainEntryPoint compiler option [C#]"
+  - "StartupObject compiler option [C#]"
   - "GenerateFullPaths compiler option [C#]"
   - "FileAlignment compiler option [C#]"
   - "PathMap compiler option [C#]"
@@ -27,7 +27,7 @@ helpviewer_keywords:
 
 The following options support advanced scenarios. The new MSBuild syntax is shown in **Bold**. The older `csc.exe` syntax is shown in `code style`.
 
-- **MainEntryPoint**, **StartupObject** / `-main`: Specify the type that contains the entry point.
+- **StartupObject** / `-main`: Specify the type that contains the entry point.
 - **PdbFile** / `-pdb`: Specify debug information file name.
 - **PathMap** / `-pathmap`: Specify a mapping for source path names output by the compiler.
 - **ApplicationConfiguration** / `-appconfig`: Specify an application configuration file containing assembly binding settings.
@@ -54,21 +54,15 @@ You add any of these options in a `<PropertyGroup>` element in your `*.csproj` f
 </PropertyGroup>
 ``````
 
-## MainEntryPoint or StartupObject
+## StartupObject
 
 This option specifies the class that contains the entry point to the program, if more than one class contains a `Main` method.
 
 ```xml
 <StartupObject>MyNamespace.Program</StartupObject>
 ```
 
-or
-
-```xml
-<MainEntryPoint>MyNamespace.Program</MainEntryPoint>
-```
-
-Where `Program` is the type that contains the `Main` method. The provided class name must be fully qualified; it must include the full namespace containing the class, followed by the class name. For example, when the `Main` method is located inside the `Program` class in the `MyApplication.Core` namespace, the compiler option has to be `-main:MyApplication.Core.Program`. If your compilation includes more than one type with a [`Main`](../../fundamentals/program-structure/main-command-line.md) method, you can specify which type contains the `Main` method.
+Where `Program` is the type that contains the `Main` method. The class name can be either fully qualified (including the namespace) or just the class name if it's unambiguous. For example, when the `Main` method is located inside the `Program` class in the `MyApplication.Core` namespace, you can specify either `-main:MyApplication.Core.Program` or just `-main:Program` if there's no ambiguity. If your compilation includes more than one type with a [`Main`](../../fundamentals/program-structure/main-command-line.md) method, you can specify which type contains the `Main` method.
 
 > [!NOTE]
 > This option can't be used for a project that includes [top-level statements](../../fundamentals/program-structure/top-level-statements.md), even if that project contains one or more `Main` methods.
@@ -245,7 +239,7 @@ Use this option if you want to define or create your own System namespace and ob
 Specifies the minimum version of the subsystem on which the executable file runs. Most commonly, this option ensures that the executable file can use security features that aren’t available with older versions of Windows.
 
 > [!NOTE]
-> To specify the subsystem itself, use the [**TargetType**](./output.md#targettype) compiler option.
+> To specify the subsystem itself, use the [**OutputType**](./output.md#outputtype) compiler option.
 
 ```xml
 <SubsystemVersion>major.minor</SubsystemVersion>
@@ -266,9 +260,9 @@ The following table lists common subsystem versions of Windows.
 The default value of the **SubsystemVersion** compiler option depends on the conditions in the following list:
 
 - The default value is 6.02 if any compiler option in the following list is set:
-  - [-target:appcontainerexe](output.md)
-  - [-target:winmdobj](output.md)
-  - [-platform:arm](output.md)
+  - [-target:appcontainerexe](output.md#outputtype)
+  - [-target:winmdobj](output.md#outputtype)
+  - [-platform:arm](output.md#platformtarget)
 - The default value is 6.00 if you're using MSBuild, you're targeting .NET Framework 4.5, and you haven't set any of the compiler options that were specified earlier in this list.
 - The default value is 4.00 if none of the previous conditions are true.
 
@@ -286,7 +280,7 @@ Specifies the name of an assembly whose nonpublic types a *.netmodule* can acces
 - You know the name of the assembly into which the .netmodule will be built.
 - The existing assembly has granted friend assembly access to the assembly into which the .*netmodule* will be built.
 
-For more information on building a .netmodule, see [**TargetType**](output.md#targettype) option of **module**. For more information on friend assemblies, see [Friend Assemblies](../../../standard/assembly/friend.md).
+For more information on building a .netmodule, see [**OutputType**](output.md#outputtype) option of **module**. For more information on friend assemblies, see [Friend Assemblies](../../../standard/assembly/friend.md).
 
 ## ReportIVTs
 

docs/csharp/language-reference/compiler-options/inputs.md

@@ -40,16 +40,16 @@ In the previous example, `LS` is the valid C# identifier that represents a root
 
 ## AddModules
 
-This option adds a module that was created with the `<TargetType>module</TargetType>` switch to the current compilation:
+This option adds a module that was created with the `<OutputType>module</OutputType>` switch to the current compilation:
 
 ```xml
 <AddModule Include=file1 />
 <AddModule Include=file2 />
 ```
 
-Where `file`, `file2` are output files that contain metadata. The file can't contain an assembly manifest. To import more than one file, separate file names with either a comma or a semicolon. All modules added with **AddModules** must be in the same directory as the output file at run time. That is, you can specify a module in any directory at compile time but the module must be in the application directory at run time. If the module isn't in the application directory at run time, you'll get a <xref:System.TypeLoadException>. `file` can't contain an assembly. For example, if the output file was created with [**TargetType**](output.md#targettype) option of **module**, its metadata can be imported with **AddModules**.
+Where `file`, `file2` are output files that contain metadata. The file can't contain an assembly manifest. To import more than one file, separate file names with either a comma or a semicolon. All modules added with **AddModules** must be in the same directory as the output file at run time. That is, you can specify a module in any directory at compile time but the module must be in the application directory at run time. If the module isn't in the application directory at run time, you'll get a <xref:System.TypeLoadException>. `file` can't contain an assembly. For example, if the output file was created with [**OutputType**](output.md#outputtype) option of **module**, its metadata can be imported with **AddModules**.
 
-If the output file was created with a [**TargetType**](output.md#targettype) option other than **module**, its metadata cannot be imported with **AddModules** but can be imported with the [**References**](#references) option.
+If the output file was created with a [**OutputType**](output.md#outputtype) option other than **module**, its metadata cannot be imported with **AddModules** but can be imported with the [**References**](#references) option.
 
 ## EmbedInteropTypes
 

docs/csharp/language-reference/compiler-options/output.md

@@ -9,7 +9,7 @@ helpviewer_keywords:
   - "OutputAssembly compiler option [C#]"
   - "PlatformTarget compiler option [C#]"
   - "ProduceReferenceAssembly compiler option [C#]"
-  - "TargetType compiler option [C#]"
+  - "OutputType compiler option [C#]"
 ---
 # C# Compiler Options that control compiler output
 
@@ -21,7 +21,7 @@ The following options control compiler output generation.
 | **OutputAssembly** | `-out:` | Specify the output assembly file. |
 | **PlatformTarget** | `-platform:` | Specify the target platform CPU. |
 | **ProduceReferenceAssembly** | `-refout:` | Generate a reference assembly. |
-| **TargetType** | `-target:` | Specify the type of the output assembly. |
+| **OutputType** | `-target:` | Specify the type of the output assembly. |
 
 > [!NOTE]
 > Refer to [Compiler options](index.md#how-to-set-options) for more information on configuring these options for your project.
@@ -34,7 +34,7 @@ The **DocumentationFile** option allows you to place documentation comments in a
 <DocumentationFile>path/to/file.xml</DocumentationFile>
 ```
 
-The source code file that contains Main or top-level statements is output first into the XML. You'll often want to use the generated .xml file with [IntelliSense](/visualstudio/ide/using-intellisense). The *.xml* filename must be the same as the assembly name. The *.xml* file must be in the same directory as the assembly. When the assembly is referenced in a Visual Studio project, the *.xml* file is found as well. For more information about generating code comments, see [Supplying Code Comments](/visualstudio/ide/reference/generate-xml-documentation-comments). Unless you compile with [`<TargetType:Module>`](#targettype), `file` will contain `<assembly>` and `</assembly>` tags specifying the name of the file containing the assembly manifest for the output file. For examples, see [How to use the XML documentation features](../xmldoc/index.md).
+The source code file that contains Main or top-level statements is output first into the XML. You'll often want to use the generated .xml file with [IntelliSense](/visualstudio/ide/using-intellisense). The *.xml* filename must be the same as the assembly name. The *.xml* file must be in the same directory as the assembly. When the assembly is referenced in a Visual Studio project, the *.xml* file is found as well. For more information about generating code comments, see [Supplying Code Comments](/visualstudio/ide/reference/generate-xml-documentation-comments). Unless you compile with [`<OutputType:module>`](#outputtype), `file` will contain `<assembly>` and `</assembly>` tags specifying the name of the file containing the assembly manifest for the output file. For examples, see [How to use the XML documentation features](../xmldoc/index.md).
 
 > [!NOTE]
 > The **DocumentationFile** option applies to all files in the project. To disable warnings related to documentation comments for a specific file or section of code, use [#pragma warning](../preprocessor-directives.md#pragma-warning).
@@ -43,13 +43,14 @@ This option can be used in any .NET SDK-style project. For more information, see
 
 ## OutputAssembly
 
-The **OutputAssembly** option specifies the name of the output file. The output path specifies the folder where compiler output is placed.
+The **OutputAssembly** option specifies the name of the output file. This option corresponds to the combination of the `OutputPath` and `AssemblyName` MSBuild properties that control where the compiled assembly is placed and what it's named.
 
 ```xml
-<OutputAssembly>folder</OutputAssembly>
+<OutputPath>bin\Debug\</OutputPath>
+<AssemblyName>MyApplication</AssemblyName>
 ```
 
-Specify the full name and extension of the file you want to create. If you don't specify the name of the output file, MSBuild uses the name of the project to specify the name of the output assembly. Old style projects use the following rules:
+Specify the name and extension of the file you want to create. The path can be relative or absolute. If you don't specify the name of the output file, MSBuild uses the project name to specify the name of the output assembly. Old style projects use the following rules:
 
 - An .exe will take its name from the source code file that contains the `Main` method or top-level statements.  
 - A .dll or .netmodule will take its name from the first source code file.
@@ -103,9 +104,9 @@ You generally don't need to work directly with reference assembly files. By defa
 
 .NET SDK 6.0.200 made a [change](../../../core/compatibility/sdk/6.0/write-reference-assemblies-to-obj.md) that moved reference assemblies from the output directory to the intermediate directory by default.
 
-## TargetType
+## OutputType
 
-The **TargetType** compiler option can be specified in one of the following forms:  
+The **OutputType** compiler option can be specified in one of the following forms:  
 
 - **library**: to create a code library. **library** is the default value.
 - **exe**: to create an .exe file.  
@@ -118,7 +119,7 @@ The **TargetType** compiler option can be specified in one of the following form
 > For .NET Framework targets, unless you specify **module**, this option causes a .NET Framework assembly manifest to be placed in an output file. For more information, see [Assemblies in .NET](../../../standard/assembly/index.md) and [Common Attributes](../attributes/global.md).
 
 ```xml
-<TargetType>library</TargetType>
+<OutputType>library</OutputType>
 ```
 
 The compiler creates only one assembly manifest per compilation. Information about all files in a compilation is placed in the assembly manifest. When producing multiple output files at the command line, only one assembly manifest can be created and it must go into the first output file specified on the command line.
@@ -131,15 +132,15 @@ The **library** option causes the compiler to create a dynamic-link library (DLL
 
 ### exe
 
-The **exe** option causes the compiler to create an executable (EXE), console application. The executable file will be created with the .exe extension. Use **winexe** to create a Windows program executable. Unless otherwise specified with the [**OutputAssembly**](#outputassembly) option, the output file name takes the name of the input file that contains the entry point ([Main](../../fundamentals/program-structure/main-command-line.md) method or top-level statements). One and only one entry point is required in the source code files that are compiled into an .exe file. The [**StartupObject**](./advanced.md#mainentrypoint-or-startupobject) compiler option lets you specify which class contains the `Main` method, in cases where your code has more than one class with a `Main` method.  
+The **exe** option causes the compiler to create an executable (EXE), console application. The executable file will be created with the .exe extension. Use **winexe** to create a Windows program executable. Unless otherwise specified with the [**OutputAssembly**](#outputassembly) option, the output file name takes the name of the input file that contains the entry point ([Main](../../fundamentals/program-structure/main-command-line.md) method or top-level statements). One and only one entry point is required in the source code files that are compiled into an .exe file. The [**StartupObject**](./advanced.md#startupobject) compiler option lets you specify which class contains the `Main` method, in cases where your code has more than one class with a `Main` method.  
 
 ### module
 
 This option causes the compiler to not generate an assembly manifest. By default, the output file created by compiling with this option will have an extension of *.netmodule*. A file that doesn't have an assembly manifest cannot be loaded by the .NET runtime. However, such a file can be incorporated into the assembly manifest of an assembly with [**AddModules**](inputs.md#addmodules). If more than one module is created in a single compilation, [internal](../keywords/internal.md) types in one module will be available to other modules in the compilation. When code in one module references `internal` types in another module, then both modules must be incorporated into an assembly manifest, with [**AddModules**](inputs.md#addmodules). Creating a module isn't supported in the Visual Studio development environment.
 
 ### winexe
 
-The **winexe** option causes the compiler to create an executable (EXE), Windows program. The executable file will be created with the .exe extension. A Windows program is one that provides a user interface from either the .NET library or with the Windows APIs. Use **exe** to create a console application. Unless otherwise specified with the [**OutputAssembly**](#outputassembly) option, the output file name takes the name of the input file that contains the [`Main`](../../fundamentals/program-structure/main-command-line.md) method. One and only one `Main` method is required in the source code files that are compiled into an .exe file. The [**StartupObject**](./advanced.md#mainentrypoint-or-startupobject) option lets you specify which class contains the `Main` method, in cases where your code has more than one class with a `Main` method.
+The **winexe** option causes the compiler to create an executable (EXE), Windows program. The executable file will be created with the .exe extension. A Windows program is one that provides a user interface from either the .NET library or with the Windows APIs. Use **exe** to create a console application. Unless otherwise specified with the [**OutputAssembly**](#outputassembly) option, the output file name takes the name of the input file that contains the [`Main`](../../fundamentals/program-structure/main-command-line.md) method. One and only one `Main` method is required in the source code files that are compiled into an .exe file. The [**StartupObject**](./advanced.md#startupobject) option lets you specify which class contains the `Main` method, in cases where your code has more than one class with a `Main` method.
 
 ### winmdobj