From 01e462b6ba7db858e9aa378da574616070e579c7 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 5 Aug 2025 20:24:04 +0000
Subject: [PATCH 1/7] Initial plan


From b623d6bd4a1560738ee68967e38d93803c69f2ac Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 5 Aug 2025 20:54:27 +0000
Subject: [PATCH 2/7] Add BinaryLoggerOption as ForwardedOption to all MSBuild
 commands

Co-authored-by: baronfel <573979+baronfel@users.noreply.github.com>
---
 .../CommandLine/CommandLineOptions.cs         | 39 +++----------------
 .../Commands/Build/BuildCommandParser.cs      |  1 +
 .../Commands/Clean/CleanCommandParser.cs      |  1 +
 .../Commands/MSBuild/MSBuildForwardingApp.cs  |  2 +-
 .../dotnet/Commands/Pack/PackCommandParser.cs |  1 +
 .../Commands/Publish/PublishCommandParser.cs  |  1 +
 .../Commands/Restore/RestoreCommandParser.cs  |  1 +
 .../dotnet/Commands/Run/RunCommandParser.cs   |  1 +
 .../Commands/Store/StoreCommandParser.cs      |  1 +
 .../dotnet/Commands/Test/TestCommandParser.cs |  1 +
 src/Cli/dotnet/CommonOptions.cs               | 26 +++++++++++++
 11 files changed, 40 insertions(+), 35 deletions(-)

diff --git a/src/BuiltInTools/dotnet-watch/CommandLine/CommandLineOptions.cs b/src/BuiltInTools/dotnet-watch/CommandLine/CommandLineOptions.cs
index 85ecb916213e..d6168b54afa3 100644
--- a/src/BuiltInTools/dotnet-watch/CommandLine/CommandLineOptions.cs
+++ b/src/BuiltInTools/dotnet-watch/CommandLine/CommandLineOptions.cs
@@ -1,7 +1,6 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System.Collections.Immutable;
 using System.CommandLine;
 using System.CommandLine.Parsing;
 using System.Data;
@@ -17,8 +16,6 @@ internal sealed class CommandLineOptions
 {
     public const string DefaultCommand = "run";
 
-    private static readonly ImmutableArray<string> s_binaryLogOptionNames = ["-bl", "/bl", "-binaryLogger", "--binaryLogger", "/binaryLogger"];
-
     public bool List { get; init; }
     public required GlobalOptions GlobalOptions { get; init; }
 
@@ -157,17 +154,14 @@ internal sealed class CommandLineOptions
             }
         }
 
-        var commandArguments = GetCommandArguments(parseResult, watchOptions, explicitCommand, out var binLogToken, out var binLogPath);
+        var commandArguments = GetCommandArguments(parseResult, watchOptions, explicitCommand);
 
         // We assume that forwarded options, if any, are intended for dotnet build.
         var buildArguments = buildOptions.Select(option => ((IForwardedOption)option).GetForwardingFunction()(parseResult)).SelectMany(args => args).ToList();
 
-        if (binLogToken != null)
-        {
-            buildArguments.Add(binLogToken);
-        }
-
         var targetFrameworkOption = (Option<string>?)buildOptions.SingleOrDefault(option => option.Name == "--framework");
+        var binaryLoggerOption = (Option<string?>?)buildOptions.SingleOrDefault(option => option.Name == "--binaryLogger");
+        var binaryLoggerPath = binaryLoggerOption != null ? parseResult.GetValue(binaryLoggerOption) : null;
 
         return new()
         {
@@ -178,7 +172,7 @@ internal sealed class CommandLineOptions
                 NoHotReload = parseResult.GetValue(noHotReloadOption),
                 NonInteractive = parseResult.GetValue(NonInteractiveOption),
                 Verbose = parseResult.GetValue(verboseOption),
-                BinaryLogPath = ParseBinaryLogFilePath(binLogPath),
+                BinaryLogPath = ParseBinaryLogFilePath(binaryLoggerPath),
             },
 
             CommandArguments = commandArguments,
@@ -215,13 +209,9 @@ internal sealed class CommandLineOptions
     private static IReadOnlyList<string> GetCommandArguments(
         ParseResult parseResult,
         IReadOnlyList<Option> watchOptions,
-        Command? explicitCommand,
-        out string? binLogToken,
-        out string? binLogPath)
+        Command? explicitCommand)
     {
         var arguments = new List<string>();
-        binLogToken = null;
-        binLogPath = null;
 
         foreach (var child in parseResult.CommandResult.Children)
         {
@@ -276,25 +266,6 @@ private static IReadOnlyList<string> GetCommandArguments(
                     seenCommand = true;
                     continue;
                 }
-
-                // Workaround: commands do not have forwarding option for -bl
-                // https://github.com/dotnet/sdk/issues/49989
-                foreach (var name in s_binaryLogOptionNames)
-                {
-                    if (token.StartsWith(name, StringComparison.OrdinalIgnoreCase))
-                    {
-                        if (token.Length == name.Length)
-                        {
-                            binLogToken = token;
-                            binLogPath = "";
-                        }
-                        else if (token.Length > name.Length + 1 && token[name.Length] == ':')
-                        {
-                            binLogToken = token;
-                            binLogPath = token[(name.Length + 1)..];
-                        }
-                    }
-                }
             }
 
             if (!dashDashInserted && i >= unmatchedTokensBeforeDashDash)
diff --git a/src/Cli/dotnet/Commands/Build/BuildCommandParser.cs b/src/Cli/dotnet/Commands/Build/BuildCommandParser.cs
index 12bea5e09309..b05ae14be3ee 100644
--- a/src/Cli/dotnet/Commands/Build/BuildCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Build/BuildCommandParser.cs
@@ -91,6 +91,7 @@ private static Command ConstructCommand()
         command.Options.Add(CommonOptions.ArchitectureOption);
         command.Options.Add(CommonOptions.OperatingSystemOption);
         command.Options.Add(CommonOptions.DisableBuildServersOption);
+        command.Options.Add(CommonOptions.BinaryLoggerOption);
         command.Options.Add(TargetOption);
 
         command.SetAction(BuildCommand.Run);
diff --git a/src/Cli/dotnet/Commands/Clean/CleanCommandParser.cs b/src/Cli/dotnet/Commands/Clean/CleanCommandParser.cs
index aff818886fe8..11f0931937df 100644
--- a/src/Cli/dotnet/Commands/Clean/CleanCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Clean/CleanCommandParser.cs
@@ -59,6 +59,7 @@ private static Command ConstructCommand()
         command.Options.Add(CommonOptions.ArtifactsPathOption);
         command.Options.Add(NoLogoOption);
         command.Options.Add(CommonOptions.DisableBuildServersOption);
+        command.Options.Add(CommonOptions.BinaryLoggerOption);
         command.Options.Add(TargetOption);
         command.Subcommands.Add(CleanFileBasedAppArtifactsCommandParser.Command);
 
diff --git a/src/Cli/dotnet/Commands/MSBuild/MSBuildForwardingApp.cs b/src/Cli/dotnet/Commands/MSBuild/MSBuildForwardingApp.cs
index 67c2a47f1051..c8a0f944bed6 100644
--- a/src/Cli/dotnet/Commands/MSBuild/MSBuildForwardingApp.cs
+++ b/src/Cli/dotnet/Commands/MSBuild/MSBuildForwardingApp.cs
@@ -38,7 +38,7 @@ private static MSBuildArgs ConcatTelemetryLogger(MSBuildArgs msbuildArgs)
     /// Mostly intended for quick/one-shot usage - most 'core' SDK commands should do more hands-on parsing.
     /// </summary>
     public MSBuildForwardingApp(IEnumerable<string> rawMSBuildArgs, string? msbuildPath = null) : this(
-        MSBuildArgs.AnalyzeMSBuildArguments(rawMSBuildArgs.ToArray(), CommonOptions.PropertiesOption, CommonOptions.RestorePropertiesOption, CommonOptions.MSBuildTargetOption(), CommonOptions.VerbosityOption()),
+        MSBuildArgs.AnalyzeMSBuildArguments(rawMSBuildArgs.ToArray(), CommonOptions.PropertiesOption, CommonOptions.RestorePropertiesOption, CommonOptions.MSBuildTargetOption(), CommonOptions.VerbosityOption(), CommonOptions.BinaryLoggerOption),
         msbuildPath)
     {
     }
diff --git a/src/Cli/dotnet/Commands/Pack/PackCommandParser.cs b/src/Cli/dotnet/Commands/Pack/PackCommandParser.cs
index 929f274ac3a7..e4b2b8658318 100644
--- a/src/Cli/dotnet/Commands/Pack/PackCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Pack/PackCommandParser.cs
@@ -86,6 +86,7 @@ private static Command ConstructCommand()
         command.Options.Add(CommonOptions.VersionSuffixOption);
         command.Options.Add(ConfigurationOption);
         command.Options.Add(CommonOptions.DisableBuildServersOption);
+        command.Options.Add(CommonOptions.BinaryLoggerOption);
         command.Options.Add(TargetOption);
 
         // Don't include runtime option because we want to include it specifically and allow the short version ("-r") to be used
diff --git a/src/Cli/dotnet/Commands/Publish/PublishCommandParser.cs b/src/Cli/dotnet/Commands/Publish/PublishCommandParser.cs
index 8de1ebee7792..58927484e3b2 100644
--- a/src/Cli/dotnet/Commands/Publish/PublishCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Publish/PublishCommandParser.cs
@@ -89,6 +89,7 @@ private static Command ConstructCommand()
         command.Options.Add(CommonOptions.ArchitectureOption);
         command.Options.Add(CommonOptions.OperatingSystemOption);
         command.Options.Add(CommonOptions.DisableBuildServersOption);
+        command.Options.Add(CommonOptions.BinaryLoggerOption);
         command.Options.Add(TargetOption);
 
         command.SetAction(PublishCommand.Run);
diff --git a/src/Cli/dotnet/Commands/Restore/RestoreCommandParser.cs b/src/Cli/dotnet/Commands/Restore/RestoreCommandParser.cs
index e986e495e2d3..f7363ad15c30 100644
--- a/src/Cli/dotnet/Commands/Restore/RestoreCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Restore/RestoreCommandParser.cs
@@ -69,6 +69,7 @@ private static Command ConstructCommand()
 
         command.Arguments.Add(SlnOrProjectOrFileArgument);
         command.Options.Add(CommonOptions.DisableBuildServersOption);
+        command.Options.Add(CommonOptions.BinaryLoggerOption);
 
         command.Options.AddRange(FullRestoreOptions());
 
diff --git a/src/Cli/dotnet/Commands/Run/RunCommandParser.cs b/src/Cli/dotnet/Commands/Run/RunCommandParser.cs
index 2049fe08b1e1..067d83966509 100644
--- a/src/Cli/dotnet/Commands/Run/RunCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Run/RunCommandParser.cs
@@ -105,6 +105,7 @@ private static Command ConstructCommand()
         command.Options.Add(CommonOptions.ArchitectureOption);
         command.Options.Add(CommonOptions.OperatingSystemOption);
         command.Options.Add(CommonOptions.DisableBuildServersOption);
+        command.Options.Add(CommonOptions.BinaryLoggerOption);
         command.Options.Add(CommonOptions.ArtifactsPathOption);
         command.Options.Add(CommonOptions.EnvOption);
 
diff --git a/src/Cli/dotnet/Commands/Store/StoreCommandParser.cs b/src/Cli/dotnet/Commands/Store/StoreCommandParser.cs
index 5f98a6006e6a..658bd2cbdcd8 100644
--- a/src/Cli/dotnet/Commands/Store/StoreCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Store/StoreCommandParser.cs
@@ -89,6 +89,7 @@ private static Command ConstructCommand()
         command.Options.Add(CommonOptions.VerbosityOption());
         command.Options.Add(CommonOptions.CurrentRuntimeOption(CliCommandStrings.CurrentRuntimeOptionDescription));
         command.Options.Add(CommonOptions.DisableBuildServersOption);
+        command.Options.Add(CommonOptions.BinaryLoggerOption);
 
         command.SetAction(StoreCommand.Run);
 
diff --git a/src/Cli/dotnet/Commands/Test/TestCommandParser.cs b/src/Cli/dotnet/Commands/Test/TestCommandParser.cs
index cf9539c1439c..02b51b631f7a 100644
--- a/src/Cli/dotnet/Commands/Test/TestCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Test/TestCommandParser.cs
@@ -294,6 +294,7 @@ private static Command GetVSTestCliCommand()
         command.Options.Add(CommonOptions.ArchitectureOption);
         command.Options.Add(CommonOptions.OperatingSystemOption);
         command.Options.Add(CommonOptions.DisableBuildServersOption);
+        command.Options.Add(CommonOptions.BinaryLoggerOption);
         command.Options.Add(VsTestTargetOption);
         command.SetAction(TestCommand.Run);
 
diff --git a/src/Cli/dotnet/CommonOptions.cs b/src/Cli/dotnet/CommonOptions.cs
index aff691d5f250..213686513ed1 100644
--- a/src/Cli/dotnet/CommonOptions.cs
+++ b/src/Cli/dotnet/CommonOptions.cs
@@ -47,6 +47,18 @@ internal static class CommonOptions
         .ForwardAsMSBuildProperty()
         .AllowSingleArgPerToken();
 
+    public static Option<string?> BinaryLoggerOption =
+        // these are all of the forms that the binary logger switch can be understood by in MSBuild
+        new ForwardedOption<string?>("--binaryLogger", "-binaryLogger", "/binaryLogger", "-bl", "--bl", "/bl")
+        {
+            Description = "Log all build output to a binary log file. Optionally specify a file path and optional parameters.",
+            HelpName = "PATH",
+            Arity = ArgumentArity.ZeroOrOne,
+            Hidden = true
+        }
+        .SetForwardingFunction(ForwardBinaryLoggerOption)
+        .AllowSingleArgPerToken();
+
     private static ReadOnlyDictionary<string, string>? ParseMSBuildTokensIntoDictionary(ArgumentResult result)
     {
         if (result.Tokens.Count == 0)
@@ -122,6 +134,20 @@ public static string[] SplitMSBuildTargets(string? defaultTargetName, ArgumentRe
         return allTargets.Distinct(StringComparer.OrdinalIgnoreCase).ToArray();
     }
 
+    private static IEnumerable<string> ForwardBinaryLoggerOption(string? value)
+    {
+        if (value is null)
+        {
+            // If no value is provided, forward the flag without parameter
+            return ["-binaryLogger"];
+        }
+        else
+        {
+            // If a value is provided, forward it with the parameter
+            return [$"-binaryLogger:{value}"];
+        }
+    }
+
     public static Option<VerbosityOptions> VerbosityOption(VerbosityOptions defaultVerbosity) =>
         new ForwardedOption<VerbosityOptions>("--verbosity", "-v")
         {

From 525191ed64329527e8d6f94161a16e500bd4b4f7 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 5 Aug 2025 21:06:28 +0000
Subject: [PATCH 3/7] Fix binary logger option forwarding to preserve original
 token format

Co-authored-by: baronfel <573979+baronfel@users.noreply.github.com>
---
 src/Cli/dotnet/CommonOptions.cs | 58 +++++++++++++++++++++------------
 1 file changed, 38 insertions(+), 20 deletions(-)

diff --git a/src/Cli/dotnet/CommonOptions.cs b/src/Cli/dotnet/CommonOptions.cs
index 213686513ed1..7c1afb7b50de 100644
--- a/src/Cli/dotnet/CommonOptions.cs
+++ b/src/Cli/dotnet/CommonOptions.cs
@@ -47,17 +47,49 @@ internal static class CommonOptions
         .ForwardAsMSBuildProperty()
         .AllowSingleArgPerToken();
 
-    public static Option<string?> BinaryLoggerOption =
-        // these are all of the forms that the binary logger switch can be understood by in MSBuild
-        new ForwardedOption<string?>("--binaryLogger", "-binaryLogger", "/binaryLogger", "-bl", "--bl", "/bl")
+    public static Option<string?> BinaryLoggerOption = CreateBinaryLoggerOption();
+
+    private static ForwardedOption<string?> CreateBinaryLoggerOption()
+    {
+        var option = new ForwardedOption<string?>("--binaryLogger", "-binaryLogger", "/binaryLogger", "-bl", "--bl", "/bl")
         {
             Description = "Log all build output to a binary log file. Optionally specify a file path and optional parameters.",
             HelpName = "PATH",
             Arity = ArgumentArity.ZeroOrOne,
             Hidden = true
-        }
-        .SetForwardingFunction(ForwardBinaryLoggerOption)
-        .AllowSingleArgPerToken();
+        };
+        
+        option.AllowSingleArgPerToken();
+        
+        // Set the forwarding function directly using the private method
+        option.SetForwardingFunction((string? value, ParseResult parseResult) => 
+        {
+            // Find the option result for the binary logger
+            var optionResult = parseResult.GetResult(option);
+            if (optionResult != null)
+            {
+                // Get the exact token that was used (e.g., "-bl", "/bl", "--binaryLogger", etc.)
+                var originalToken = optionResult.IdentifierToken?.Value ?? option.Name;
+                
+                // Check if there are any argument tokens (the value after :)
+                if (optionResult.Tokens.Count > 0)
+                {
+                    // If there is a value, forward it with the parameter
+                    var argumentValue = optionResult.Tokens[0].Value;
+                    return [$"{originalToken}:{argumentValue}"];
+                }
+                else
+                {
+                    // If no value is provided, forward just the flag
+                    return [originalToken];
+                }
+            }
+            
+            return [];
+        });
+        
+        return option;
+    }
 
     private static ReadOnlyDictionary<string, string>? ParseMSBuildTokensIntoDictionary(ArgumentResult result)
     {
@@ -134,20 +166,6 @@ public static string[] SplitMSBuildTargets(string? defaultTargetName, ArgumentRe
         return allTargets.Distinct(StringComparer.OrdinalIgnoreCase).ToArray();
     }
 
-    private static IEnumerable<string> ForwardBinaryLoggerOption(string? value)
-    {
-        if (value is null)
-        {
-            // If no value is provided, forward the flag without parameter
-            return ["-binaryLogger"];
-        }
-        else
-        {
-            // If a value is provided, forward it with the parameter
-            return [$"-binaryLogger:{value}"];
-        }
-    }
-
     public static Option<VerbosityOptions> VerbosityOption(VerbosityOptions defaultVerbosity) =>
         new ForwardedOption<VerbosityOptions>("--verbosity", "-v")
         {

From f4ad9948c13c11b91b1cde6cc34e765e65f38142 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 5 Aug 2025 21:14:33 +0000
Subject: [PATCH 4/7] Complete BinaryLoggerOption implementation with
 reflection-based ForwardingFunction

Co-authored-by: baronfel <573979+baronfel@users.noreply.github.com>
---
 src/Cli/dotnet/CommonOptions.cs | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/src/Cli/dotnet/CommonOptions.cs b/src/Cli/dotnet/CommonOptions.cs
index 7c1afb7b50de..e806eca1f09a 100644
--- a/src/Cli/dotnet/CommonOptions.cs
+++ b/src/Cli/dotnet/CommonOptions.cs
@@ -61,8 +61,8 @@ internal static class CommonOptions
         
         option.AllowSingleArgPerToken();
         
-        // Set the forwarding function directly using the private method
-        option.SetForwardingFunction((string? value, ParseResult parseResult) => 
+        // Set the forwarding function directly to bypass the null value check
+        Func<ParseResult, IEnumerable<string>> forwardingFunc = (ParseResult parseResult) =>
         {
             // Find the option result for the binary logger
             var optionResult = parseResult.GetResult(option);
@@ -86,7 +86,11 @@ internal static class CommonOptions
             }
             
             return [];
-        });
+        };
+        
+        // Use reflection to set the private ForwardingFunction field
+        var forwardingFunctionField = typeof(ForwardedOption<string?>).GetField("ForwardingFunction", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
+        forwardingFunctionField?.SetValue(option, forwardingFunc);
         
         return option;
     }

From 2b1d572dc33ad8983dc8c6505de26c9772502b21 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 5 Aug 2025 23:14:35 +0000
Subject: [PATCH 5/7] Refactor BinaryLoggerOption to use ForwardAs instead of
 reflection and support typed parameters

Co-authored-by: baronfel <573979+baronfel@users.noreply.github.com>
---
 .../CommandLine/CommandLineOptions.cs         |  39 ++---
 .../dotnet/Commands/Run/Api/RunApiCommand.cs  |   3 +-
 src/Cli/dotnet/Commands/Run/RunCommand.cs     |  68 ++++++--
 src/Cli/dotnet/CommonOptions.cs               | 149 +++++++++++++-----
 4 files changed, 182 insertions(+), 77 deletions(-)

diff --git a/src/BuiltInTools/dotnet-watch/CommandLine/CommandLineOptions.cs b/src/BuiltInTools/dotnet-watch/CommandLine/CommandLineOptions.cs
index d6168b54afa3..e18827e930ca 100644
--- a/src/BuiltInTools/dotnet-watch/CommandLine/CommandLineOptions.cs
+++ b/src/BuiltInTools/dotnet-watch/CommandLine/CommandLineOptions.cs
@@ -160,8 +160,8 @@ internal sealed class CommandLineOptions
         var buildArguments = buildOptions.Select(option => ((IForwardedOption)option).GetForwardingFunction()(parseResult)).SelectMany(args => args).ToList();
 
         var targetFrameworkOption = (Option<string>?)buildOptions.SingleOrDefault(option => option.Name == "--framework");
-        var binaryLoggerOption = (Option<string?>?)buildOptions.SingleOrDefault(option => option.Name == "--binaryLogger");
-        var binaryLoggerPath = binaryLoggerOption != null ? parseResult.GetValue(binaryLoggerOption) : null;
+        var binaryLoggerOption = (Option<BinaryLoggerOptions?>?)buildOptions.SingleOrDefault(option => option.Name == "--binaryLogger");
+        var binaryLoggerOptions = binaryLoggerOption != null ? parseResult.GetValue(binaryLoggerOption) : null;
 
         return new()
         {
@@ -172,7 +172,7 @@ internal sealed class CommandLineOptions
                 NoHotReload = parseResult.GetValue(noHotReloadOption),
                 NonInteractive = parseResult.GetValue(NonInteractiveOption),
                 Verbose = parseResult.GetValue(verboseOption),
-                BinaryLogPath = ParseBinaryLogFilePath(binaryLoggerPath),
+                BinaryLogPath = GetBinaryLogFilePath(binaryLoggerOptions),
             },
 
             CommandArguments = commandArguments,
@@ -187,24 +187,25 @@ internal sealed class CommandLineOptions
     }
 
     /// <summary>
-    /// Parses the value of msbuild option `-binaryLogger[:[LogFile=]output.binlog[;ProjectImports={None,Embed,ZipFile}]]`.
-    /// Emulates https://github.com/dotnet/msbuild/blob/7f69ea906c29f2478cc05423484ad185de66e124/src/Build/Logging/BinaryLogger/BinaryLogger.cs#L481.
-    /// See https://github.com/dotnet/msbuild/issues/12256
+    /// Gets the binary log file path from the binary logger options.
     /// </summary>
-    internal static string? ParseBinaryLogFilePath(string? value)
-        => value switch
+    internal static string? GetBinaryLogFilePath(BinaryLoggerOptions? options)
+    {
+        if (options == null)
         {
-            null => null,
-            _ => (from parameter in value.Split(';', StringSplitOptions.RemoveEmptyEntries)
-                  where !string.Equals(parameter, "ProjectImports=None", StringComparison.OrdinalIgnoreCase) &&
-                        !string.Equals(parameter, "ProjectImports=Embed", StringComparison.OrdinalIgnoreCase) &&
-                        !string.Equals(parameter, "ProjectImports=ZipFile", StringComparison.OrdinalIgnoreCase) &&
-                        !string.Equals(parameter, "OmitInitialInfo", StringComparison.OrdinalIgnoreCase)
-                  let path = (parameter.StartsWith("LogFile=", StringComparison.OrdinalIgnoreCase) ? parameter["LogFile=".Length..] : parameter).Trim('"')
-                  let pathWithExtension = path.EndsWith(".binlog", StringComparison.OrdinalIgnoreCase) ? path : $"{path}.binlog"
-                  select pathWithExtension)
-                 .LastOrDefault("msbuild.binlog")
-        };
+            return null;
+        }
+
+        var parsedParams = options.ParseParameters();
+        if (!string.IsNullOrEmpty(parsedParams.LogFile))
+        {
+            return parsedParams.LogFile.EndsWith(".binlog", StringComparison.OrdinalIgnoreCase) 
+                ? parsedParams.LogFile 
+                : $"{parsedParams.LogFile}.binlog";
+        }
+
+        return "msbuild.binlog";
+    }
 
     private static IReadOnlyList<string> GetCommandArguments(
         ParseResult parseResult,
diff --git a/src/Cli/dotnet/Commands/Run/Api/RunApiCommand.cs b/src/Cli/dotnet/Commands/Run/Api/RunApiCommand.cs
index 067ff538a740..fc416658ad01 100644
--- a/src/Cli/dotnet/Commands/Run/Api/RunApiCommand.cs
+++ b/src/Cli/dotnet/Commands/Run/Api/RunApiCommand.cs
@@ -108,7 +108,8 @@ public override RunApiOutput Execute()
                 applicationArgs: [],
                 readCodeFromStdin: false,
                 environmentVariables: ReadOnlyDictionary<string, string>.Empty,
-                msbuildRestoreProperties: ReadOnlyDictionary<string, string>.Empty);
+                msbuildRestoreProperties: ReadOnlyDictionary<string, string>.Empty,
+                binaryLoggerOptions: null);
 
             runCommand.TryGetLaunchProfileSettingsIfNeeded(out var launchSettings);
             var targetCommand = (Utils.Command)runCommand.GetTargetCommand(buildCommand.CreateProjectInstance);
diff --git a/src/Cli/dotnet/Commands/Run/RunCommand.cs b/src/Cli/dotnet/Commands/Run/RunCommand.cs
index 6a1876c3a886..8bd29ab8ca30 100644
--- a/src/Cli/dotnet/Commands/Run/RunCommand.cs
+++ b/src/Cli/dotnet/Commands/Run/RunCommand.cs
@@ -46,6 +46,11 @@ public class RunCommand
 
     public ReadOnlyDictionary<string, string>? RestoreProperties { get; }
 
+    /// <summary>
+    /// Binary logger options, if specified on the command line.
+    /// </summary>
+    public BinaryLoggerOptions? BinaryLoggerOptions { get; }
+
     /// <summary>
     /// unparsed/arbitrary CLI tokens to be passed to the running application
     /// </summary>
@@ -89,7 +94,8 @@ public RunCommand(
         string[] applicationArgs,
         bool readCodeFromStdin,
         IReadOnlyDictionary<string, string> environmentVariables,
-        ReadOnlyDictionary<string, string>? msbuildRestoreProperties)
+        ReadOnlyDictionary<string, string>? msbuildRestoreProperties,
+        BinaryLoggerOptions? binaryLoggerOptions)
     {
         Debug.Assert(projectFileFullPath is null ^ entryPointFileFullPath is null);
         Debug.Assert(!readCodeFromStdin || entryPointFileFullPath is not null);
@@ -108,6 +114,7 @@ public RunCommand(
         MSBuildArgs = SetupSilentBuildArgs(msbuildArgs);
         EnvironmentVariables = environmentVariables;
         RestoreProperties = msbuildRestoreProperties;
+        BinaryLoggerOptions = binaryLoggerOptions;
     }
 
     public int Execute()
@@ -356,7 +363,7 @@ internal ICommand GetTargetCommand(Func<ProjectCollection, ProjectInstance>? pro
             return CreateCommandForCscBuiltProgram(EntryPointFileFullPath);
         }
 
-        FacadeLogger? logger = LoggerUtility.DetermineBinlogger([..MSBuildArgs.OtherMSBuildArgs], "dotnet-run");
+        FacadeLogger? logger = CreateBinaryLogger(BinaryLoggerOptions, "dotnet-run");
         var project = EvaluateProject(ProjectFileFullPath, projectFactory, MSBuildArgs, logger);
         ValidatePreconditions(project);
         InvokeRunArgumentsTarget(project, NoBuild, logger, MSBuildArgs);
@@ -465,6 +472,38 @@ static void InvokeRunArgumentsTarget(ProjectInstance project, bool noBuild, Faca
         }
     }
 
+    private static FacadeLogger? CreateBinaryLogger(BinaryLoggerOptions? options, string verb)
+    {
+        if (options == null)
+        {
+            return null;
+        }
+
+        List<BinaryLogger> binaryLoggers = [];
+        var parsedParams = options.ParseParameters();
+
+        string filename;
+        if (!string.IsNullOrEmpty(parsedParams.LogFile))
+        {
+            filename = parsedParams.LogFile;
+            if (filename.EndsWith(".binlog"))
+            {
+                filename = filename.Substring(0, filename.Length - ".binlog".Length);
+                filename = $"{filename}-{verb}.binlog";
+            }
+        }
+        else
+        {
+            // Default filename when no specific file is provided
+            filename = $"msbuild-{verb}.binlog";
+        }
+
+        binaryLoggers.Add(new BinaryLogger { Parameters = filename });
+
+        // Create the facade logger
+        return LoggerUtility.CreateFacadeLogger(binaryLoggers);
+    }
+
     static readonly string ComputeRunArgumentsTarget = "ComputeRunArguments";
 
     private static LoggerVerbosity ToLoggerVerbosity(VerbosityOptions? verbosity)
@@ -596,23 +635,14 @@ public static RunCommand FromParseResult(ParseResult parseResult)
             parseResult = ModifyParseResultForShorthandProjectOption(parseResult);
         }
 
-        // if the application arguments contain any binlog args then we need to remove them from the application arguments and apply
-        // them to the restore args.
-        // this is because we can't model the binlog command structure in MSbuild in the System.CommandLine parser, but we need
-        // bl information to synchronize the restore and build logger configurations
+        // Get application arguments (no need to separate binary log args since they're now handled as a ForwardedOption)
         var applicationArguments = parseResult.GetValue(RunCommandParser.ApplicationArguments)?.ToList();
 
-        LoggerUtility.SeparateBinLogArguments(applicationArguments, out var binLogArgs, out var nonBinLogArgs);
-
         var msbuildProperties = parseResult.OptionValuesToBeForwarded(RunCommandParser.GetCommand()).ToList();
-        if (binLogArgs.Count > 0)
-        {
-            msbuildProperties.AddRange(binLogArgs);
-        }
 
         // Only consider `-` to mean "read code from stdin" if it is before double dash `--`
         // (otherwise it should be forwarded to the target application as its command-line argument).
-        bool readCodeFromStdin = nonBinLogArgs is ["-", ..] &&
+        bool readCodeFromStdin = applicationArguments is ["-", ..] &&
             parseResult.Tokens.TakeWhile(static t => t.Type != TokenType.DoubleDash)
                 .Any(static t => t is { Type: TokenType.Argument, Value: "-" });
 
@@ -624,7 +654,7 @@ public static RunCommand FromParseResult(ParseResult parseResult)
             throw new GracefulException(CliCommandStrings.CannotCombineOptions, RunCommandParser.ProjectOption.Name, RunCommandParser.FileOption.Name);
         }
 
-        string[] args = [.. nonBinLogArgs];
+        string[] args = [.. applicationArguments ?? []];
         string? projectFilePath = DiscoverProjectFilePath(
             filePath: fileOption,
             projectFileOrDirectoryPath: projectOption,
@@ -661,8 +691,11 @@ public static RunCommand FromParseResult(ParseResult parseResult)
                 stdinStream.CopyTo(fileStream);
             }
 
-            Debug.Assert(nonBinLogArgs[0] == "-");
-            nonBinLogArgs[0] = entryPointFilePath;
+            Debug.Assert(applicationArguments?[0] == "-");
+            if (applicationArguments != null)
+            {
+                applicationArguments[0] = entryPointFilePath;
+            }
         }
 
         var msbuildArgs = MSBuildArgs.AnalyzeMSBuildArguments(msbuildProperties, CommonOptions.PropertiesOption, CommonOptions.RestorePropertiesOption, CommonOptions.MSBuildTargetOption(), RunCommandParser.VerbosityOption);
@@ -681,7 +714,8 @@ public static RunCommand FromParseResult(ParseResult parseResult)
             applicationArgs: args,
             readCodeFromStdin: readCodeFromStdin,
             environmentVariables: parseResult.GetValue(CommonOptions.EnvOption) ?? ImmutableDictionary<string, string>.Empty,
-            msbuildRestoreProperties: parseResult.GetValue(CommonOptions.RestorePropertiesOption)
+            msbuildRestoreProperties: parseResult.GetValue(CommonOptions.RestorePropertiesOption),
+            binaryLoggerOptions: parseResult.GetValue(CommonOptions.BinaryLoggerOption)
         );
 
         return command;
diff --git a/src/Cli/dotnet/CommonOptions.cs b/src/Cli/dotnet/CommonOptions.cs
index e806eca1f09a..aecb40be15cc 100644
--- a/src/Cli/dotnet/CommonOptions.cs
+++ b/src/Cli/dotnet/CommonOptions.cs
@@ -47,52 +47,67 @@ internal static class CommonOptions
         .ForwardAsMSBuildProperty()
         .AllowSingleArgPerToken();
 
-    public static Option<string?> BinaryLoggerOption = CreateBinaryLoggerOption();
-
-    private static ForwardedOption<string?> CreateBinaryLoggerOption()
-    {
-        var option = new ForwardedOption<string?>("--binaryLogger", "-binaryLogger", "/binaryLogger", "-bl", "--bl", "/bl")
+    public static Option<BinaryLoggerOptions?> BinaryLoggerOption =
+        new ForwardedOption<BinaryLoggerOptions?>("--binaryLogger", "-binaryLogger", "/binaryLogger", "-bl", "--bl", "/bl")
         {
             Description = "Log all build output to a binary log file. Optionally specify a file path and optional parameters.",
             HelpName = "PATH",
             Arity = ArgumentArity.ZeroOrOne,
-            Hidden = true
-        };
-        
-        option.AllowSingleArgPerToken();
-        
-        // Set the forwarding function directly to bypass the null value check
-        Func<ParseResult, IEnumerable<string>> forwardingFunc = (ParseResult parseResult) =>
+            Hidden = true,
+            CustomParser = ParseBinaryLoggerOptions
+        }
+        .SetForwardingFunction(ForwardBinaryLoggerOptions)
+        .AllowSingleArgPerToken();
+
+    private static BinaryLoggerOptions? ParseBinaryLoggerOptions(ArgumentResult result)
+    {
+        if (result.Tokens.Count == 0)
+        {
+            // Flag form (e.g., -bl without parameters)
+            return new BinaryLoggerOptions(null, null);
+        }
+
+        if (result.Tokens.Count == 1)
+        {
+            // Parameter form (e.g., -bl:file.binlog or -bl file.binlog)
+            var argumentValue = result.Tokens[0].Value;
+            return new BinaryLoggerOptions(null, argumentValue);
+        }
+
+        return null;
+    }
+
+    private static IEnumerable<string> ForwardBinaryLoggerOptions(BinaryLoggerOptions? options, ParseResult parseResult)
+    {
+        if (options == null)
         {
-            // Find the option result for the binary logger
-            var optionResult = parseResult.GetResult(option);
-            if (optionResult != null)
-            {
-                // Get the exact token that was used (e.g., "-bl", "/bl", "--binaryLogger", etc.)
-                var originalToken = optionResult.IdentifierToken?.Value ?? option.Name;
-                
-                // Check if there are any argument tokens (the value after :)
-                if (optionResult.Tokens.Count > 0)
-                {
-                    // If there is a value, forward it with the parameter
-                    var argumentValue = optionResult.Tokens[0].Value;
-                    return [$"{originalToken}:{argumentValue}"];
-                }
-                else
-                {
-                    // If no value is provided, forward just the flag
-                    return [originalToken];
-                }
-            }
-            
             return [];
-        };
-        
-        // Use reflection to set the private ForwardingFunction field
-        var forwardingFunctionField = typeof(ForwardedOption<string?>).GetField("ForwardingFunction", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
-        forwardingFunctionField?.SetValue(option, forwardingFunc);
-        
-        return option;
+        }
+
+        // Get the option result to access the original token that was used
+        var optionResult = parseResult.GetResult(BinaryLoggerOption);
+        if (optionResult == null)
+        {
+            return [];
+        }
+
+        // Find the original token that was used to invoke this option
+        string originalToken = "--binaryLogger"; // default fallback
+        if (optionResult.IdentifierToken != null)
+        {
+            originalToken = optionResult.IdentifierToken.Value;
+        }
+
+        if (options.Arguments == null)
+        {
+            // Flag form: forward just the original token
+            return [originalToken];
+        }
+        else
+        {
+            // Parameter form: forward with colon syntax
+            return [$"{originalToken}:{options.Arguments}"];
+        }
     }
 
     private static ReadOnlyDictionary<string, string>? ParseMSBuildTokensIntoDictionary(ArgumentResult result)
@@ -526,3 +541,57 @@ public class DynamicOption<T>(string name, params string[] aliases) : Option<T>(
 public class DynamicArgument<T>(string name) : Argument<T>(name), IDynamicArgument
 {
 }
+
+/// <summary>
+/// Represents the parsed binary logger options for MSBuild.
+/// </summary>
+/// <param name="OriginalToken">The original command-line token used (determined from ParseResult), or null if not available</param>
+/// <param name="Arguments">The arguments part of the binary logger option, or null if none specified</param>
+public record BinaryLoggerOptions(string? OriginalToken, string? Arguments)
+{
+    /// <summary>
+    /// Parses the arguments into structured binary logger parameters.
+    /// Format: filename[;keyword=value]*
+    /// </summary>
+    public BinaryLoggerParameters ParseParameters()
+    {
+        if (string.IsNullOrEmpty(Arguments))
+        {
+            return new BinaryLoggerParameters();
+        }
+
+        var parts = Arguments.Split(';');
+        string? logFile = parts.Length > 0 ? parts[0] : null;
+        
+        // If the first part is empty or just contains keywords, no filename was specified
+        if (logFile?.Contains('=') == true)
+        {
+            logFile = null;
+        }
+
+        var parameters = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+        
+        // Parse keyword=value pairs starting from the appropriate index
+        int startIndex = logFile != null ? 1 : 0;
+        for (int i = startIndex; i < parts.Length; i++)
+        {
+            var part = parts[i];
+            var equalIndex = part.IndexOf('=');
+            if (equalIndex > 0)
+            {
+                string key = part.Substring(0, equalIndex);
+                string value = part.Substring(equalIndex + 1);
+                parameters[key] = value;
+            }
+        }
+
+        return new BinaryLoggerParameters(logFile, parameters);
+    }
+}
+
+/// <summary>
+/// Represents the structured parameters for binary logging.
+/// </summary>
+/// <param name="LogFile">The log file path, or null if not specified</param>
+/// <param name="Parameters">Additional keyword-value parameters</param>
+public record BinaryLoggerParameters(string? LogFile = null, IReadOnlyDictionary<string, string>? Parameters = null);

From b225decbdd55bc4f115550496b1e8286a9d94114 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 6 Aug 2025 15:04:45 +0000
Subject: [PATCH 6/7] Enhance binary logger parsing to fully support MSBuild
 parameters and update all usages

Co-authored-by: baronfel <573979+baronfel@users.noreply.github.com>
---
 src/Cli/dotnet/Commands/Run/RunCommand.cs     |  34 +-----
 .../dotnet/Commands/Test/MSBuildUtility.cs    |  10 +-
 src/Cli/dotnet/Commands/Test/Options.cs       |   8 +-
 .../dotnet/Commands/Test/TestCommandParser.cs |   1 +
 src/Cli/dotnet/CommonOptions.cs               | 108 +++++++++++++++---
 src/Cli/dotnet/LoggerUtility.cs               |  57 +++++++++
 6 files changed, 162 insertions(+), 56 deletions(-)

diff --git a/src/Cli/dotnet/Commands/Run/RunCommand.cs b/src/Cli/dotnet/Commands/Run/RunCommand.cs
index 8bd29ab8ca30..b92f0640bbc2 100644
--- a/src/Cli/dotnet/Commands/Run/RunCommand.cs
+++ b/src/Cli/dotnet/Commands/Run/RunCommand.cs
@@ -363,7 +363,7 @@ internal ICommand GetTargetCommand(Func<ProjectCollection, ProjectInstance>? pro
             return CreateCommandForCscBuiltProgram(EntryPointFileFullPath);
         }
 
-        FacadeLogger? logger = CreateBinaryLogger(BinaryLoggerOptions, "dotnet-run");
+        FacadeLogger? logger = LoggerUtility.CreateBinaryLogger(BinaryLoggerOptions, "dotnet-run");
         var project = EvaluateProject(ProjectFileFullPath, projectFactory, MSBuildArgs, logger);
         ValidatePreconditions(project);
         InvokeRunArgumentsTarget(project, NoBuild, logger, MSBuildArgs);
@@ -472,38 +472,6 @@ static void InvokeRunArgumentsTarget(ProjectInstance project, bool noBuild, Faca
         }
     }
 
-    private static FacadeLogger? CreateBinaryLogger(BinaryLoggerOptions? options, string verb)
-    {
-        if (options == null)
-        {
-            return null;
-        }
-
-        List<BinaryLogger> binaryLoggers = [];
-        var parsedParams = options.ParseParameters();
-
-        string filename;
-        if (!string.IsNullOrEmpty(parsedParams.LogFile))
-        {
-            filename = parsedParams.LogFile;
-            if (filename.EndsWith(".binlog"))
-            {
-                filename = filename.Substring(0, filename.Length - ".binlog".Length);
-                filename = $"{filename}-{verb}.binlog";
-            }
-        }
-        else
-        {
-            // Default filename when no specific file is provided
-            filename = $"msbuild-{verb}.binlog";
-        }
-
-        binaryLoggers.Add(new BinaryLogger { Parameters = filename });
-
-        // Create the facade logger
-        return LoggerUtility.CreateFacadeLogger(binaryLoggers);
-    }
-
     static readonly string ComputeRunArgumentsTarget = "ComputeRunArguments";
 
     private static LoggerVerbosity ToLoggerVerbosity(VerbosityOptions? verbosity)
diff --git a/src/Cli/dotnet/Commands/Test/MSBuildUtility.cs b/src/Cli/dotnet/Commands/Test/MSBuildUtility.cs
index 5944ad4f677d..b6a648ec8b41 100644
--- a/src/Cli/dotnet/Commands/Test/MSBuildUtility.cs
+++ b/src/Cli/dotnet/Commands/Test/MSBuildUtility.cs
@@ -32,7 +32,7 @@ public static (IEnumerable<ParallelizableTestModuleGroupWithSequentialInnerModul
                 Path.GetDirectoryName(solutionModel.Description)! :
                 SolutionAndProjectUtility.GetRootDirectory(solutionFilePath);
 
-        FacadeLogger? logger = LoggerUtility.DetermineBinlogger([.. buildOptions.MSBuildArgs], dotnetTestVerb);
+        FacadeLogger? logger = LoggerUtility.CreateBinaryLogger(buildOptions.BinaryLoggerOptions, dotnetTestVerb);
         var collection = new ProjectCollection(globalProperties: CommonRunHelpers.GetGlobalPropertiesFromArgs([.. buildOptions.MSBuildArgs]), loggers: logger is null ? null : [logger], toolsetDefinitionLocations: ToolsetDefinitionLocations.Default);
 
         ConcurrentBag<ParallelizableTestModuleGroupWithSequentialInnerModules> projects = GetProjectsProperties(collection, solutionModel.SolutionProjects.Select(p => Path.Combine(rootDirectory, p.FilePath)), buildOptions);
@@ -50,7 +50,7 @@ public static (IEnumerable<ParallelizableTestModuleGroupWithSequentialInnerModul
             return (Array.Empty<ParallelizableTestModuleGroupWithSequentialInnerModules>(), isBuiltOrRestored);
         }
 
-        FacadeLogger? logger = LoggerUtility.DetermineBinlogger([.. buildOptions.MSBuildArgs], dotnetTestVerb);
+        FacadeLogger? logger = LoggerUtility.CreateBinaryLogger(buildOptions.BinaryLoggerOptions, dotnetTestVerb);
         var collection = new ProjectCollection(globalProperties: CommonRunHelpers.GetGlobalPropertiesFromArgs([.. buildOptions.MSBuildArgs]), logger is null ? null : [logger], toolsetDefinitionLocations: ToolsetDefinitionLocations.Default);
 
         IEnumerable<ParallelizableTestModuleGroupWithSequentialInnerModules> projects = SolutionAndProjectUtility.GetProjectProperties(projectFilePath, collection, buildOptions.NoLaunchProfile);
@@ -71,6 +71,9 @@ public static BuildOptions GetBuildOptions(ParseResult parseResult, int degreeOf
             parseResult.GetValue(TestingPlatformOptions.SolutionOption),
             parseResult.GetValue(TestingPlatformOptions.DirectoryOption));
 
+        // Get the binary logger options from the parse result
+        var binaryLoggerOptions = parseResult.GetValue(CommonOptions.BinaryLoggerOption);
+
         return new BuildOptions(
             pathOptions,
             parseResult.GetValue(CommonOptions.NoRestoreOption),
@@ -80,7 +83,8 @@ public static BuildOptions GetBuildOptions(ParseResult parseResult, int degreeOf
             parseResult.GetValue(TestingPlatformOptions.NoLaunchProfileArgumentsOption),
             degreeOfParallelism,
             otherArgs,
-            msbuildArgs);
+            msbuildArgs,
+            binaryLoggerOptions);
     }
 
     private static bool BuildOrRestoreProjectOrSolution(string filePath, BuildOptions buildOptions)
diff --git a/src/Cli/dotnet/Commands/Test/Options.cs b/src/Cli/dotnet/Commands/Test/Options.cs
index ff64e4e7ce5a..5b09f44721e4 100644
--- a/src/Cli/dotnet/Commands/Test/Options.cs
+++ b/src/Cli/dotnet/Commands/Test/Options.cs
@@ -1,6 +1,8 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using Microsoft.DotNet.Cli;
+
 namespace Microsoft.DotNet.Cli.Commands.Test;
 
 internal record TestOptions(bool HasFilterMode, bool IsHelp);
@@ -14,5 +16,7 @@ internal record BuildOptions(
     Utils.VerbosityOptions? Verbosity,
     bool NoLaunchProfile,
     bool NoLaunchProfileArguments,
-    int DegreeOfParallelism, List<string> UnmatchedTokens,
-    IEnumerable<string> MSBuildArgs);
+    int DegreeOfParallelism, 
+    List<string> UnmatchedTokens,
+    IEnumerable<string> MSBuildArgs,
+    BinaryLoggerOptions? BinaryLoggerOptions);
diff --git a/src/Cli/dotnet/Commands/Test/TestCommandParser.cs b/src/Cli/dotnet/Commands/Test/TestCommandParser.cs
index 02b51b631f7a..97b98f10ac7c 100644
--- a/src/Cli/dotnet/Commands/Test/TestCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Test/TestCommandParser.cs
@@ -250,6 +250,7 @@ private static Command GetTestingPlatformCliCommand()
         command.Options.Add(TestingPlatformOptions.OutputOption);
         command.Options.Add(TestingPlatformOptions.NoLaunchProfileOption);
         command.Options.Add(TestingPlatformOptions.NoLaunchProfileArgumentsOption);
+        command.Options.Add(CommonOptions.BinaryLoggerOption);
         command.Options.Add(MTPTargetOption);
 
         return command;
diff --git a/src/Cli/dotnet/CommonOptions.cs b/src/Cli/dotnet/CommonOptions.cs
index aecb40be15cc..cecb42078778 100644
--- a/src/Cli/dotnet/CommonOptions.cs
+++ b/src/Cli/dotnet/CommonOptions.cs
@@ -7,6 +7,7 @@
 using System.CommandLine.Completions;
 using System.CommandLine.Parsing;
 using System.CommandLine.StaticCompletions;
+using Microsoft.Build.Framework;
 using Microsoft.DotNet.Cli.Extensions;
 using Microsoft.DotNet.Cli.Utils;
 
@@ -551,7 +552,11 @@ public record BinaryLoggerOptions(string? OriginalToken, string? Arguments)
 {
     /// <summary>
     /// Parses the arguments into structured binary logger parameters.
-    /// Format: filename[;keyword=value]*
+    /// Supports the full MSBuild format: [LogFile=]filename[;keyword=value]*
+    /// Examples:
+    /// - "output.binlog" -> LogFile = "output.binlog"
+    /// - "output.binlog;ProjectImports=None" -> LogFile = "output.binlog", ProjectImports = None
+    /// - "LogFile=output.binlog;ProjectImports=ZipFile" -> LogFile = "output.binlog", ProjectImports = ZipFile
     /// </summary>
     public BinaryLoggerParameters ParseParameters()
     {
@@ -561,31 +566,73 @@ public BinaryLoggerParameters ParseParameters()
         }
 
         var parts = Arguments.Split(';');
-        string? logFile = parts.Length > 0 ? parts[0] : null;
-        
-        // If the first part is empty or just contains keywords, no filename was specified
-        if (logFile?.Contains('=') == true)
-        {
-            logFile = null;
-        }
-
+        string? logFile = null;
+        ProjectImportsMode? projectImports = null;
+        LoggerVerbosity? verbosity = null;
         var parameters = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
         
-        // Parse keyword=value pairs starting from the appropriate index
-        int startIndex = logFile != null ? 1 : 0;
-        for (int i = startIndex; i < parts.Length; i++)
+        // Parse each part
+        for (int i = 0; i < parts.Length; i++)
         {
-            var part = parts[i];
+            var part = parts[i].Trim();
+            if (string.IsNullOrEmpty(part))
+                continue;
+
             var equalIndex = part.IndexOf('=');
+            
             if (equalIndex > 0)
             {
-                string key = part.Substring(0, equalIndex);
-                string value = part.Substring(equalIndex + 1);
-                parameters[key] = value;
+                // keyword=value format
+                string key = part.Substring(0, equalIndex).Trim();
+                string value = part.Substring(equalIndex + 1).Trim();
+
+                switch (key.ToLowerInvariant())
+                {
+                    case "logfile":
+                        logFile = value;
+                        break;
+                    case "projectimports":
+                        if (Enum.TryParse<ProjectImportsMode>(value, ignoreCase: true, out var importMode))
+                        {
+                            projectImports = importMode;
+                        }
+                        else
+                        {
+                            parameters[key] = value;
+                        }
+                        break;
+                    case "verbosity":
+                        if (Enum.TryParse<LoggerVerbosity>(value, ignoreCase: true, out var verb))
+                        {
+                            verbosity = verb;
+                        }
+                        else
+                        {
+                            parameters[key] = value;
+                        }
+                        break;
+                    default:
+                        parameters[key] = value;
+                        break;
+                }
+            }
+            else if (i == 0)
+            {
+                // First part without '=' is treated as the log file
+                logFile = part;
+            }
+            else
+            {
+                // Treat as a parameter with empty value
+                parameters[part] = "";
             }
         }
 
-        return new BinaryLoggerParameters(logFile, parameters);
+        return new BinaryLoggerParameters(
+            logFile, 
+            projectImports, 
+            verbosity, 
+            parameters.Count > 0 ? parameters : null);
     }
 }
 
@@ -593,5 +640,30 @@ public BinaryLoggerParameters ParseParameters()
 /// Represents the structured parameters for binary logging.
 /// </summary>
 /// <param name="LogFile">The log file path, or null if not specified</param>
+/// <param name="ProjectImports">How to handle project imports</param>
+/// <param name="Verbosity">The logger verbosity level</param>
 /// <param name="Parameters">Additional keyword-value parameters</param>
-public record BinaryLoggerParameters(string? LogFile = null, IReadOnlyDictionary<string, string>? Parameters = null);
+public record BinaryLoggerParameters(
+    string? LogFile = null, 
+    ProjectImportsMode? ProjectImports = null,
+    LoggerVerbosity? Verbosity = null,
+    IReadOnlyDictionary<string, string>? Parameters = null);
+
+/// <summary>
+/// Represents how the binary logger should handle project imports.
+/// </summary>
+public enum ProjectImportsMode
+{
+    /// <summary>
+    /// Don't collect the project imports.
+    /// </summary>
+    None,
+    /// <summary>
+    /// Embed project imports in the log file (default).
+    /// </summary>
+    Embed,
+    /// <summary>
+    /// Save project files to {output}.projectimports.zip.
+    /// </summary>
+    ZipFile
+}
diff --git a/src/Cli/dotnet/LoggerUtility.cs b/src/Cli/dotnet/LoggerUtility.cs
index 0210c47c02f5..92361beaeb06 100644
--- a/src/Cli/dotnet/LoggerUtility.cs
+++ b/src/Cli/dotnet/LoggerUtility.cs
@@ -8,6 +8,63 @@ namespace Microsoft.DotNet.Cli;
 
 internal static class LoggerUtility
 {
+    public static FacadeLogger? CreateBinaryLogger(BinaryLoggerOptions? options, string verb)
+    {
+        if (options == null)
+        {
+            return null;
+        }
+
+        List<BinaryLogger> binaryLoggers = [];
+        var parsedParams = options.ParseParameters();
+
+        string filename;
+        if (!string.IsNullOrEmpty(parsedParams.LogFile))
+        {
+            filename = parsedParams.LogFile;
+            if (filename.EndsWith(".binlog"))
+            {
+                filename = filename.Substring(0, filename.Length - ".binlog".Length);
+                filename = $"{filename}-{verb}.binlog";
+            }
+        }
+        else
+        {
+            // Default filename when no specific file is provided
+            filename = $"msbuild-{verb}.binlog";
+        }
+
+        // Build the parameters string for the BinaryLogger
+        var parametersList = new List<string> { filename };
+        
+        // Add ProjectImports parameter if specified
+        if (parsedParams.ProjectImports.HasValue)
+        {
+            parametersList.Add($"ProjectImports={parsedParams.ProjectImports.Value}");
+        }
+        
+        // Add Verbosity parameter if specified
+        if (parsedParams.Verbosity.HasValue)
+        {
+            parametersList.Add($"Verbosity={parsedParams.Verbosity.Value}");
+        }
+        
+        // Add any additional parameters
+        if (parsedParams.Parameters != null)
+        {
+            foreach (var kvp in parsedParams.Parameters)
+            {
+                parametersList.Add($"{kvp.Key}={kvp.Value}");
+            }
+        }
+
+        string parameters = string.Join(";", parametersList);
+        binaryLoggers.Add(new BinaryLogger { Parameters = parameters });
+
+        // Create the facade logger
+        return CreateFacadeLogger(binaryLoggers);
+    }
+
     public static FacadeLogger? DetermineBinlogger(string[] restoreArgs, string verb)
     {
         List<BinaryLogger> binaryLoggers = [];

From 72326b3b5eb4fb2914aaa60d6f6edd89534d0b37 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 6 Aug 2025 20:34:56 +0000
Subject: [PATCH 7/7] Eliminate BinaryLoggerOptions record and use
 BinaryLoggerParameters directly throughout codebase

Co-authored-by: baronfel <573979+baronfel@users.noreply.github.com>
---
 .../CommandLine/CommandLineOptions.cs         |  15 +-
 .../dotnet/Commands/Run/Api/RunApiCommand.cs  |   2 +-
 src/Cli/dotnet/Commands/Run/RunCommand.cs     |  12 +-
 .../dotnet/Commands/Test/MSBuildUtility.cs    |  10 +-
 src/Cli/dotnet/Commands/Test/Options.cs       |   2 +-
 src/Cli/dotnet/CommonOptions.cs               | 200 ++++++++----------
 src/Cli/dotnet/LoggerUtility.cs               |  25 ++-
 7 files changed, 126 insertions(+), 140 deletions(-)

diff --git a/src/BuiltInTools/dotnet-watch/CommandLine/CommandLineOptions.cs b/src/BuiltInTools/dotnet-watch/CommandLine/CommandLineOptions.cs
index e18827e930ca..fcdcf705378d 100644
--- a/src/BuiltInTools/dotnet-watch/CommandLine/CommandLineOptions.cs
+++ b/src/BuiltInTools/dotnet-watch/CommandLine/CommandLineOptions.cs
@@ -160,7 +160,7 @@ internal sealed class CommandLineOptions
         var buildArguments = buildOptions.Select(option => ((IForwardedOption)option).GetForwardingFunction()(parseResult)).SelectMany(args => args).ToList();
 
         var targetFrameworkOption = (Option<string>?)buildOptions.SingleOrDefault(option => option.Name == "--framework");
-        var binaryLoggerOption = (Option<BinaryLoggerOptions?>?)buildOptions.SingleOrDefault(option => option.Name == "--binaryLogger");
+        var binaryLoggerOption = (Option<BinaryLoggerParameters?>?)buildOptions.SingleOrDefault(option => option.Name == "--binaryLogger");
         var binaryLoggerOptions = binaryLoggerOption != null ? parseResult.GetValue(binaryLoggerOption) : null;
 
         return new()
@@ -189,19 +189,18 @@ internal sealed class CommandLineOptions
     /// <summary>
     /// Gets the binary log file path from the binary logger options.
     /// </summary>
-    internal static string? GetBinaryLogFilePath(BinaryLoggerOptions? options)
+    internal static string? GetBinaryLogFilePath(BinaryLoggerParameters? parameters)
     {
-        if (options == null)
+        if (parameters == null)
         {
             return null;
         }
 
-        var parsedParams = options.ParseParameters();
-        if (!string.IsNullOrEmpty(parsedParams.LogFile))
+        if (!string.IsNullOrEmpty(parameters.LogFile))
         {
-            return parsedParams.LogFile.EndsWith(".binlog", StringComparison.OrdinalIgnoreCase) 
-                ? parsedParams.LogFile 
-                : $"{parsedParams.LogFile}.binlog";
+            return parameters.LogFile.EndsWith(".binlog", StringComparison.OrdinalIgnoreCase) 
+                ? parameters.LogFile 
+                : $"{parameters.LogFile}.binlog";
         }
 
         return "msbuild.binlog";
diff --git a/src/Cli/dotnet/Commands/Run/Api/RunApiCommand.cs b/src/Cli/dotnet/Commands/Run/Api/RunApiCommand.cs
index fc416658ad01..4e9262db0b16 100644
--- a/src/Cli/dotnet/Commands/Run/Api/RunApiCommand.cs
+++ b/src/Cli/dotnet/Commands/Run/Api/RunApiCommand.cs
@@ -109,7 +109,7 @@ public override RunApiOutput Execute()
                 readCodeFromStdin: false,
                 environmentVariables: ReadOnlyDictionary<string, string>.Empty,
                 msbuildRestoreProperties: ReadOnlyDictionary<string, string>.Empty,
-                binaryLoggerOptions: null);
+                binaryLoggerParameters: null);
 
             runCommand.TryGetLaunchProfileSettingsIfNeeded(out var launchSettings);
             var targetCommand = (Utils.Command)runCommand.GetTargetCommand(buildCommand.CreateProjectInstance);
diff --git a/src/Cli/dotnet/Commands/Run/RunCommand.cs b/src/Cli/dotnet/Commands/Run/RunCommand.cs
index b92f0640bbc2..261161856dbc 100644
--- a/src/Cli/dotnet/Commands/Run/RunCommand.cs
+++ b/src/Cli/dotnet/Commands/Run/RunCommand.cs
@@ -47,9 +47,9 @@ public class RunCommand
     public ReadOnlyDictionary<string, string>? RestoreProperties { get; }
 
     /// <summary>
-    /// Binary logger options, if specified on the command line.
+    /// Binary logger parameters, if specified on the command line.
     /// </summary>
-    public BinaryLoggerOptions? BinaryLoggerOptions { get; }
+    public BinaryLoggerParameters? BinaryLoggerParameters { get; }
 
     /// <summary>
     /// unparsed/arbitrary CLI tokens to be passed to the running application
@@ -95,7 +95,7 @@ public RunCommand(
         bool readCodeFromStdin,
         IReadOnlyDictionary<string, string> environmentVariables,
         ReadOnlyDictionary<string, string>? msbuildRestoreProperties,
-        BinaryLoggerOptions? binaryLoggerOptions)
+        BinaryLoggerParameters? binaryLoggerParameters)
     {
         Debug.Assert(projectFileFullPath is null ^ entryPointFileFullPath is null);
         Debug.Assert(!readCodeFromStdin || entryPointFileFullPath is not null);
@@ -114,7 +114,7 @@ public RunCommand(
         MSBuildArgs = SetupSilentBuildArgs(msbuildArgs);
         EnvironmentVariables = environmentVariables;
         RestoreProperties = msbuildRestoreProperties;
-        BinaryLoggerOptions = binaryLoggerOptions;
+        BinaryLoggerParameters = binaryLoggerParameters;
     }
 
     public int Execute()
@@ -363,7 +363,7 @@ internal ICommand GetTargetCommand(Func<ProjectCollection, ProjectInstance>? pro
             return CreateCommandForCscBuiltProgram(EntryPointFileFullPath);
         }
 
-        FacadeLogger? logger = LoggerUtility.CreateBinaryLogger(BinaryLoggerOptions, "dotnet-run");
+        FacadeLogger? logger = LoggerUtility.CreateBinaryLogger(BinaryLoggerParameters, "dotnet-run");
         var project = EvaluateProject(ProjectFileFullPath, projectFactory, MSBuildArgs, logger);
         ValidatePreconditions(project);
         InvokeRunArgumentsTarget(project, NoBuild, logger, MSBuildArgs);
@@ -683,7 +683,7 @@ public static RunCommand FromParseResult(ParseResult parseResult)
             readCodeFromStdin: readCodeFromStdin,
             environmentVariables: parseResult.GetValue(CommonOptions.EnvOption) ?? ImmutableDictionary<string, string>.Empty,
             msbuildRestoreProperties: parseResult.GetValue(CommonOptions.RestorePropertiesOption),
-            binaryLoggerOptions: parseResult.GetValue(CommonOptions.BinaryLoggerOption)
+            binaryLoggerParameters: parseResult.GetValue(CommonOptions.BinaryLoggerOption)
         );
 
         return command;
diff --git a/src/Cli/dotnet/Commands/Test/MSBuildUtility.cs b/src/Cli/dotnet/Commands/Test/MSBuildUtility.cs
index b6a648ec8b41..764ab18aad25 100644
--- a/src/Cli/dotnet/Commands/Test/MSBuildUtility.cs
+++ b/src/Cli/dotnet/Commands/Test/MSBuildUtility.cs
@@ -32,7 +32,7 @@ public static (IEnumerable<ParallelizableTestModuleGroupWithSequentialInnerModul
                 Path.GetDirectoryName(solutionModel.Description)! :
                 SolutionAndProjectUtility.GetRootDirectory(solutionFilePath);
 
-        FacadeLogger? logger = LoggerUtility.CreateBinaryLogger(buildOptions.BinaryLoggerOptions, dotnetTestVerb);
+        FacadeLogger? logger = LoggerUtility.CreateBinaryLogger(buildOptions.BinaryLoggerParameters, dotnetTestVerb);
         var collection = new ProjectCollection(globalProperties: CommonRunHelpers.GetGlobalPropertiesFromArgs([.. buildOptions.MSBuildArgs]), loggers: logger is null ? null : [logger], toolsetDefinitionLocations: ToolsetDefinitionLocations.Default);
 
         ConcurrentBag<ParallelizableTestModuleGroupWithSequentialInnerModules> projects = GetProjectsProperties(collection, solutionModel.SolutionProjects.Select(p => Path.Combine(rootDirectory, p.FilePath)), buildOptions);
@@ -50,7 +50,7 @@ public static (IEnumerable<ParallelizableTestModuleGroupWithSequentialInnerModul
             return (Array.Empty<ParallelizableTestModuleGroupWithSequentialInnerModules>(), isBuiltOrRestored);
         }
 
-        FacadeLogger? logger = LoggerUtility.CreateBinaryLogger(buildOptions.BinaryLoggerOptions, dotnetTestVerb);
+        FacadeLogger? logger = LoggerUtility.CreateBinaryLogger(buildOptions.BinaryLoggerParameters, dotnetTestVerb);
         var collection = new ProjectCollection(globalProperties: CommonRunHelpers.GetGlobalPropertiesFromArgs([.. buildOptions.MSBuildArgs]), logger is null ? null : [logger], toolsetDefinitionLocations: ToolsetDefinitionLocations.Default);
 
         IEnumerable<ParallelizableTestModuleGroupWithSequentialInnerModules> projects = SolutionAndProjectUtility.GetProjectProperties(projectFilePath, collection, buildOptions.NoLaunchProfile);
@@ -71,8 +71,8 @@ public static BuildOptions GetBuildOptions(ParseResult parseResult, int degreeOf
             parseResult.GetValue(TestingPlatformOptions.SolutionOption),
             parseResult.GetValue(TestingPlatformOptions.DirectoryOption));
 
-        // Get the binary logger options from the parse result
-        var binaryLoggerOptions = parseResult.GetValue(CommonOptions.BinaryLoggerOption);
+        // Get the binary logger parameters from the parse result
+        var binaryLoggerParameters = parseResult.GetValue(CommonOptions.BinaryLoggerOption);
 
         return new BuildOptions(
             pathOptions,
@@ -84,7 +84,7 @@ public static BuildOptions GetBuildOptions(ParseResult parseResult, int degreeOf
             degreeOfParallelism,
             otherArgs,
             msbuildArgs,
-            binaryLoggerOptions);
+            binaryLoggerParameters);
     }
 
     private static bool BuildOrRestoreProjectOrSolution(string filePath, BuildOptions buildOptions)
diff --git a/src/Cli/dotnet/Commands/Test/Options.cs b/src/Cli/dotnet/Commands/Test/Options.cs
index 5b09f44721e4..cc7a72903651 100644
--- a/src/Cli/dotnet/Commands/Test/Options.cs
+++ b/src/Cli/dotnet/Commands/Test/Options.cs
@@ -19,4 +19,4 @@ internal record BuildOptions(
     int DegreeOfParallelism, 
     List<string> UnmatchedTokens,
     IEnumerable<string> MSBuildArgs,
-    BinaryLoggerOptions? BinaryLoggerOptions);
+    BinaryLoggerParameters? BinaryLoggerParameters);
diff --git a/src/Cli/dotnet/CommonOptions.cs b/src/Cli/dotnet/CommonOptions.cs
index cecb42078778..6f3549787eb3 100644
--- a/src/Cli/dotnet/CommonOptions.cs
+++ b/src/Cli/dotnet/CommonOptions.cs
@@ -48,39 +48,116 @@ internal static class CommonOptions
         .ForwardAsMSBuildProperty()
         .AllowSingleArgPerToken();
 
-    public static Option<BinaryLoggerOptions?> BinaryLoggerOption =
-        new ForwardedOption<BinaryLoggerOptions?>("--binaryLogger", "-binaryLogger", "/binaryLogger", "-bl", "--bl", "/bl")
+    public static Option<BinaryLoggerParameters?> BinaryLoggerOption =
+        new ForwardedOption<BinaryLoggerParameters?>("--binaryLogger", "-binaryLogger", "/binaryLogger", "-bl", "--bl", "/bl")
         {
             Description = "Log all build output to a binary log file. Optionally specify a file path and optional parameters.",
             HelpName = "PATH",
             Arity = ArgumentArity.ZeroOrOne,
             Hidden = true,
-            CustomParser = ParseBinaryLoggerOptions
+            CustomParser = ParseBinaryLoggerParameters
         }
-        .SetForwardingFunction(ForwardBinaryLoggerOptions)
+        .SetForwardingFunction(ForwardBinaryLoggerParameters)
         .AllowSingleArgPerToken();
 
-    private static BinaryLoggerOptions? ParseBinaryLoggerOptions(ArgumentResult result)
+    private static BinaryLoggerParameters? ParseBinaryLoggerParameters(ArgumentResult result)
     {
         if (result.Tokens.Count == 0)
         {
             // Flag form (e.g., -bl without parameters)
-            return new BinaryLoggerOptions(null, null);
+            return new BinaryLoggerParameters();
         }
 
         if (result.Tokens.Count == 1)
         {
             // Parameter form (e.g., -bl:file.binlog or -bl file.binlog)
             var argumentValue = result.Tokens[0].Value;
-            return new BinaryLoggerOptions(null, argumentValue);
+            return ParseBinaryLoggerArgumentString(argumentValue);
         }
 
         return null;
     }
 
-    private static IEnumerable<string> ForwardBinaryLoggerOptions(BinaryLoggerOptions? options, ParseResult parseResult)
+    private static BinaryLoggerParameters ParseBinaryLoggerArgumentString(string arguments)
+    {
+        if (string.IsNullOrEmpty(arguments))
+        {
+            return new BinaryLoggerParameters();
+        }
+
+        var parts = arguments.Split(';');
+        string? logFile = null;
+        ProjectImportsMode? projectImports = null;
+        LoggerVerbosity? verbosity = null;
+        var parameters = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+        
+        // Parse each part
+        for (int i = 0; i < parts.Length; i++)
+        {
+            var part = parts[i].Trim();
+            if (string.IsNullOrEmpty(part))
+                continue;
+
+            var equalIndex = part.IndexOf('=');
+            
+            if (equalIndex > 0)
+            {
+                // keyword=value format
+                string key = part.Substring(0, equalIndex).Trim();
+                string value = part.Substring(equalIndex + 1).Trim();
+
+                switch (key.ToLowerInvariant())
+                {
+                    case "logfile":
+                        logFile = value;
+                        break;
+                    case "projectimports":
+                        if (Enum.TryParse<ProjectImportsMode>(value, ignoreCase: true, out var importMode))
+                        {
+                            projectImports = importMode;
+                        }
+                        else
+                        {
+                            parameters[key] = value;
+                        }
+                        break;
+                    case "verbosity":
+                        if (Enum.TryParse<LoggerVerbosity>(value, ignoreCase: true, out var verb))
+                        {
+                            verbosity = verb;
+                        }
+                        else
+                        {
+                            parameters[key] = value;
+                        }
+                        break;
+                    default:
+                        parameters[key] = value;
+                        break;
+                }
+            }
+            else if (i == 0)
+            {
+                // First part without '=' is treated as the log file
+                logFile = part;
+            }
+            else
+            {
+                // Treat as a parameter with empty value
+                parameters[part] = "";
+            }
+        }
+
+        return new BinaryLoggerParameters(
+            logFile, 
+            projectImports, 
+            verbosity, 
+            parameters.Count > 0 ? parameters : null);
+    }
+
+    private static IEnumerable<string> ForwardBinaryLoggerParameters(BinaryLoggerParameters? parameters, ParseResult parseResult)
     {
-        if (options == null)
+        if (parameters == null)
         {
             return [];
         }
@@ -99,16 +176,20 @@ private static IEnumerable<string> ForwardBinaryLoggerOptions(BinaryLoggerOption
             originalToken = optionResult.IdentifierToken.Value;
         }
 
-        if (options.Arguments == null)
+        // Check if it's flag form (no arguments) or parameter form
+        if (optionResult.Tokens.Count == 0)
         {
             // Flag form: forward just the original token
             return [originalToken];
         }
-        else
+        else if (optionResult.Tokens.Count == 1)
         {
-            // Parameter form: forward with colon syntax
-            return [$"{originalToken}:{options.Arguments}"];
+            // Parameter form: forward with colon syntax using the original argument
+            var originalArguments = optionResult.Tokens[0].Value;
+            return [$"{originalToken}:{originalArguments}"];
         }
+
+        return [];
     }
 
     private static ReadOnlyDictionary<string, string>? ParseMSBuildTokensIntoDictionary(ArgumentResult result)
@@ -543,99 +624,6 @@ public class DynamicArgument<T>(string name) : Argument<T>(name), IDynamicArgume
 {
 }
 
-/// <summary>
-/// Represents the parsed binary logger options for MSBuild.
-/// </summary>
-/// <param name="OriginalToken">The original command-line token used (determined from ParseResult), or null if not available</param>
-/// <param name="Arguments">The arguments part of the binary logger option, or null if none specified</param>
-public record BinaryLoggerOptions(string? OriginalToken, string? Arguments)
-{
-    /// <summary>
-    /// Parses the arguments into structured binary logger parameters.
-    /// Supports the full MSBuild format: [LogFile=]filename[;keyword=value]*
-    /// Examples:
-    /// - "output.binlog" -> LogFile = "output.binlog"
-    /// - "output.binlog;ProjectImports=None" -> LogFile = "output.binlog", ProjectImports = None
-    /// - "LogFile=output.binlog;ProjectImports=ZipFile" -> LogFile = "output.binlog", ProjectImports = ZipFile
-    /// </summary>
-    public BinaryLoggerParameters ParseParameters()
-    {
-        if (string.IsNullOrEmpty(Arguments))
-        {
-            return new BinaryLoggerParameters();
-        }
-
-        var parts = Arguments.Split(';');
-        string? logFile = null;
-        ProjectImportsMode? projectImports = null;
-        LoggerVerbosity? verbosity = null;
-        var parameters = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
-        
-        // Parse each part
-        for (int i = 0; i < parts.Length; i++)
-        {
-            var part = parts[i].Trim();
-            if (string.IsNullOrEmpty(part))
-                continue;
-
-            var equalIndex = part.IndexOf('=');
-            
-            if (equalIndex > 0)
-            {
-                // keyword=value format
-                string key = part.Substring(0, equalIndex).Trim();
-                string value = part.Substring(equalIndex + 1).Trim();
-
-                switch (key.ToLowerInvariant())
-                {
-                    case "logfile":
-                        logFile = value;
-                        break;
-                    case "projectimports":
-                        if (Enum.TryParse<ProjectImportsMode>(value, ignoreCase: true, out var importMode))
-                        {
-                            projectImports = importMode;
-                        }
-                        else
-                        {
-                            parameters[key] = value;
-                        }
-                        break;
-                    case "verbosity":
-                        if (Enum.TryParse<LoggerVerbosity>(value, ignoreCase: true, out var verb))
-                        {
-                            verbosity = verb;
-                        }
-                        else
-                        {
-                            parameters[key] = value;
-                        }
-                        break;
-                    default:
-                        parameters[key] = value;
-                        break;
-                }
-            }
-            else if (i == 0)
-            {
-                // First part without '=' is treated as the log file
-                logFile = part;
-            }
-            else
-            {
-                // Treat as a parameter with empty value
-                parameters[part] = "";
-            }
-        }
-
-        return new BinaryLoggerParameters(
-            logFile, 
-            projectImports, 
-            verbosity, 
-            parameters.Count > 0 ? parameters : null);
-    }
-}
-
 /// <summary>
 /// Represents the structured parameters for binary logging.
 /// </summary>
diff --git a/src/Cli/dotnet/LoggerUtility.cs b/src/Cli/dotnet/LoggerUtility.cs
index 92361beaeb06..1b31dc6419cd 100644
--- a/src/Cli/dotnet/LoggerUtility.cs
+++ b/src/Cli/dotnet/LoggerUtility.cs
@@ -8,20 +8,19 @@ namespace Microsoft.DotNet.Cli;
 
 internal static class LoggerUtility
 {
-    public static FacadeLogger? CreateBinaryLogger(BinaryLoggerOptions? options, string verb)
+    public static FacadeLogger? CreateBinaryLogger(BinaryLoggerParameters? parameters, string verb)
     {
-        if (options == null)
+        if (parameters == null)
         {
             return null;
         }
 
         List<BinaryLogger> binaryLoggers = [];
-        var parsedParams = options.ParseParameters();
 
         string filename;
-        if (!string.IsNullOrEmpty(parsedParams.LogFile))
+        if (!string.IsNullOrEmpty(parameters.LogFile))
         {
-            filename = parsedParams.LogFile;
+            filename = parameters.LogFile;
             if (filename.EndsWith(".binlog"))
             {
                 filename = filename.Substring(0, filename.Length - ".binlog".Length);
@@ -38,28 +37,28 @@ internal static class LoggerUtility
         var parametersList = new List<string> { filename };
         
         // Add ProjectImports parameter if specified
-        if (parsedParams.ProjectImports.HasValue)
+        if (parameters.ProjectImports.HasValue)
         {
-            parametersList.Add($"ProjectImports={parsedParams.ProjectImports.Value}");
+            parametersList.Add($"ProjectImports={parameters.ProjectImports.Value}");
         }
         
         // Add Verbosity parameter if specified
-        if (parsedParams.Verbosity.HasValue)
+        if (parameters.Verbosity.HasValue)
         {
-            parametersList.Add($"Verbosity={parsedParams.Verbosity.Value}");
+            parametersList.Add($"Verbosity={parameters.Verbosity.Value}");
         }
         
         // Add any additional parameters
-        if (parsedParams.Parameters != null)
+        if (parameters.Parameters != null)
         {
-            foreach (var kvp in parsedParams.Parameters)
+            foreach (var kvp in parameters.Parameters)
             {
                 parametersList.Add($"{kvp.Key}={kvp.Value}");
             }
         }
 
-        string parameters = string.Join(";", parametersList);
-        binaryLoggers.Add(new BinaryLogger { Parameters = parameters });
+        string parameterString = string.Join(";", parametersList);
+        binaryLoggers.Add(new BinaryLogger { Parameters = parameterString });
 
         // Create the facade logger
         return CreateFacadeLogger(binaryLoggers);