Remove obsolete method IActiveConfiguredProjectsProvider.GetActiveConfiguredProjectsMapAsync

Author: drewnoakes

src/Microsoft.VisualStudio.ProjectSystem.Managed/ProjectSystem/ActiveConfiguredProjectsProvider.cs

@@ -63,35 +63,6 @@ public ActiveConfiguredProjectsProvider(IUnconfiguredProjectServices services, U
     [ImportMany]
     public OrderPrecedenceImportCollection<IActiveConfiguredProjectsDimensionProvider> DimensionProviders { get; }
 
-    public async Task<ImmutableDictionary<string, ConfiguredProject>?> GetActiveConfiguredProjectsMapAsync()
-    {
-        ActiveConfiguredObjects<ConfiguredProject>? projects = await GetActiveConfiguredProjectsAsync();
-
-        if (projects?.Objects.IsEmpty != false)
-        {
-            return null;
-        }
-
-        var builder = PooledDictionary<string, ConfiguredProject>.GetInstance();
-
-        bool isCrossTargeting = projects.Objects.All(project => project.ProjectConfiguration.IsCrossTargeting());
-
-        if (isCrossTargeting)
-        {
-            foreach (ConfiguredProject project in projects.Objects)
-            {
-                string targetFramework = project.ProjectConfiguration.Dimensions[ConfigurationGeneral.TargetFrameworkProperty];
-                builder.Add(targetFramework, project);
-            }
-        }
-        else
-        {
-            builder.Add(string.Empty, projects.Objects[0]);
-        }
-
-        return builder.ToImmutableDictionaryAndFree();
-    }
-
     public async Task<ActiveConfiguredObjects<ConfiguredProject>?> GetActiveConfiguredProjectsAsync()
     {
         ActiveConfiguredObjects<ProjectConfiguration>? configurations = await GetActiveProjectConfigurationsAsync();

src/Microsoft.VisualStudio.ProjectSystem.Managed/ProjectSystem/Debug/ActiveDebugFrameworkServices.cs

@@ -53,44 +53,67 @@ public async Task SetActiveDebuggingFrameworkPropertyAsync(string activeFramewor
 
     public async Task<ConfiguredProject?> GetConfiguredProjectForActiveFrameworkAsync()
     {
-#pragma warning disable CS0618 // Type or member is obsolete
-        ImmutableDictionary<string, ConfiguredProject>? configProjects = await _activeConfiguredProjectsProvider.GetActiveConfiguredProjectsMapAsync();
-#pragma warning restore CS0618 // Type or member is obsolete
+        ActiveConfiguredObjects<ConfiguredProject>? projects = await _activeConfiguredProjectsProvider.GetActiveConfiguredProjectsAsync();
 
-        if (configProjects is null)
+        if (projects is null || projects.Objects.IsEmpty)
         {
             return null;
         }
 
-        // If there is only one we are done
-        if (configProjects.Count == 1)
+        if (projects.Objects.Length is 1)
         {
-            return configProjects.First().Value;
+            return projects.Objects[0];
         }
 
-        string? activeFramework = await GetActiveDebuggingFrameworkPropertyAsync();
+        bool isMultiTargeting = projects.Objects.All(project => project.ProjectConfiguration.IsCrossTargeting());
 
-        if (!Strings.IsNullOrWhiteSpace(activeFramework))
+        if (isMultiTargeting)
         {
-            if (configProjects.TryGetValue(activeFramework, out ConfiguredProject? configuredProject))
+            string? activeDebugFramework = await GetActiveDebuggingFrameworkPropertyAsync();
+
+            ConfiguredProject? project = FindProject(activeDebugFramework);
+
+            if (project is null)
             {
-                return configuredProject;
+                // The expected debug framework was not found, so we need to pick one.
+                // Use the first target as defined in the TargetFrameworks property. This is treated specially.
+                // We must pick the first that was defined can't just select the first one. If activeFramework is not set we must pick the first one as defined by the 
+                // targetFrameworks property. So we need the order as returned by GetProjectFrameworks()
+                if (await GetProjectFrameworksAsync() is [string firstFramework, ..])
+                {
+                    project = FindProject(firstFramework);
+                }
             }
+
+            System.Diagnostics.Debug.Assert(project is not null, "Unable to determine debug project configuration.");
+
+            return project;
         }
+        else
+        {
+            System.Diagnostics.Debug.Assert(projects.Objects.Length == 1, "Expected only one active configured project when not cross-targeting.");
 
-        // We can't just select the first one. If activeFramework is not set we must pick the first one as defined by the 
-        // targetFrameworks property. So we need the order as returned by GetProjectFrameworks()
-        List<string>? frameworks = await GetProjectFrameworksAsync();
+            return projects.Objects[0];
+        }
 
-        if (frameworks?.Count > 0)
+        ConfiguredProject? FindProject(string? targetFramework)
         {
-            if (configProjects.TryGetValue(frameworks[0], out ConfiguredProject? configuredProject))
+            if (Strings.IsNullOrWhiteSpace(targetFramework))
             {
-                return configuredProject;
+                return null;
             }
-        }
 
-        // All that is left is to return the first one.
-        return configProjects.First().Value;
+            foreach (ConfiguredProject project in projects.Objects)
+            {
+                string tf = project.ProjectConfiguration.Dimensions[ConfigurationGeneral.TargetFrameworkProperty];
+
+                if (StringComparers.ConfigurationDimensionValues.Equals(tf, targetFramework))
+                {
+                    return project;
+                }
+            }
+
+            return null;
+        }
     }
 }

src/Microsoft.VisualStudio.ProjectSystem.Managed/ProjectSystem/IActiveConfiguredProjectsProvider.cs

@@ -14,18 +14,6 @@ namespace Microsoft.VisualStudio.ProjectSystem;
 [ProjectSystemContract(ProjectSystemContractScope.UnconfiguredProject, ProjectSystemContractProvider.Private, Cardinality = ImportCardinality.ExactlyOne)]
 internal interface IActiveConfiguredProjectsProvider
 {
-    /// <summary>
-    ///     Gets all the active configured projects by TargetFramework dimension for the current unconfigured project.
-    ///     If the current project is not a cross-targeting project, then it returns a singleton key-value pair with an
-    ///     ignorable key and single active configured project as value.
-    /// </summary>
-    /// <returns>
-    ///     Map from TargetFramework dimension to active configured project, or <see langword="null" /> if there
-    ///     are no active <see cref="ConfiguredProject"/> objects.
-    /// </returns>
-    [Obsolete("This method will be removed in a future build.")]
-    Task<ImmutableDictionary<string, ConfiguredProject>?> GetActiveConfiguredProjectsMapAsync();
-
     /// <summary>
     ///     Returns the ordered list of configured projects that are active for the current project, loading them if needed.
     /// </summary>

tests/Microsoft.VisualStudio.ProjectSystem.Managed.UnitTests/Mocks/IActiveConfiguredProjectsProviderFactory.cs

@@ -13,15 +13,6 @@ public void Verify()
         _mock.Verify();
     }
 
-    public IActiveConfiguredProjectsProviderFactory ImplementGetActiveConfiguredProjectsMapAsync(ImmutableDictionary<string, ConfiguredProject> configuredProjects)
-    {
-#pragma warning disable CS0618 // Type or member is obsolete
-        _mock.Setup(x => x.GetActiveConfiguredProjectsMapAsync())
-#pragma warning restore CS0618 // Type or member is obsolete
-                          .ReturnsAsync(configuredProjects);
-        return this;
-    }
-
     public IActiveConfiguredProjectsProviderFactory ImplementGetActiveConfiguredProjectsAsync(ActiveConfiguredObjects<ConfiguredProject> configuredProjects)
     {
         _mock.Setup(x => x.GetActiveConfiguredProjectsAsync())

tests/Microsoft.VisualStudio.ProjectSystem.Managed.UnitTests/ProjectSystem/Debug/ActiveDebugFrameworkServicesTests.cs

@@ -74,23 +74,25 @@ public async Task GetConfiguredProjectForActiveFrameworkAsync_ReturnsCorrectProj
         var data = new PropertyPageData(ProjectDebugger.SchemaName, ProjectDebugger.ActiveDebugFrameworkProperty, framework);
         var data2 = new PropertyPageData(ConfigurationGeneral.SchemaName, ConfigurationGeneral.TargetFrameworksProperty, "net462;net461;netcoreapp1.0");
 
-        var projects = ImmutableStringDictionary<ConfiguredProject>.EmptyOrdinal
-                        .Add("net461", ConfiguredProjectFactory.Create(null, new StandardProjectConfiguration("Debug|AnyCPU|net461", Empty.PropertiesMap
-                                                                                .Add("Configuration", "Debug")
-                                                                                .Add("Platform", "AnyCPU")
-                                                                                .Add("TargetFramework", "net461"))))
-                        .Add("netcoreapp1.0", ConfiguredProjectFactory.Create(null, new StandardProjectConfiguration("Debug|AnyCPU|netcoreapp1.0", Empty.PropertiesMap
-                                                                                .Add("Configuration", "Debug")
-                                                                                .Add("Platform", "AnyCPU")
-                                                                                .Add("TargetFramework", "netcoreapp1.0"))))
-                        .Add("net462", ConfiguredProjectFactory.Create(null, new StandardProjectConfiguration("Debug|AnyCPU|net462", Empty.PropertiesMap
-                                                                                .Add("Configuration", "Debug")
-                                                                                .Add("Platform", "AnyCPU")
-                                                                                .Add("TargetFramework", "net462"))));
+        ImmutableArray<ConfiguredProject> projects =
+        [
+            ConfiguredProjectFactory.Create(null, new StandardProjectConfiguration("Debug|AnyCPU|net461", Empty.PropertiesMap
+                .Add("Configuration", "Debug")
+                .Add("Platform", "AnyCPU")
+                .Add("TargetFramework", "net461"))),
+            ConfiguredProjectFactory.Create(null, new StandardProjectConfiguration("Debug|AnyCPU|netcoreapp1.0", Empty.PropertiesMap
+                .Add("Configuration", "Debug")
+                .Add("Platform", "AnyCPU")
+                .Add("TargetFramework", "netcoreapp1.0"))),
+            ConfiguredProjectFactory.Create(null, new StandardProjectConfiguration("Debug|AnyCPU|net462", Empty.PropertiesMap
+                .Add("Configuration", "Debug")
+                .Add("Platform", "AnyCPU")
+                .Add("TargetFramework", "net462")))
+        ];
 
         var projectProperties = ProjectPropertiesFactory.Create(project, data, data2);
         var projectConfigProvider = new IActiveConfiguredProjectsProviderFactory(MockBehavior.Strict)
-                                   .ImplementGetActiveConfiguredProjectsMapAsync(projects);
+                                   .ImplementGetActiveConfiguredProjectsAsync(new ActiveConfiguredObjects<ConfiguredProject>(projects, ["TargetFramework"]));
 
         var commonServices = IUnconfiguredProjectCommonServicesFactory.Create(projectProperties: projectProperties);