$(String[] args) in S:\t\ConsoleApp81\ConsoleApp81\Program.cs:line 9' + Match match = s_regex.Match(stackFrame); + + line = 0; + file = null; + place = null; + + if (match.Success) + { + // get the exact info from stack frame. + place = match.Groups["code"].Value; + file = match.Groups["file"].Value; + _ = int.TryParse(match.Groups["line"].Value, out line); + } + + return match.Success; + } + + [MemberNotNull(nameof(s_regex))] + private static void InitializeRegex() + { + if (s_regex != null) + { + return; + } + + string atResourceName = "Word_At"; + string inResourceName = "StackTrace_InFileLineNumber"; + + string? atString = null; + string? inString = null; + + // Grab words from localized resource, in case the stack trace is localized. + try + { + // Get these resources: https://github.com/dotnet/runtime/blob/main/src/libraries/System.Private.CoreLib/src/Resources/Strings.resx + MethodInfo? getResourceStringMethod = typeof(Environment).GetMethod("GetResourceString", BindingFlags.Static | BindingFlags.NonPublic, null, [typeof(string)], null); + if (getResourceStringMethod is not null) + { + // at + atString = (string?)getResourceStringMethod.Invoke(null, [atResourceName]); + + // in {0}:line {1} + inString = (string?)getResourceStringMethod.Invoke(null, [inResourceName]); + } + } + catch + { + // If we fail, populate the defaults below. + } + + atString = atString == null || atString == atResourceName ? "at" : atString; + inString = inString == null || inString == inResourceName ? "in {0}:line {1}" : inString; + + string inPattern = string.Format(CultureInfo.InvariantCulture, inString, "(?.+)", @"(?\d+)"); + + s_regex = new Regex(@$"^ {atString} (?
.+) {inPattern}$", RegexOptions.Compiled, matchTimeout: TimeSpan.FromSeconds(1));
+    }
+}
diff --git a/src/Platform/Microsoft.Testing.Platform.MSBuild/Tasks/TestingPlatformEntryPointTask.cs b/src/Platform/Microsoft.Testing.Platform.MSBuild/Tasks/TestingPlatformEntryPointTask.cs
new file mode 100644
index 0000000000..608298f4d7
--- /dev/null
+++ b/src/Platform/Microsoft.Testing.Platform.MSBuild/Tasks/TestingPlatformEntryPointTask.cs
@@ -0,0 +1,243 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+#pragma warning disable CS8618 // Properties below are set by MSBuild.
+
+using System.Globalization;
+using System.Text;
+
+using Microsoft.Build.Framework;
+using Microsoft.Build.Utilities;
+
+namespace Microsoft.Testing.Platform.MSBuild;
+
+public sealed class TestingPlatformEntryPointTask : Build.Utilities.Task
+{
+    private const string DisplayNameMetadataName = "DisplayName";
+    private const string TypeFullNameMetadataName = "TypeFullName";
+    private const string WellKnownBuilderHookMicrosoftTestingExtensionsTrx = "2006B3F7-93D2-4D9C-9C69-F41A1F21C9C7";
+    private const string CSharpLanguageSymbol = "C#";
+    private const string FSharpLanguageSymbol = "F#";
+    private const string VBLanguageSymbol = "VB";
+
+    public TestingPlatformEntryPointTask()
+        : this(new FileSystem())
+    {
+    }
+
+    internal TestingPlatformEntryPointTask(IFileSystem fileSystem)
+    {
+        _fileSystem = fileSystem;
+    }
+
+    [Required]
+    public ITaskItem TestingPlatformEntryPointSourcePath { get; set; }
+
+    [Required]
+    public ITaskItem Language { get; set; }
+
+    [Required]
+    public ITaskItem[] TestingPlatformBuilderHooks { get; set; }
+
+    [Output]
+    public ITaskItem TestingPlatformEntryPointGeneratedFilePath { get; set; }
+
+    private readonly string _expectedItemSpec = """
+Expected item spec:
+
+    
+    
+        
+        MyBuilderHook
+        
+        Contoso.BuilderHook
+    
+
+Expected method signature
+static Contoso.BuilderHook.AddExtensions(Microsoft.Testing.Platform.Builder.TestApplicationBuilder builder, string[] args)
+""";
+
+    private readonly IFileSystem _fileSystem;
+
+    public override bool Execute()
+    {
+        Log.LogMessage(MessageImportance.Normal, $"TestingPlatformEntryPointSourcePath: '{TestingPlatformEntryPointSourcePath.ItemSpec}'");
+        Log.LogMessage(MessageImportance.Normal, $"Language: '{Language.ItemSpec}'");
+
+        if (TestingPlatformBuilderHooks.Length == 0)
+        {
+            Log.LogError("Zero TestingPlatformBuilderHook items found, add once or disable the testing platform entrypoint generation adding\nfalse\n{0}", _expectedItemSpec);
+            return false;
+        }
+
+        if (TestingPlatformBuilderHooks.Length > 0)
+        {
+            StringBuilder stringBuilder = new();
+            stringBuilder.AppendLine("TestingPlatformExtensionFullTypeNames:");
+
+            // Distinct by ItemSpec and take the first one.
+            foreach (ITaskItem item in TestingPlatformBuilderHooks.GroupBy(x => x.ItemSpec).Select(x => x.First()))
+            {
+                if (string.IsNullOrEmpty(item.GetMetadata(DisplayNameMetadataName)))
+                {
+                    Log.LogError("Missing 'DisplayName' metadata for item 'TestingPlatformBuilderHook'\n{0}", _expectedItemSpec);
+                }
+
+                if (string.IsNullOrEmpty(item.GetMetadata(TypeFullNameMetadataName)))
+                {
+                    Log.LogError("Missing 'TypeFullName' metadata for item 'TestingPlatformBuilderHook'\n{0}", _expectedItemSpec);
+                }
+
+                stringBuilder.AppendLine(CultureInfo.InvariantCulture, $" Hook UID: '{item.ItemSpec}' DisplayName: '{item.GetMetadata(DisplayNameMetadataName)}' TypeFullName: '{item.GetMetadata(TypeFullNameMetadataName)}'");
+            }
+
+            Log.LogMessage(MessageImportance.Normal, stringBuilder.ToString());
+        }
+
+        if (!Log.HasLoggedErrors)
+        {
+            ITaskItem[] taskItems = Reorder(TestingPlatformBuilderHooks);
+
+            if (!Language.ItemSpec.Equals(CSharpLanguageSymbol, StringComparison.OrdinalIgnoreCase) &&
+                !Language.ItemSpec.Equals(VBLanguageSymbol, StringComparison.OrdinalIgnoreCase) &&
+                !Language.ItemSpec.Equals(FSharpLanguageSymbol, StringComparison.OrdinalIgnoreCase))
+            {
+                TestingPlatformEntryPointGeneratedFilePath = default!;
+                Log.LogError($"Language '{Language.ItemSpec}' is not supported.");
+            }
+            else
+            {
+                GenerateEntryPoint(Language.ItemSpec, taskItems, TestingPlatformEntryPointSourcePath, _fileSystem, Log);
+                TestingPlatformEntryPointGeneratedFilePath = TestingPlatformEntryPointSourcePath;
+            }
+        }
+
+        return !Log.HasLoggedErrors;
+    }
+
+    private static ITaskItem[] Reorder(ITaskItem[] items)
+    {
+        List result = new(items.Length);
+        int wellKnownBuilderHook_MicrosoftTestingPlatformExtensions_index = -1;
+        for (int i = 0; i < items.Length; i++)
+        {
+            if (items[i].ItemSpec == WellKnownBuilderHookMicrosoftTestingExtensionsTrx)
+            {
+                wellKnownBuilderHook_MicrosoftTestingPlatformExtensions_index = i;
+                continue;
+            }
+
+            result.Add(items[i]);
+        }
+
+        if (wellKnownBuilderHook_MicrosoftTestingPlatformExtensions_index != -1)
+        {
+            result.Add(items[wellKnownBuilderHook_MicrosoftTestingPlatformExtensions_index]);
+        }
+
+        return result.ToArray();
+    }
+
+    private static void GenerateEntryPoint(string language, ITaskItem[] taskItems, ITaskItem testingPlatformEntryPointSourcePath, IFileSystem fileSystem, TaskLoggingHelper taskLoggingHelper)
+    {
+        StringBuilder builder = new();
+
+        for (int i = 0; i < taskItems.Length; i++)
+        {
+            if (i != 0)
+            {
+                // Indent
+                builder.Append("        ");
+            }
+
+            builder.Append(CultureInfo.InvariantCulture, $"{taskItems[i].GetMetadata(TypeFullNameMetadataName)}.AddExtensions(builder, args){(language == CSharpLanguageSymbol ? ";" : string.Empty)}");
+            if (i < taskItems.Length - 1)
+            {
+                builder.AppendLine();
+            }
+        }
+
+        string entryPointSource = GetEntryPointSourceCode(language, builder.ToString());
+        taskLoggingHelper.LogMessage(MessageImportance.Normal, $"Entrypoint source:\n'{entryPointSource}'");
+        fileSystem.WriteAllText(testingPlatformEntryPointSourcePath.ItemSpec, entryPointSource);
+    }
+
+    private static string GetEntryPointSourceCode(string language, string extensionsFragments)
+    {
+        if (language == CSharpLanguageSymbol)
+        {
+            return $$"""
+//------------------------------------------------------------------------------
+// 
+//     This code was generated by Microsoft.Testing.Platform.MSBuild
+// 
+//------------------------------------------------------------------------------
+
+[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+internal sealed class TestingPlatformEntryPoint
+{
+    public static async global::System.Threading.Tasks.Task Main(string[] args)
+    {
+        global::Microsoft.Testing.Platform.Builder.ITestApplicationBuilder builder = await global::Microsoft.Testing.Platform.Builder.TestApplication.CreateBuilderAsync(args);
+        {{extensionsFragments}}
+        using (global::Microsoft.Testing.Platform.Builder.ITestApplication app = await builder.BuildAsync())
+        {
+            return await app.RunAsync();
+        }
+    }
+}
+""";
+        }
+        else if (language == VBLanguageSymbol)
+        {
+            return $$"""
+'------------------------------------------------------------------------------
+' 
+'     This code was generated by Microsoft.Testing.Platform.MSBuild
+' 
+'------------------------------------------------------------------------------
+
+
+Module TestingPlatformEntryPoint
+
+    Function Main(args As Global.System.String()) As Global.System.Int32
+        Return MainAsync(args).Result
+    End Function
+
+    Public Async Function MainAsync(ByVal args() As Global.System.String) As Global.System.Threading.Tasks.Task(Of Integer)
+        Dim builder = Await Global.Microsoft.Testing.Platform.Builder.TestApplication.CreateBuilderAsync(args)
+        {{extensionsFragments}}
+        Using testApplication = Await builder.BuildAsync()
+            Return Await testApplication.RunAsync()
+        End Using
+    End Function
+
+End Module
+""";
+        }
+        else if (language == FSharpLanguageSymbol)
+        {
+            return $$"""
+//------------------------------------------------------------------------------
+// 
+//     This code was generated by Microsoft.Testing.Platform.MSBuild
+// 
+//------------------------------------------------------------------------------
+
+[]
+[]
+let main args =
+    task {
+        let! builder = Microsoft.Testing.Platform.Builder.TestApplication.CreateBuilderAsync args
+        {{extensionsFragments}}
+        use! app = builder.BuildAsync()
+        return! app.RunAsync()
+    }
+    |> Async.AwaitTask
+    |> Async.RunSynchronously
+""";
+        }
+
+        throw new InvalidOperationException($"Language not supported '{language}'");
+    }
+}
diff --git a/src/Platform/Microsoft.Testing.Platform.MSBuild/TestPlatformExtensions/MSBuildCommandLine.cs b/src/Platform/Microsoft.Testing.Platform.MSBuild/TestPlatformExtensions/MSBuildCommandLine.cs
new file mode 100644
index 0000000000..b851811efd
--- /dev/null
+++ b/src/Platform/Microsoft.Testing.Platform.MSBuild/TestPlatformExtensions/MSBuildCommandLine.cs
@@ -0,0 +1,36 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using Microsoft.Testing.Platform.CommandLine;
+using Microsoft.Testing.Platform.Extensions;
+using Microsoft.Testing.Platform.Extensions.CommandLine;
+using Microsoft.Testing.Platform.Helpers;
+
+namespace Microsoft.Testing.Platform.MSBuild.TestPlatformExtensions;
+
+internal sealed class MSBuildCommandLineProvider : ICommandLineOptionsProvider
+{
+    public const string MSBuildNodeOptionKey = "internal-msbuild-node";
+
+    public string Uid => nameof(MSBuildCommandLineProvider);
+
+    public string Version => AppVersion.DefaultSemVer;
+
+    public string DisplayName => nameof(MSBuildCommandLineProvider);
+
+    public string Description => Resources.MSBuildResources.MSBuildExtensionsDescription;
+
+    public IReadOnlyCollection GetCommandLineOptions()
+        =>
+        [
+            new(MSBuildNodeOptionKey, "Used to pass the msbuild node handle", ArgumentArity.ExactlyOne, isHidden: true, isBuiltIn: true)
+        ];
+
+    public Task IsEnabledAsync() => Task.FromResult(true);
+
+    public Task ValidateCommandLineOptionsAsync(ICommandLineOptions commandLineOptions)
+        => ValidationResult.ValidTask;
+
+    public Task ValidateOptionArgumentsAsync(CommandLineOption commandOption, string[] arguments)
+        => ValidationResult.ValidTask;
+}
diff --git a/src/Platform/Microsoft.Testing.Platform.MSBuild/TestPlatformExtensions/MSBuildConsumer.cs b/src/Platform/Microsoft.Testing.Platform.MSBuild/TestPlatformExtensions/MSBuildConsumer.cs
new file mode 100644
index 0000000000..4181ba2cf6
--- /dev/null
+++ b/src/Platform/Microsoft.Testing.Platform.MSBuild/TestPlatformExtensions/MSBuildConsumer.cs
@@ -0,0 +1,228 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.Globalization;
+using System.Text;
+
+using Microsoft.Testing.Platform.CommandLine;
+using Microsoft.Testing.Platform.Extensions.Messages;
+using Microsoft.Testing.Platform.Extensions.TestHost;
+using Microsoft.Testing.Platform.Helpers;
+using Microsoft.Testing.Platform.IPC.Models;
+using Microsoft.Testing.Platform.MSBuild.TestPlatformExtensions.Serializers;
+using Microsoft.Testing.Platform.Services;
+using Microsoft.Testing.Platform.TestHost;
+
+namespace Microsoft.Testing.Platform.MSBuild.TestPlatformExtensions;
+
+internal class MSBuildConsumer : IDataConsumer, ITestSessionLifetimeHandler
+{
+    private readonly IServiceProvider _serviceProvider;
+    private readonly ICommandLineOptions _commandLineOptions;
+    private MSBuildTestApplicationLifecycleCallbacks? _msBuildTestApplicationLifecycleCallbacks;
+    private bool _sessionEnded;
+    private int _totalTests;
+    private int _totalFailedTests;
+    private int _totalPassedTests;
+    private int _totalSkippedTests;
+
+    public MSBuildConsumer(IServiceProvider serviceProvider, ICommandLineOptions commandLineOptions)
+    {
+        _serviceProvider = serviceProvider;
+        _commandLineOptions = commandLineOptions;
+    }
+
+    public Type[] DataTypesConsumed { get; } =
+    [
+        typeof(TestNodeUpdateMessage),
+        typeof(TestRequestExecutionTimeInfo),
+    ];
+
+    public string Uid => nameof(MSBuildConsumer);
+
+    public string Version => AppVersion.DefaultSemVer;
+
+    public string DisplayName => nameof(MSBuildConsumer);
+
+    public string Description => Resources.MSBuildResources.MSBuildExtensionsDescription;
+
+    public Task IsEnabledAsync()
+        => Task.FromResult(_commandLineOptions.IsOptionSet(MSBuildCommandLineProvider.MSBuildNodeOptionKey));
+
+    public Task OnTestSessionStartingAsync(SessionUid sessionUid, CancellationToken cancellationToken)
+    {
+        // We get the pipe from the MSBuildTestApplicationLifecycleCallbacks only if we're enabled.
+        _msBuildTestApplicationLifecycleCallbacks = _serviceProvider.GetRequiredService();
+        return Task.CompletedTask;
+    }
+
+    public Task OnTestSessionFinishingAsync(SessionUid sessionUid, CancellationToken cancellationToken)
+    {
+        _sessionEnded = true;
+        return Task.CompletedTask;
+    }
+
+    public async Task ConsumeAsync(IDataProducer dataProducer, IData value, CancellationToken cancellationToken)
+    {
+        if (cancellationToken.IsCancellationRequested)
+        {
+            return;
+        }
+
+        // Avoid processing messages if the session has ended.
+        if (_sessionEnded)
+        {
+            return;
+        }
+
+        switch (value)
+        {
+            case TestNodeUpdateMessage testNodeStateChanged:
+                TimingProperty? timingProperty = testNodeStateChanged.TestNode.Properties.SingleOrDefault();
+                string? duration = timingProperty is null ? null :
+                    ToHumanReadableDuration(timingProperty.GlobalTiming.Duration.TotalMilliseconds);
+
+                TestFileLocationProperty? testFileLocationProperty = testNodeStateChanged.TestNode.Properties.SingleOrDefault();
+
+                switch (testNodeStateChanged.TestNode.Properties.SingleOrDefault())
+                {
+                    case ErrorTestNodeStateProperty errorState:
+                        await HandleFailuresAsync(
+                            testNodeStateChanged.TestNode.DisplayName,
+                            isCancelled: false,
+                            duration: duration,
+                            errorMessage: errorState.Exception?.Message ?? errorState.Explanation,
+                            errorStackTrace: errorState.Exception?.StackTrace,
+                            expected: null,
+                            actual: null,
+                            testFileLocationProperty?.FilePath,
+                            testFileLocationProperty?.LineSpan.Start.Line ?? 0,
+                            cancellationToken);
+                        break;
+
+                    case FailedTestNodeStateProperty failedState:
+                        await HandleFailuresAsync(
+                            testNodeStateChanged.TestNode.DisplayName,
+                            isCancelled: false,
+                            duration: duration,
+                            errorMessage: failedState.Exception?.Message ?? failedState.Explanation,
+                            errorStackTrace: failedState.Exception?.StackTrace,
+                            expected: failedState.Exception?.Data["assert.expected"] as string,
+                            actual: failedState.Exception?.Data["assert.actual"] as string,
+                            testFileLocationProperty?.FilePath,
+                            testFileLocationProperty?.LineSpan.Start.Line ?? 0,
+                            cancellationToken);
+                        break;
+
+                    case TimeoutTestNodeStateProperty timeoutState:
+                        await HandleFailuresAsync(
+                            testNodeStateChanged.TestNode.DisplayName,
+                            isCancelled: true,
+                            duration: duration,
+                            errorMessage: timeoutState.Exception?.Message ?? timeoutState.Explanation,
+                            errorStackTrace: timeoutState.Exception?.StackTrace,
+                            expected: null,
+                            actual: null,
+                            testFileLocationProperty?.FilePath,
+                            testFileLocationProperty?.LineSpan.Start.Line ?? 0,
+                            cancellationToken);
+                        break;
+
+                    case CancelledTestNodeStateProperty cancelledState:
+                        await HandleFailuresAsync(
+                            testNodeStateChanged.TestNode.DisplayName,
+                            isCancelled: true,
+                            duration: duration,
+                            errorMessage: cancelledState.Exception?.Message ?? cancelledState.Explanation,
+                            errorStackTrace: cancelledState.Exception?.StackTrace,
+                            expected: null,
+                            actual: null,
+                            testFileLocationProperty?.FilePath,
+                            testFileLocationProperty?.LineSpan.Start.Line ?? 0,
+                            cancellationToken);
+                        break;
+
+                    case PassedTestNodeStateProperty:
+                        _totalTests++;
+                        _totalPassedTests++;
+                        break;
+
+                    case SkippedTestNodeStateProperty:
+                        _totalTests++;
+                        _totalSkippedTests++;
+                        break;
+                }
+
+                break;
+
+            case TestRequestExecutionTimeInfo testRequestExecutionTimeInfo:
+                await HandleSummaryAsync(testRequestExecutionTimeInfo, cancellationToken);
+
+                break;
+        }
+    }
+
+    private async Task HandleFailuresAsync(string testDisplayName, bool isCancelled, string? duration, string? errorMessage, string? errorStackTrace, string? expected, string? actual, string? codeFilePath, int lineNumber, CancellationToken cancellationToken)
+    {
+        _totalTests++;
+        _totalFailedTests++;
+        ApplicationStateGuard.Ensure(_msBuildTestApplicationLifecycleCallbacks != null);
+        ApplicationStateGuard.Ensure(_msBuildTestApplicationLifecycleCallbacks.PipeClient != null);
+        var failedTestInfoRequest = new FailedTestInfoRequest(testDisplayName, isCancelled, duration, errorMessage, errorStackTrace, expected, actual, codeFilePath, lineNumber);
+        await _msBuildTestApplicationLifecycleCallbacks.PipeClient.RequestReplyAsync(failedTestInfoRequest, cancellationToken);
+    }
+
+    private async Task HandleSummaryAsync(TestRequestExecutionTimeInfo timeInfo, CancellationToken cancellationToken)
+    {
+        string? duration = ToHumanReadableDuration(timeInfo.TimingInfo.Duration.TotalMilliseconds);
+
+        ApplicationStateGuard.Ensure(_msBuildTestApplicationLifecycleCallbacks != null);
+        ApplicationStateGuard.Ensure(_msBuildTestApplicationLifecycleCallbacks.PipeClient != null);
+        var runSummaryInfoRequest = new RunSummaryInfoRequest(_totalTests, _totalFailedTests, _totalPassedTests, _totalSkippedTests, duration);
+        await _msBuildTestApplicationLifecycleCallbacks.PipeClient.RequestReplyAsync(runSummaryInfoRequest, cancellationToken);
+    }
+
+    private static string? ToHumanReadableDuration(double? durationInMs)
+    {
+        if (durationInMs is null or < 0)
+        {
+            return null;
+        }
+
+        var time = TimeSpan.FromMilliseconds(durationInMs.Value);
+
+        StringBuilder stringBuilder = new();
+        bool hasParentValue = false;
+
+        if (time.Days > 0)
+        {
+            stringBuilder.Append(CultureInfo.InvariantCulture, $"{time.Days}d");
+            hasParentValue = true;
+        }
+
+        if (time.Hours > 0 || hasParentValue)
+        {
+            stringBuilder.Append(CultureInfo.InvariantCulture, $"{(hasParentValue ? " " : string.Empty)}{(hasParentValue ? time.Hours.ToString(CultureInfo.InvariantCulture).PadLeft(2, '0') : time.Hours.ToString(CultureInfo.InvariantCulture))}h");
+            hasParentValue = true;
+        }
+
+        if (time.Minutes > 0 || hasParentValue)
+        {
+            stringBuilder.Append(CultureInfo.InvariantCulture, $"{(hasParentValue ? " " : string.Empty)}{(hasParentValue ? time.Minutes.ToString(CultureInfo.InvariantCulture).PadLeft(2, '0') : time.Minutes.ToString(CultureInfo.InvariantCulture))}m");
+            hasParentValue = true;
+        }
+
+        if (time.Seconds > 0 || hasParentValue)
+        {
+            stringBuilder.Append(CultureInfo.InvariantCulture, $"{(hasParentValue ? " " : string.Empty)}{(hasParentValue ? time.Seconds.ToString(CultureInfo.InvariantCulture).PadLeft(2, '0') : time.Seconds.ToString(CultureInfo.InvariantCulture))}s");
+            hasParentValue = true;
+        }
+
+        if (time.Milliseconds >= 0 || hasParentValue)
+        {
+            stringBuilder.Append(CultureInfo.InvariantCulture, $"{(hasParentValue ? " " : string.Empty)}{(hasParentValue ? time.Milliseconds.ToString(CultureInfo.InvariantCulture).PadLeft(3, '0') : time.Milliseconds.ToString(CultureInfo.InvariantCulture))}ms");
+        }
+
+        return stringBuilder.ToString();
+    }
+}
diff --git a/src/Platform/Microsoft.Testing.Platform.MSBuild/TestPlatformExtensions/MSBuildExtensions.cs b/src/Platform/Microsoft.Testing.Platform.MSBuild/TestPlatformExtensions/MSBuildExtensions.cs
new file mode 100644
index 0000000000..a2421d5dee
--- /dev/null
+++ b/src/Platform/Microsoft.Testing.Platform.MSBuild/TestPlatformExtensions/MSBuildExtensions.cs
@@ -0,0 +1,30 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using Microsoft.Testing.Platform.Builder;
+using Microsoft.Testing.Platform.Extensions;
+using Microsoft.Testing.Platform.MSBuild.TestPlatformExtensions;
+using Microsoft.Testing.Platform.Services;
+
+namespace Microsoft.Testing.Platform.MSBuild;
+
+public static class MSBuildExtensions
+{
+    public static void AddMSBuild(this ITestApplicationBuilder builder)
+    {
+        builder.CommandLine.AddProvider(() => new MSBuildCommandLineProvider());
+        builder.TestHost.AddTestApplicationLifecycleCallbacks(
+            serviceProvider => new MSBuildTestApplicationLifecycleCallbacks(
+                serviceProvider.GetConfiguration(),
+                serviceProvider.GetCommandLineOptions(),
+                serviceProvider.GetTestApplicationCancellationTokenSource()));
+
+        CompositeExtensionFactory compositeExtensionFactory
+            = new(serviceProvider => new MSBuildConsumer(
+                serviceProvider,
+                serviceProvider.GetCommandLineOptions()));
+
+        builder.TestHost.AddDataConsumer(compositeExtensionFactory);
+        builder.TestHost.AddTestSessionLifetimeHandle(compositeExtensionFactory);
+    }
+}
diff --git a/src/Platform/Microsoft.Testing.Platform.MSBuild/TestPlatformExtensions/MSBuildTestApplicationLifecycleCallbacks.cs b/src/Platform/Microsoft.Testing.Platform.MSBuild/TestPlatformExtensions/MSBuildTestApplicationLifecycleCallbacks.cs
new file mode 100644
index 0000000000..73621c6f5f
--- /dev/null
+++ b/src/Platform/Microsoft.Testing.Platform.MSBuild/TestPlatformExtensions/MSBuildTestApplicationLifecycleCallbacks.cs
@@ -0,0 +1,80 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.Runtime.InteropServices;
+
+using Microsoft.Testing.Platform.CommandLine;
+using Microsoft.Testing.Platform.Configurations;
+using Microsoft.Testing.Platform.Extensions.TestHost;
+using Microsoft.Testing.Platform.Helpers;
+using Microsoft.Testing.Platform.IPC;
+using Microsoft.Testing.Platform.IPC.Models;
+using Microsoft.Testing.Platform.IPC.Serializers;
+using Microsoft.Testing.Platform.MSBuild.TestPlatformExtensions;
+using Microsoft.Testing.Platform.MSBuild.TestPlatformExtensions.Serializers;
+using Microsoft.Testing.Platform.Services;
+
+namespace Microsoft.Testing.Platform.MSBuild;
+
+internal class MSBuildTestApplicationLifecycleCallbacks : ITestApplicationLifecycleCallbacks, IDisposable
+{
+    private readonly IConfiguration _configuration;
+    private readonly ICommandLineOptions _commandLineOptions;
+    private readonly ITestApplicationCancellationTokenSource _testApplicationCancellationTokenSource;
+
+    public MSBuildTestApplicationLifecycleCallbacks(
+        IConfiguration configuration,
+        ICommandLineOptions commandLineOptions,
+        ITestApplicationCancellationTokenSource testApplicationCancellationTokenSource)
+    {
+        _configuration = configuration;
+        _commandLineOptions = commandLineOptions;
+        _testApplicationCancellationTokenSource = testApplicationCancellationTokenSource;
+    }
+
+    public NamedPipeClient? PipeClient { get; private set; }
+
+    public string Uid => nameof(MSBuildTestApplicationLifecycleCallbacks);
+
+    public string Version => AppVersion.DefaultSemVer;
+
+    public string DisplayName => nameof(MSBuildTestApplicationLifecycleCallbacks);
+
+    public string Description => Resources.MSBuildResources.MSBuildExtensionsDescription;
+
+    public Task IsEnabledAsync()
+        => Task.FromResult(_commandLineOptions.IsOptionSet(MSBuildCommandLineProvider.MSBuildNodeOptionKey));
+
+    public async Task BeforeRunAsync(CancellationToken cancellationToken)
+    {
+        if (!_commandLineOptions.TryGetOptionArgumentList(MSBuildCommandLineProvider.MSBuildNodeOptionKey, out string[]? msbuildInfo))
+        {
+            throw new InvalidOperationException($"MSBuild pipe name not found in the command line, missing {MSBuildCommandLineProvider.MSBuildNodeOptionKey}");
+        }
+
+        if (msbuildInfo is null || msbuildInfo.Length != 1 || string.IsNullOrEmpty(msbuildInfo[0]))
+        {
+            throw new InvalidOperationException($"MSBuild pipe name not found in the command line, missing argument for {MSBuildCommandLineProvider.MSBuildNodeOptionKey}");
+        }
+
+        PipeClient = new(msbuildInfo[0]);
+        PipeClient.RegisterSerializer(new ModuleInfoRequestSerializer(), typeof(ModuleInfoRequest));
+        PipeClient.RegisterSerializer(new VoidResponseSerializer(), typeof(VoidResponse));
+        PipeClient.RegisterSerializer(new FailedTestInfoRequestSerializer(), typeof(FailedTestInfoRequest));
+        PipeClient.RegisterSerializer(new RunSummaryInfoRequestSerializer(), typeof(RunSummaryInfoRequest));
+        using var cancellationTokenSource = new CancellationTokenSource(TimeoutHelper.DefaultHangTimeSpanTimeout);
+        using var linkedCancellationToken = CancellationTokenSource.CreateLinkedTokenSource(cancellationTokenSource.Token, _testApplicationCancellationTokenSource.CancellationToken);
+        await PipeClient.ConnectAsync(linkedCancellationToken.Token);
+        await PipeClient.RequestReplyAsync(
+            new ModuleInfoRequest(
+            RuntimeInformation.FrameworkDescription,
+            RuntimeInformation.ProcessArchitecture.ToString().ToLowerInvariant(),
+            _configuration.GetTestResultDirectory()),
+            _testApplicationCancellationTokenSource.CancellationToken);
+    }
+
+    public void Dispose()
+        => PipeClient?.Dispose();
+
+    public Task AfterRunAsync(int exitCode, CancellationToken cancellation) => Task.CompletedTask;
+}
diff --git a/src/Platform/Microsoft.Testing.Platform.MSBuild/TestPlatformExtensions/Serializers/FailedTestInfoRequestSerializer.cs b/src/Platform/Microsoft.Testing.Platform.MSBuild/TestPlatformExtensions/Serializers/FailedTestInfoRequestSerializer.cs
new file mode 100644
index 0000000000..9fa49a3859
--- /dev/null
+++ b/src/Platform/Microsoft.Testing.Platform.MSBuild/TestPlatformExtensions/Serializers/FailedTestInfoRequestSerializer.cs
@@ -0,0 +1,49 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using Microsoft.Testing.Platform.IPC;
+using Microsoft.Testing.Platform.IPC.Serializers;
+
+namespace Microsoft.Testing.Platform.MSBuild.TestPlatformExtensions.Serializers;
+
+internal record FailedTestInfoRequest(
+    string DisplayName,
+    bool IsCancelled,
+    string? Duration,
+    string? ErrorMessage,
+    string? ErrorStackTrace,
+    string? Expected,
+    string? Actual,
+    string? CodeFilePath,
+    int LineNumber) : IRequest;
+
+internal class FailedTestInfoRequestSerializer : BaseSerializer, INamedPipeSerializer
+{
+    public int Id => 2;
+
+    public object Deserialize(Stream stream)
+        => new FailedTestInfoRequest(
+            ReadString(stream),
+            ReadInt(stream) == 1,
+            ReadString(stream),
+            ReadString(stream),
+            ReadString(stream),
+            ReadString(stream),
+            ReadString(stream),
+            ReadString(stream),
+            ReadInt(stream));
+
+    public void Serialize(object objectToSerialize, Stream stream)
+    {
+        var failedTestInfoRequest = (FailedTestInfoRequest)objectToSerialize;
+        WriteString(stream, failedTestInfoRequest.DisplayName);
+        WriteInt(stream, failedTestInfoRequest.IsCancelled ? 1 : 0);
+        WriteString(stream, failedTestInfoRequest.Duration ?? string.Empty);
+        WriteString(stream, failedTestInfoRequest.ErrorMessage ?? string.Empty);
+        WriteString(stream, failedTestInfoRequest.ErrorStackTrace ?? string.Empty);
+        WriteString(stream, failedTestInfoRequest.Expected ?? string.Empty);
+        WriteString(stream, failedTestInfoRequest.Actual ?? string.Empty);
+        WriteString(stream, failedTestInfoRequest.CodeFilePath ?? string.Empty);
+        WriteInt(stream, failedTestInfoRequest.LineNumber);
+    }
+}
diff --git a/src/Platform/Microsoft.Testing.Platform.MSBuild/TestPlatformExtensions/Serializers/ModuleInfoRequestSerializer.cs b/src/Platform/Microsoft.Testing.Platform.MSBuild/TestPlatformExtensions/Serializers/ModuleInfoRequestSerializer.cs
new file mode 100644
index 0000000000..5539f7d107
--- /dev/null
+++ b/src/Platform/Microsoft.Testing.Platform.MSBuild/TestPlatformExtensions/Serializers/ModuleInfoRequestSerializer.cs
@@ -0,0 +1,25 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using Microsoft.Testing.Platform.IPC;
+using Microsoft.Testing.Platform.IPC.Serializers;
+
+namespace Microsoft.Testing.Platform.MSBuild.TestPlatformExtensions.Serializers;
+
+internal record ModuleInfoRequest(string FrameworkDescription, string ProcessArchitecture, string TestResultFolder) : IRequest;
+
+internal class ModuleInfoRequestSerializer : BaseSerializer, INamedPipeSerializer
+{
+    public int Id => 1;
+
+    public object Deserialize(Stream stream)
+        => new ModuleInfoRequest(ReadString(stream), ReadString(stream), ReadString(stream));
+
+    public void Serialize(object objectToSerialize, Stream stream)
+    {
+        var moduleInfo = (ModuleInfoRequest)objectToSerialize;
+        WriteString(stream, moduleInfo.FrameworkDescription);
+        WriteString(stream, moduleInfo.ProcessArchitecture);
+        WriteString(stream, moduleInfo.TestResultFolder);
+    }
+}
diff --git a/src/Platform/Microsoft.Testing.Platform.MSBuild/TestPlatformExtensions/Serializers/RunSummaryRequestSerializer.cs b/src/Platform/Microsoft.Testing.Platform.MSBuild/TestPlatformExtensions/Serializers/RunSummaryRequestSerializer.cs
new file mode 100644
index 0000000000..1703e10b26
--- /dev/null
+++ b/src/Platform/Microsoft.Testing.Platform.MSBuild/TestPlatformExtensions/Serializers/RunSummaryRequestSerializer.cs
@@ -0,0 +1,37 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using Microsoft.Testing.Platform.IPC;
+using Microsoft.Testing.Platform.IPC.Serializers;
+
+namespace Microsoft.Testing.Platform.MSBuild.TestPlatformExtensions.Serializers;
+
+internal record RunSummaryInfoRequest(
+    int Total,
+    int TotalFailed,
+    int TotalPassed,
+    int TotalSkipped,
+    string? Duration) : IRequest;
+
+internal class RunSummaryInfoRequestSerializer : BaseSerializer, INamedPipeSerializer
+{
+    public int Id => 3;
+
+    public object Deserialize(Stream stream)
+        => new RunSummaryInfoRequest(
+            ReadInt(stream),
+            ReadInt(stream),
+            ReadInt(stream),
+            ReadInt(stream),
+            ReadString(stream));
+
+    public void Serialize(object objectToSerialize, Stream stream)
+    {
+        var runSummaryInfoRequest = (RunSummaryInfoRequest)objectToSerialize;
+        WriteInt(stream, runSummaryInfoRequest.Total);
+        WriteInt(stream, runSummaryInfoRequest.TotalFailed);
+        WriteInt(stream, runSummaryInfoRequest.TotalPassed);
+        WriteInt(stream, runSummaryInfoRequest.TotalSkipped);
+        WriteString(stream, runSummaryInfoRequest.Duration ?? string.Empty);
+    }
+}
diff --git a/src/Platform/Microsoft.Testing.Platform.MSBuild/TestPlatformExtensions/TestingPlatformBuilderHook.cs b/src/Platform/Microsoft.Testing.Platform.MSBuild/TestPlatformExtensions/TestingPlatformBuilderHook.cs
new file mode 100644
index 0000000000..53e32087d3
--- /dev/null
+++ b/src/Platform/Microsoft.Testing.Platform.MSBuild/TestPlatformExtensions/TestingPlatformBuilderHook.cs
@@ -0,0 +1,12 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using Microsoft.Testing.Platform.Builder;
+
+namespace Microsoft.Testing.Platform.MSBuild;
+
+public static class TestingPlatformBuilderHook
+{
+    public static void AddExtensions(ITestApplicationBuilder testApplicationBuilder, string[] _)
+        => MSBuildExtensions.AddMSBuild(testApplicationBuilder);
+}
diff --git a/src/Platform/Microsoft.Testing.Platform.MSBuild/build/Microsoft.Testing.Platform.MSBuild.props b/src/Platform/Microsoft.Testing.Platform.MSBuild/build/Microsoft.Testing.Platform.MSBuild.props
new file mode 100644
index 0000000000..027ba9b9c6
--- /dev/null
+++ b/src/Platform/Microsoft.Testing.Platform.MSBuild/build/Microsoft.Testing.Platform.MSBuild.props
@@ -0,0 +1,3 @@
+
+  
+
diff --git a/src/Platform/Microsoft.Testing.Platform.MSBuild/build/Microsoft.Testing.Platform.MSBuild.targets b/src/Platform/Microsoft.Testing.Platform.MSBuild/build/Microsoft.Testing.Platform.MSBuild.targets
new file mode 100644
index 0000000000..0ccea6d5d5
--- /dev/null
+++ b/src/Platform/Microsoft.Testing.Platform.MSBuild/build/Microsoft.Testing.Platform.MSBuild.targets
@@ -0,0 +1,3 @@
+
+  
+
diff --git a/src/Platform/Microsoft.Testing.Platform.MSBuild/buildMultiTargeting/Microsoft.Testing.Platform.MSBuild.VSTest.targets b/src/Platform/Microsoft.Testing.Platform.MSBuild/buildMultiTargeting/Microsoft.Testing.Platform.MSBuild.VSTest.targets
new file mode 100644
index 0000000000..295a3db7bb
--- /dev/null
+++ b/src/Platform/Microsoft.Testing.Platform.MSBuild/buildMultiTargeting/Microsoft.Testing.Platform.MSBuild.VSTest.targets
@@ -0,0 +1,7 @@
+
+
+  
+  
+    
+  
+
diff --git a/src/Platform/Microsoft.Testing.Platform.MSBuild/buildMultiTargeting/Microsoft.Testing.Platform.MSBuild.props b/src/Platform/Microsoft.Testing.Platform.MSBuild/buildMultiTargeting/Microsoft.Testing.Platform.MSBuild.props
new file mode 100644
index 0000000000..cf8a05c3f6
--- /dev/null
+++ b/src/Platform/Microsoft.Testing.Platform.MSBuild/buildMultiTargeting/Microsoft.Testing.Platform.MSBuild.props
@@ -0,0 +1,15 @@
+
+
+  
+    
+    True
+  
+
+  
+  
+    
+      Microsoft.Testing.Platform.MSBuild
+      Microsoft.Testing.Platform.MSBuild.TestingPlatformBuilderHook
+    
+  
+
diff --git a/src/Platform/Microsoft.Testing.Platform.MSBuild/buildMultiTargeting/Microsoft.Testing.Platform.MSBuild.targets b/src/Platform/Microsoft.Testing.Platform.MSBuild/buildMultiTargeting/Microsoft.Testing.Platform.MSBuild.targets
new file mode 100644
index 0000000000..838690e317
--- /dev/null
+++ b/src/Platform/Microsoft.Testing.Platform.MSBuild/buildMultiTargeting/Microsoft.Testing.Platform.MSBuild.targets
@@ -0,0 +1,260 @@
+
+
+
+  
+  
+    True
+    True
+  
+
+  
+  
+    
+
+    
+    
+  
+
+  
+  
+    
+  
+
+  
+  
+    
+    $(MSBuildThisFileDirectory)..\_MSBuildTasks\netstandard2.0\
+  
+
+  
+
+  
+
+  
+    <_TestingPlatformConfigurationFileSourceFileName>testingplatformconfig.json
+    <_TestingPlatformConfigurationFileSourcePath>$([System.IO.Path]::Combine($(MSBuildProjectDirectory),$(_TestingPlatformConfigurationFileSourceFileName)))
+    <_TestingPlatformConfigurationFileName>$(AssemblyName).testingplatformconfig.json
+    <_TestingPlatformConfigurationFile>$([System.IO.Path]::Combine($(MSBuildProjectDirectory),$(OutputPath),$(_TestingPlatformConfigurationFileName)))
+  
+  
+    
+      
+    
+    
+      
+    
+    
+      
+        $(_TestingPlatformConfigurationFileName)
+      
+    
+  
+
+
+  
+
+  
+
+  
+    
+      
+      <_GenerateTestingPlatformEntryPointInputsCachFilePath>$(IntermediateOutputPath)$(MSBuildProjectName).gentestingplatformentrypointinputcache.cache
+      <_GenerateTestingPlatformEntryPointInputsCachFilePath>$([MSBuild]::NormalizePath($(MSBuildProjectDirectory), $(_GenerateTestingPlatformEntryPointInputsCachFilePath)))
+    
+    
+      
+      <_GenerateTestingPlatformEntryPointInputsCacheToHash Include="@(TestingPlatformBuilderHook)"/>
+      
+      
+    
+    
+    
+      
+    
+    
+    
+    
+      
+    
+  
+
+  
+  
+    <_TestingPlatformEntryPointSourceNameWithoutExtension>TestPlatformEntryPoint
+    <_TestingPlatformEntryPointSourceName Condition=" $(Language) == 'C#' " >$(_TestingPlatformEntryPointSourceNameWithoutExtension).cs
+    <_TestingPlatformEntryPointSourceName Condition=" $(Language) == 'VB' " >$(_TestingPlatformEntryPointSourceNameWithoutExtension).vb
+    <_TestingPlatformEntryPointSourceName Condition=" $(Language) == 'F#' " >$(_TestingPlatformEntryPointSourceNameWithoutExtension).fs
+    <_TestingPlatformEntryPointSourcePath>$([System.IO.Path]::Combine($(IntermediateOutputPath),$(_TestingPlatformEntryPointSourceName)))
+    <_TestingPlatformEntryPointSourcePath>$([MSBuild]::NormalizePath($(MSBuildProjectDirectory), $(_TestingPlatformEntryPointSourcePath)))
+  
+  
+    
+      
+    
+    
+      
+    
+  
+
+  
+  
+    
+      
+    
+    
+    
+      
+    
+  
+
+
+  
+  
+
+  
+    
+    False
+    
+    False
+    
+    <_MSBuildTestInfrastructureAvailable Condition="Exists('$(MSBuildExtensionsPath)\Microsoft.Common.Test.targets')" >True
+  
+
+  
+    
+      
+      InvokeTestingPlatform
+    
+  
+  
+  
+
+  
+  
+  
+    
+      InvokeTestingPlatform
+    
+  
+
+  
+  
+    
+  
+
+  
+  
+    
+  
+
+  
+    
+    
+    
+    
+  
+
+  
+  
+    
+    
+    
+  
+
+  
+  
+    
+    <_TestArchitecture>$(PlatformTarget)
+    
+    <_TestArchitecture Condition="('$(_TestArchitecture)' == '' or '$(_TestArchitecture)' == 'AnyCpu') and '$(DefaultAppHostRuntimeIdentifier)' != ''">$([System.Text.RegularExpressions.Regex]::Replace($(DefaultAppHostRuntimeIdentifier), '.*-', ''))
+    
+    <_TestArchitecture Condition="('$(_TestArchitecture)' == '' or '$(_TestArchitecture)' == 'AnyCpu') and '$(NETCoreSdkRuntimeIdentifier)' != ''">$([System.Text.RegularExpressions.Regex]::Replace($(DefaultAppHostRuntimeIdentifier), '.*-', ''))
+    
+    <_TestArchitecture Condition="'$(_TestArchitecture)' == '' or '$(_TestArchitecture)' == 'AnyCpu'">x64
+    False
+    True
+  
+  
+    
+    
+    
+  
+
+  
+
diff --git a/src/Platform/Microsoft.Testing.Platform.MSBuild/buildTransitive/Microsoft.Testing.Platform.MSBuild.props b/src/Platform/Microsoft.Testing.Platform.MSBuild/buildTransitive/Microsoft.Testing.Platform.MSBuild.props
new file mode 100644
index 0000000000..027ba9b9c6
--- /dev/null
+++ b/src/Platform/Microsoft.Testing.Platform.MSBuild/buildTransitive/Microsoft.Testing.Platform.MSBuild.props
@@ -0,0 +1,3 @@
+
+  
+
diff --git a/src/Platform/Microsoft.Testing.Platform.MSBuild/buildTransitive/Microsoft.Testing.Platform.MSBuild.targets b/src/Platform/Microsoft.Testing.Platform.MSBuild/buildTransitive/Microsoft.Testing.Platform.MSBuild.targets
new file mode 100644
index 0000000000..0ccea6d5d5
--- /dev/null
+++ b/src/Platform/Microsoft.Testing.Platform.MSBuild/buildTransitive/Microsoft.Testing.Platform.MSBuild.targets
@@ -0,0 +1,3 @@
+
+  
+
diff --git a/src/Platform/Microsoft.Testing.Platform/.editorconfig b/src/Platform/Microsoft.Testing.Platform/.editorconfig
new file mode 100644
index 0000000000..5c8e5dad5d
--- /dev/null
+++ b/src/Platform/Microsoft.Testing.Platform/.editorconfig
@@ -0,0 +1,3 @@
+[*.{cs,vb}]
+# TPEXP: Type is for evaluation purposes only and is subject to change or removal in future updates. Suppress this diagnostic to proceed.
+dotnet_diagnostic.TPEXP.severity = none
diff --git a/src/Platform/Microsoft.Testing.Platform/Builder/TestApplication.cs b/src/Platform/Microsoft.Testing.Platform/Builder/TestApplication.cs
index 907cfcd7db..6ca4b20638 100644
--- a/src/Platform/Microsoft.Testing.Platform/Builder/TestApplication.cs
+++ b/src/Platform/Microsoft.Testing.Platform/Builder/TestApplication.cs
@@ -114,7 +114,7 @@ public static async Task CreateBuilderAsync(string[] ar
         }
 
         // All checks are fine, create the TestApplication.
-        return new TestApplicationBuilder(args, loggingState, createBuilderStart, testApplicationOptions, s_unhandledExceptionHandler);
+        return new TestApplicationBuilder(loggingState, createBuilderStart, testApplicationOptions, s_unhandledExceptionHandler);
     }
 
     private static async Task LogInformationAsync(
@@ -142,7 +142,8 @@ private static async Task LogInformationAsync(
         await logger.LogInformationAsync("Logging mode: " + (syncWrite ? "synchronous" : "asynchronous"));
         await logger.LogInformationAsync($"Logging level: {loggerLevel}");
         await logger.LogInformationAsync($"CreateBuilderAsync entry time: {createBuilderEntryTime}");
-        await logger.LogInformationAsync($"PID: {processHandler.GetCurrentProcess().Id}");
+        using IProcess currentProcess = processHandler.GetCurrentProcess();
+        await logger.LogInformationAsync($"PID: {currentProcess.Id}");
 
 #if NETCOREAPP
         string runtimeInformation = $"{RuntimeInformation.RuntimeIdentifier} - {RuntimeInformation.FrameworkDescription}";
@@ -156,7 +157,7 @@ private static async Task LogInformationAsync(
         if (RuntimeFeature.IsDynamicCodeSupported)
         {
 #pragma warning disable IL3000 // Avoid accessing Assembly file path when publishing as a single file
-            string? runtimeLocation = typeof(object).Assembly?.Location;
+            string? runtimeLocation = typeof(object).Assembly.Location;
 #pragma warning restore IL3000 // Avoid accessing Assembly file path when publishing as a single file
             if (runtimeLocation is not null)
             {
@@ -212,23 +213,20 @@ private static async Task LogInformationAsync(
 
         if (testHostControllerInfo.HasTestHostController)
         {
-            string? processCorrelationId;
             int? testHostControllerPID = testHostControllerInfo.GetTestHostControllerPID();
-            if ((processCorrelationId = environment.GetEnvironmentVariable($"{EnvironmentVariableConstants.TESTINGPLATFORM_TESTHOSTCONTROLLER_CORRELATIONID}_{testHostControllerPID}")) is not null)
-            {
-                await logger.LogDebugAsync($"{$"{EnvironmentVariableConstants.TESTINGPLATFORM_TESTHOSTCONTROLLER_CORRELATIONID}_{testHostControllerPID}"} '{processCorrelationId}'");
-            }
 
-            string? parentPid;
-            if ((parentPid = environment.GetEnvironmentVariable($"{EnvironmentVariableConstants.TESTINGPLATFORM_TESTHOSTCONTROLLER_PARENTPID}_{testHostControllerPID}")) is not null)
-            {
-                await logger.LogDebugAsync($"{$"{EnvironmentVariableConstants.TESTINGPLATFORM_TESTHOSTCONTROLLER_PARENTPID}_{testHostControllerPID}"} '{parentPid}'");
-            }
+            await LogVariableAsync(EnvironmentVariableConstants.TESTINGPLATFORM_TESTHOSTCONTROLLER_CORRELATIONID);
+            await LogVariableAsync(EnvironmentVariableConstants.TESTINGPLATFORM_TESTHOSTCONTROLLER_PARENTPID);
+            await LogVariableAsync(EnvironmentVariableConstants.TESTINGPLATFORM_TESTHOSTCONTROLLER_TESTHOSTPROCESSSTARTTIME);
 
-            string? testHostProcessStartTime;
-            if ((testHostProcessStartTime = environment.GetEnvironmentVariable($"{EnvironmentVariableConstants.TESTINGPLATFORM_TESTHOSTCONTROLLER_TESTHOSTPROCESSSTARTTIME}_{testHostControllerPID}")) is not null)
+            async Task LogVariableAsync(string key)
             {
-                await logger.LogDebugAsync($"{EnvironmentVariableConstants.TESTINGPLATFORM_TESTHOSTCONTROLLER_TESTHOSTPROCESSSTARTTIME}_{testHostControllerPID} '{testHostProcessStartTime}'");
+                string? value;
+                key = $"{key}_{testHostControllerPID}";
+                if ((value = environment.GetEnvironmentVariable(key)) is not null)
+                {
+                    await logger.LogDebugAsync($"{key} '{value}'");
+                }
             }
         }
 
@@ -299,11 +297,7 @@ private static ApplicationLoggingState CreateFileLoggerIfDiagnosticIsEnabled(
 
         if (result.TryGetOptionArgumentList(PlatformCommandLineProvider.DiagnosticVerbosityOptionKey, out string[]? verbosity))
         {
-#if NET
-            logLevel = Enum.Parse(verbosity[0], true);
-#else
-            logLevel = (LogLevel)Enum.Parse(typeof(LogLevel), verbosity[0], true);
-#endif
+            logLevel = EnumPolyfill.Parse(verbosity[0], true);
         }
 
         // Override the log level if the environment variable is set
diff --git a/src/Platform/Microsoft.Testing.Platform/Builder/TestApplicationBuilder.cs b/src/Platform/Microsoft.Testing.Platform/Builder/TestApplicationBuilder.cs
index 13ab3e216a..91ad6a032d 100644
--- a/src/Platform/Microsoft.Testing.Platform/Builder/TestApplicationBuilder.cs
+++ b/src/Platform/Microsoft.Testing.Platform/Builder/TestApplicationBuilder.cs
@@ -26,25 +26,22 @@ namespace Microsoft.Testing.Platform.Builder;
 ///