From 93cfd500593ef5a4461c05d88c90488ac1bf7811 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 3 Sep 2025 20:41:04 +0000
Subject: [PATCH 1/7] Initial plan


From ce83b907f46c68e350584e689f773a76fe7d71d0 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 3 Sep 2025 20:58:42 +0000
Subject: [PATCH 2/7] Implement SelectRuntimeIdentifierSpecificItems MSBuild
 task with tests

Co-authored-by: baronfel <573979+baronfel@users.noreply.github.com>
---
 ...enASelectRuntimeIdentifierSpecificItems.cs | 191 ++++++++++++++++++
 .../SelectRuntimeIdentifierSpecificItems.cs   | 100 +++++++++
 2 files changed, 291 insertions(+)
 create mode 100644 src/Tasks/Microsoft.NET.Build.Tasks.UnitTests/GivenASelectRuntimeIdentifierSpecificItems.cs
 create mode 100644 src/Tasks/Microsoft.NET.Build.Tasks/SelectRuntimeIdentifierSpecificItems.cs

diff --git a/src/Tasks/Microsoft.NET.Build.Tasks.UnitTests/GivenASelectRuntimeIdentifierSpecificItems.cs b/src/Tasks/Microsoft.NET.Build.Tasks.UnitTests/GivenASelectRuntimeIdentifierSpecificItems.cs
new file mode 100644
index 000000000000..c6dea601a9ff
--- /dev/null
+++ b/src/Tasks/Microsoft.NET.Build.Tasks.UnitTests/GivenASelectRuntimeIdentifierSpecificItems.cs
@@ -0,0 +1,191 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using FluentAssertions;
+using Microsoft.Build.Framework;
+using Microsoft.Build.Utilities;
+using Xunit;
+
+namespace Microsoft.NET.Build.Tasks.UnitTests
+{
+    public class GivenASelectRuntimeIdentifierSpecificItems
+    {
+        [Fact]
+        public void ItSelectsCompatibleItems()
+        {
+            // Arrange
+            var testRuntimeGraphPath = CreateTestRuntimeGraph();
+            var items = new[]
+            {
+                CreateTaskItem("Item1", "linux-x64"),
+                CreateTaskItem("Item2", "win-x64"),
+                CreateTaskItem("Item3", "linux"),
+                CreateTaskItem("Item4", "ubuntu.18.04-x64")
+            };
+
+            var task = new SelectRuntimeIdentifierSpecificItems()
+            {
+                TargetRuntimeIdentifier = "ubuntu.18.04-x64",
+                Items = items,
+                RuntimeIdentifierGraphPath = testRuntimeGraphPath,
+                BuildEngine = new MockBuildEngine()
+            };
+
+            // Act
+            bool result = task.Execute();
+
+            // Assert
+            result.Should().BeTrue();
+            task.SelectedItems.Should().HaveCount(3); // linux-x64, linux, ubuntu.18.04-x64 should be compatible
+            task.SelectedItems.Should().Contain(i => i.ItemSpec == "Item1"); // linux-x64
+            task.SelectedItems.Should().Contain(i => i.ItemSpec == "Item3"); // linux
+            task.SelectedItems.Should().Contain(i => i.ItemSpec == "Item4"); // ubuntu.18.04-x64
+            task.SelectedItems.Should().NotContain(i => i.ItemSpec == "Item2"); // win-x64
+        }
+
+        [Fact]
+        public void ItSelectsItemsWithExactMatch()
+        {
+            // Arrange
+            var testRuntimeGraphPath = CreateTestRuntimeGraph();
+            var items = new[]
+            {
+                CreateTaskItem("Item1", "win-x64"),
+                CreateTaskItem("Item2", "linux-x64")
+            };
+
+            var task = new SelectRuntimeIdentifierSpecificItems()
+            {
+                TargetRuntimeIdentifier = "win-x64",
+                Items = items,
+                RuntimeIdentifierGraphPath = testRuntimeGraphPath,
+                BuildEngine = new MockBuildEngine()
+            };
+
+            // Act
+            bool result = task.Execute();
+
+            // Assert
+            result.Should().BeTrue();
+            task.SelectedItems.Should().HaveCount(1);
+            task.SelectedItems[0].ItemSpec.Should().Be("Item1");
+        }
+
+        [Fact]
+        public void ItSkipsItemsWithoutRuntimeIdentifierMetadata()
+        {
+            // Arrange
+            var testRuntimeGraphPath = CreateTestRuntimeGraph();
+            var items = new[]
+            {
+                CreateTaskItem("Item1", "linux-x64"),
+                CreateTaskItem("Item2", null), // No runtime identifier
+                CreateTaskItem("Item3", "") // Empty runtime identifier
+            };
+
+            var task = new SelectRuntimeIdentifierSpecificItems()
+            {
+                TargetRuntimeIdentifier = "linux-x64",
+                Items = items,
+                RuntimeIdentifierGraphPath = testRuntimeGraphPath,
+                BuildEngine = new MockBuildEngine()
+            };
+
+            // Act
+            bool result = task.Execute();
+
+            // Assert
+            result.Should().BeTrue();
+            task.SelectedItems.Should().HaveCount(1);
+            task.SelectedItems[0].ItemSpec.Should().Be("Item1");
+        }
+
+        [Fact]
+        public void ItUsesCustomRuntimeIdentifierMetadata()
+        {
+            // Arrange
+            var testRuntimeGraphPath = CreateTestRuntimeGraph();
+            var item = new TaskItem("Item1");
+            item.SetMetadata("CustomRID", "linux-x64");
+
+            var task = new SelectRuntimeIdentifierSpecificItems()
+            {
+                TargetRuntimeIdentifier = "ubuntu.18.04-x64",
+                Items = new[] { item },
+                RuntimeIdentifierItemMetadata = "CustomRID",
+                RuntimeIdentifierGraphPath = testRuntimeGraphPath,
+                BuildEngine = new MockBuildEngine()
+            };
+
+            // Act
+            bool result = task.Execute();
+
+            // Assert
+            result.Should().BeTrue();
+            task.SelectedItems.Should().HaveCount(1);
+            task.SelectedItems[0].ItemSpec.Should().Be("Item1");
+        }
+
+        [Fact]
+        public void ItReturnsEmptyArrayWhenNoItemsProvided()
+        {
+            // Arrange
+            var testRuntimeGraphPath = CreateTestRuntimeGraph();
+
+            var task = new SelectRuntimeIdentifierSpecificItems()
+            {
+                TargetRuntimeIdentifier = "linux-x64",
+                Items = new ITaskItem[0],
+                RuntimeIdentifierGraphPath = testRuntimeGraphPath,
+                BuildEngine = new MockBuildEngine()
+            };
+
+            // Act
+            bool result = task.Execute();
+
+            // Assert
+            result.Should().BeTrue();
+            task.SelectedItems.Should().BeEmpty();
+        }
+
+        private static TaskItem CreateTaskItem(string itemSpec, string? runtimeIdentifier)
+        {
+            var item = new TaskItem(itemSpec);
+            if (!string.IsNullOrEmpty(runtimeIdentifier))
+            {
+                item.SetMetadata("RuntimeIdentifier", runtimeIdentifier);
+            }
+            return item;
+        }
+
+        private static string CreateTestRuntimeGraph()
+        {
+            // Create a minimal runtime graph for testing
+            var runtimeGraph = @"{
+  ""runtimes"": {
+    ""linux"": {},
+    ""linux-x64"": {
+      ""#import"": [""linux""]
+    },
+    ""ubuntu"": {
+      ""#import"": [""linux""]
+    },
+    ""ubuntu.18.04"": {
+      ""#import"": [""ubuntu""]
+    },
+    ""ubuntu.18.04-x64"": {
+      ""#import"": [""ubuntu.18.04"", ""linux-x64""]
+    },
+    ""win"": {},
+    ""win-x64"": {
+      ""#import"": [""win""]
+    }
+  }
+}";
+
+            var tempFile = Path.GetTempFileName();
+            File.WriteAllText(tempFile, runtimeGraph);
+            return tempFile;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Tasks/Microsoft.NET.Build.Tasks/SelectRuntimeIdentifierSpecificItems.cs b/src/Tasks/Microsoft.NET.Build.Tasks/SelectRuntimeIdentifierSpecificItems.cs
new file mode 100644
index 000000000000..f83b4868f48b
--- /dev/null
+++ b/src/Tasks/Microsoft.NET.Build.Tasks/SelectRuntimeIdentifierSpecificItems.cs
@@ -0,0 +1,100 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#nullable disable
+
+using Microsoft.Build.Framework;
+using NuGet.RuntimeModel;
+
+namespace Microsoft.NET.Build.Tasks
+{
+    /// <summary>
+    /// MSBuild task that filters a set of Items by matching on compatible RuntimeIdentifier.
+    /// This task filters an Item list by those items that contain a specific Metadata that is 
+    /// compatible with a specified Runtime Identifier, according to a given RuntimeIdentifierGraph file.
+    /// </summary>
+    public class SelectRuntimeIdentifierSpecificItems : TaskBase
+    {
+        /// <summary>
+        /// The target runtime identifier to check compatibility against.
+        /// </summary>
+        [Required]
+        public string TargetRuntimeIdentifier { get; set; } = string.Empty;
+
+        /// <summary>
+        /// The list of candidate items to filter.
+        /// </summary>
+        [Required]
+        public ITaskItem[] Items { get; set; } = [];
+
+        /// <summary>
+        /// The name of the MSBuild metadata to check on each item. Defaults to "RuntimeIdentifier".
+        /// </summary>
+        public string RuntimeIdentifierItemMetadata { get; set; } = "RuntimeIdentifier";
+
+        /// <summary>
+        /// Path to the RuntimeIdentifierGraph file.
+        /// </summary>
+        [Required]
+        public string RuntimeIdentifierGraphPath { get; set; } = string.Empty;
+
+        /// <summary>
+        /// The filtered items that are compatible with the target runtime identifier.
+        /// </summary>
+        [Output]
+        public ITaskItem[] SelectedItems { get; set; } = [];
+
+        protected override void ExecuteCore()
+        {
+            if (Items == null || Items.Length == 0)
+            {
+                SelectedItems = [];
+                return;
+            }
+
+            RuntimeGraph runtimeGraph = new RuntimeGraphCache(this).GetRuntimeGraph(RuntimeIdentifierGraphPath);
+
+            var selectedItems = new List<ITaskItem>();
+            
+            foreach (var item in Items)
+            {
+                string itemRuntimeIdentifier = item.GetMetadata(RuntimeIdentifierItemMetadata);
+                
+                if (string.IsNullOrEmpty(itemRuntimeIdentifier))
+                {
+                    // Item doesn't have the runtime identifier metadata, skip it
+                    continue;
+                }
+
+                // Check if the item's runtime identifier is compatible with the target runtime identifier
+                if (IsCompatibleRuntimeIdentifier(runtimeGraph, TargetRuntimeIdentifier, itemRuntimeIdentifier))
+                {
+                    selectedItems.Add(item);
+                }
+            }
+
+            SelectedItems = selectedItems.ToArray();
+        }
+
+        /// <summary>
+        /// Determines if a candidate runtime identifier is compatible with a target runtime identifier.
+        /// </summary>
+        /// <param name="runtimeGraph">The runtime graph containing compatibility information.</param>
+        /// <param name="targetRuntimeIdentifier">The target runtime identifier.</param>
+        /// <param name="candidateRuntimeIdentifier">The candidate runtime identifier to check.</param>
+        /// <returns>True if the candidate is compatible with the target, false otherwise.</returns>
+        private static bool IsCompatibleRuntimeIdentifier(RuntimeGraph runtimeGraph, string targetRuntimeIdentifier, string candidateRuntimeIdentifier)
+        {
+            if (string.Equals(targetRuntimeIdentifier, candidateRuntimeIdentifier, StringComparison.OrdinalIgnoreCase))
+            {
+                return true;
+            }
+
+            // Get the list of compatible runtime identifiers for the target
+            var compatibleRuntimeIdentifiers = runtimeGraph.ExpandRuntime(targetRuntimeIdentifier);
+
+            // Check if the candidate runtime identifier is in the list of compatible ones
+            return compatibleRuntimeIdentifiers.Contains(candidateRuntimeIdentifier, StringComparer.OrdinalIgnoreCase);
+        }
+    }
+}
\ No newline at end of file

From bf9dbae91053e76143a56b6fabaff8d6059ccf8d Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 3 Sep 2025 21:32:20 +0000
Subject: [PATCH 3/7] Add UsingTask declaration for
 SelectRuntimeIdentifierSpecificItems in
 Microsoft.NET.RuntimeIdentifierInference.targets

Co-authored-by: baronfel <573979+baronfel@users.noreply.github.com>
---
 .../targets/Microsoft.NET.RuntimeIdentifierInference.targets    | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/Tasks/Microsoft.NET.Build.Tasks/targets/Microsoft.NET.RuntimeIdentifierInference.targets b/src/Tasks/Microsoft.NET.Build.Tasks/targets/Microsoft.NET.RuntimeIdentifierInference.targets
index 7bb069dbc417..fbf9522c3e78 100644
--- a/src/Tasks/Microsoft.NET.Build.Tasks/targets/Microsoft.NET.RuntimeIdentifierInference.targets
+++ b/src/Tasks/Microsoft.NET.Build.Tasks/targets/Microsoft.NET.RuntimeIdentifierInference.targets
@@ -366,6 +366,8 @@ Copyright (c) .NET Foundation. All rights reserved.
 
   <UsingTask TaskName="Microsoft.NET.Build.Tasks.GetDefaultPlatformTargetForNetFramework"
            AssemblyFile="$(MicrosoftNETBuildTasksAssembly)" />
+  <UsingTask TaskName="Microsoft.NET.Build.Tasks.SelectRuntimeIdentifierSpecificItems"
+           AssemblyFile="$(MicrosoftNETBuildTasksAssembly)" />
 
   <!--
     Switch our default .NETFramework CPU architecture choice back to AnyCPU before

From 1e3659fed081cfd8703b0516af83a1286f8917e0 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 3 Sep 2025 22:05:14 +0000
Subject: [PATCH 4/7] Remove #nullable disable and add proper nullable
 reference type annotations

Co-authored-by: baronfel <573979+baronfel@users.noreply.github.com>
---
 .../SelectRuntimeIdentifierSpecificItems.cs   | 39 +++++++++++++------
 1 file changed, 28 insertions(+), 11 deletions(-)

diff --git a/src/Tasks/Microsoft.NET.Build.Tasks/SelectRuntimeIdentifierSpecificItems.cs b/src/Tasks/Microsoft.NET.Build.Tasks/SelectRuntimeIdentifierSpecificItems.cs
index f83b4868f48b..8b0cca381818 100644
--- a/src/Tasks/Microsoft.NET.Build.Tasks/SelectRuntimeIdentifierSpecificItems.cs
+++ b/src/Tasks/Microsoft.NET.Build.Tasks/SelectRuntimeIdentifierSpecificItems.cs
@@ -1,8 +1,9 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-#nullable disable
-
+using System;
+using System.Collections.Generic;
+using System.Linq;
 using Microsoft.Build.Framework;
 using NuGet.RuntimeModel;
 
@@ -19,46 +20,62 @@ public class SelectRuntimeIdentifierSpecificItems : TaskBase
         /// The target runtime identifier to check compatibility against.
         /// </summary>
         [Required]
-        public string TargetRuntimeIdentifier { get; set; } = string.Empty;
+        public string? TargetRuntimeIdentifier { get; set; }
 
         /// <summary>
         /// The list of candidate items to filter.
         /// </summary>
         [Required]
-        public ITaskItem[] Items { get; set; } = [];
+        public ITaskItem[]? Items { get; set; }
 
         /// <summary>
         /// The name of the MSBuild metadata to check on each item. Defaults to "RuntimeIdentifier".
         /// </summary>
-        public string RuntimeIdentifierItemMetadata { get; set; } = "RuntimeIdentifier";
+        public string? RuntimeIdentifierItemMetadata { get; set; } = "RuntimeIdentifier";
 
         /// <summary>
         /// Path to the RuntimeIdentifierGraph file.
         /// </summary>
         [Required]
-        public string RuntimeIdentifierGraphPath { get; set; } = string.Empty;
+        public string? RuntimeIdentifierGraphPath { get; set; }
 
         /// <summary>
         /// The filtered items that are compatible with the target runtime identifier.
         /// </summary>
         [Output]
-        public ITaskItem[] SelectedItems { get; set; } = [];
+        public ITaskItem[]? SelectedItems { get; set; }
 
         protected override void ExecuteCore()
         {
             if (Items == null || Items.Length == 0)
             {
-                SelectedItems = [];
+                SelectedItems = Array.Empty<ITaskItem>();
+                return;
+            }
+
+            string targetRid = TargetRuntimeIdentifier ?? string.Empty;
+            string ridGraphPath = RuntimeIdentifierGraphPath ?? string.Empty;
+            string ridMetadata = RuntimeIdentifierItemMetadata ?? "RuntimeIdentifier";
+
+            if (string.IsNullOrEmpty(targetRid))
+            {
+                Log.LogError("TargetRuntimeIdentifier is required but was not provided.");
+                return;
+            }
+
+            if (string.IsNullOrEmpty(ridGraphPath))
+            {
+                Log.LogError("RuntimeIdentifierGraphPath is required but was not provided.");
                 return;
             }
 
-            RuntimeGraph runtimeGraph = new RuntimeGraphCache(this).GetRuntimeGraph(RuntimeIdentifierGraphPath);
+            RuntimeGraph runtimeGraph = new RuntimeGraphCache(this).GetRuntimeGraph(ridGraphPath);
 
             var selectedItems = new List<ITaskItem>();
             
             foreach (var item in Items)
             {
-                string itemRuntimeIdentifier = item.GetMetadata(RuntimeIdentifierItemMetadata);
+                string? itemRuntimeIdentifier = item.GetMetadata(ridMetadata);
                 
                 if (string.IsNullOrEmpty(itemRuntimeIdentifier))
                 {
@@ -67,7 +84,7 @@ protected override void ExecuteCore()
                 }
 
                 // Check if the item's runtime identifier is compatible with the target runtime identifier
-                if (IsCompatibleRuntimeIdentifier(runtimeGraph, TargetRuntimeIdentifier, itemRuntimeIdentifier))
+                if (IsCompatibleRuntimeIdentifier(runtimeGraph, targetRid, itemRuntimeIdentifier))
                 {
                     selectedItems.Add(item);
                 }

From 0a444839f0be3c80983f99785f9b6c8e6a83953a Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 3 Sep 2025 22:24:02 +0000
Subject: [PATCH 5/7] Simplify runtime compatibility check to use
 runtimeGraph.AreCompatible() directly

Co-authored-by: baronfel <573979+baronfel@users.noreply.github.com>
---
 .../SelectRuntimeIdentifierSpecificItems.cs   | 23 +------------------
 1 file changed, 1 insertion(+), 22 deletions(-)

diff --git a/src/Tasks/Microsoft.NET.Build.Tasks/SelectRuntimeIdentifierSpecificItems.cs b/src/Tasks/Microsoft.NET.Build.Tasks/SelectRuntimeIdentifierSpecificItems.cs
index 8b0cca381818..7099a8548503 100644
--- a/src/Tasks/Microsoft.NET.Build.Tasks/SelectRuntimeIdentifierSpecificItems.cs
+++ b/src/Tasks/Microsoft.NET.Build.Tasks/SelectRuntimeIdentifierSpecificItems.cs
@@ -84,7 +84,7 @@ protected override void ExecuteCore()
                 }
 
                 // Check if the item's runtime identifier is compatible with the target runtime identifier
-                if (IsCompatibleRuntimeIdentifier(runtimeGraph, targetRid, itemRuntimeIdentifier))
+                if (runtimeGraph.AreCompatible(targetRid, itemRuntimeIdentifier))
                 {
                     selectedItems.Add(item);
                 }
@@ -92,26 +92,5 @@ protected override void ExecuteCore()
 
             SelectedItems = selectedItems.ToArray();
         }
-
-        /// <summary>
-        /// Determines if a candidate runtime identifier is compatible with a target runtime identifier.
-        /// </summary>
-        /// <param name="runtimeGraph">The runtime graph containing compatibility information.</param>
-        /// <param name="targetRuntimeIdentifier">The target runtime identifier.</param>
-        /// <param name="candidateRuntimeIdentifier">The candidate runtime identifier to check.</param>
-        /// <returns>True if the candidate is compatible with the target, false otherwise.</returns>
-        private static bool IsCompatibleRuntimeIdentifier(RuntimeGraph runtimeGraph, string targetRuntimeIdentifier, string candidateRuntimeIdentifier)
-        {
-            if (string.Equals(targetRuntimeIdentifier, candidateRuntimeIdentifier, StringComparison.OrdinalIgnoreCase))
-            {
-                return true;
-            }
-
-            // Get the list of compatible runtime identifiers for the target
-            var compatibleRuntimeIdentifiers = runtimeGraph.ExpandRuntime(targetRuntimeIdentifier);
-
-            // Check if the candidate runtime identifier is in the list of compatible ones
-            return compatibleRuntimeIdentifiers.Contains(candidateRuntimeIdentifier, StringComparer.OrdinalIgnoreCase);
-        }
     }
 }
\ No newline at end of file

From f351342b1ce21ba3f7fdbf1e5574490f332894a1 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 3 Sep 2025 22:40:33 +0000
Subject: [PATCH 6/7] Update nullable annotations for Required properties to
 use null! pattern

Co-authored-by: baronfel <573979+baronfel@users.noreply.github.com>
---
 .../SelectRuntimeIdentifierSpecificItems.cs   | 26 +++++--------------
 1 file changed, 6 insertions(+), 20 deletions(-)

diff --git a/src/Tasks/Microsoft.NET.Build.Tasks/SelectRuntimeIdentifierSpecificItems.cs b/src/Tasks/Microsoft.NET.Build.Tasks/SelectRuntimeIdentifierSpecificItems.cs
index 7099a8548503..04c1281d4b4c 100644
--- a/src/Tasks/Microsoft.NET.Build.Tasks/SelectRuntimeIdentifierSpecificItems.cs
+++ b/src/Tasks/Microsoft.NET.Build.Tasks/SelectRuntimeIdentifierSpecificItems.cs
@@ -20,13 +20,13 @@ public class SelectRuntimeIdentifierSpecificItems : TaskBase
         /// The target runtime identifier to check compatibility against.
         /// </summary>
         [Required]
-        public string? TargetRuntimeIdentifier { get; set; }
+        public string TargetRuntimeIdentifier { get; set; } = null!;
 
         /// <summary>
         /// The list of candidate items to filter.
         /// </summary>
         [Required]
-        public ITaskItem[]? Items { get; set; }
+        public ITaskItem[] Items { get; set; } = null!;
 
         /// <summary>
         /// The name of the MSBuild metadata to check on each item. Defaults to "RuntimeIdentifier".
@@ -37,7 +37,7 @@ public class SelectRuntimeIdentifierSpecificItems : TaskBase
         /// Path to the RuntimeIdentifierGraph file.
         /// </summary>
         [Required]
-        public string? RuntimeIdentifierGraphPath { get; set; }
+        public string RuntimeIdentifierGraphPath { get; set; } = null!;
 
         /// <summary>
         /// The filtered items that are compatible with the target runtime identifier.
@@ -47,29 +47,15 @@ public class SelectRuntimeIdentifierSpecificItems : TaskBase
 
         protected override void ExecuteCore()
         {
-            if (Items == null || Items.Length == 0)
+            if (Items.Length == 0)
             {
                 SelectedItems = Array.Empty<ITaskItem>();
                 return;
             }
 
-            string targetRid = TargetRuntimeIdentifier ?? string.Empty;
-            string ridGraphPath = RuntimeIdentifierGraphPath ?? string.Empty;
             string ridMetadata = RuntimeIdentifierItemMetadata ?? "RuntimeIdentifier";
 
-            if (string.IsNullOrEmpty(targetRid))
-            {
-                Log.LogError("TargetRuntimeIdentifier is required but was not provided.");
-                return;
-            }
-
-            if (string.IsNullOrEmpty(ridGraphPath))
-            {
-                Log.LogError("RuntimeIdentifierGraphPath is required but was not provided.");
-                return;
-            }
-
-            RuntimeGraph runtimeGraph = new RuntimeGraphCache(this).GetRuntimeGraph(ridGraphPath);
+            RuntimeGraph runtimeGraph = new RuntimeGraphCache(this).GetRuntimeGraph(RuntimeIdentifierGraphPath);
 
             var selectedItems = new List<ITaskItem>();
             
@@ -84,7 +70,7 @@ protected override void ExecuteCore()
                 }
 
                 // Check if the item's runtime identifier is compatible with the target runtime identifier
-                if (runtimeGraph.AreCompatible(targetRid, itemRuntimeIdentifier))
+                if (runtimeGraph.AreCompatible(TargetRuntimeIdentifier, itemRuntimeIdentifier))
                 {
                     selectedItems.Add(item);
                 }

From 2b0d0058c04f23527c5444266f871d5cfa7e51f1 Mon Sep 17 00:00:00 2001
From: --get <chusk3@gmail.com>
Date: Tue, 16 Sep 2025 15:58:04 -0500
Subject: [PATCH 7/7] Address Yanni's formatting feedback

---
 .../SelectRuntimeIdentifierSpecificItems.cs   | 114 +++++++++---------
 1 file changed, 55 insertions(+), 59 deletions(-)

diff --git a/src/Tasks/Microsoft.NET.Build.Tasks/SelectRuntimeIdentifierSpecificItems.cs b/src/Tasks/Microsoft.NET.Build.Tasks/SelectRuntimeIdentifierSpecificItems.cs
index 04c1281d4b4c..f3995157dfb9 100644
--- a/src/Tasks/Microsoft.NET.Build.Tasks/SelectRuntimeIdentifierSpecificItems.cs
+++ b/src/Tasks/Microsoft.NET.Build.Tasks/SelectRuntimeIdentifierSpecificItems.cs
@@ -1,82 +1,78 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System;
-using System.Collections.Generic;
-using System.Linq;
 using Microsoft.Build.Framework;
 using NuGet.RuntimeModel;
 
-namespace Microsoft.NET.Build.Tasks
+namespace Microsoft.NET.Build.Tasks;
+
+/// <summary>
+/// MSBuild task that filters a set of Items by matching on compatible RuntimeIdentifier.
+/// This task filters an Item list by those items that contain a specific Metadata that is
+/// compatible with a specified Runtime Identifier, according to a given RuntimeIdentifierGraph file.
+/// </summary>
+public class SelectRuntimeIdentifierSpecificItems : TaskBase
 {
     /// <summary>
-    /// MSBuild task that filters a set of Items by matching on compatible RuntimeIdentifier.
-    /// This task filters an Item list by those items that contain a specific Metadata that is 
-    /// compatible with a specified Runtime Identifier, according to a given RuntimeIdentifierGraph file.
+    /// The target runtime identifier to check compatibility against.
     /// </summary>
-    public class SelectRuntimeIdentifierSpecificItems : TaskBase
-    {
-        /// <summary>
-        /// The target runtime identifier to check compatibility against.
-        /// </summary>
-        [Required]
-        public string TargetRuntimeIdentifier { get; set; } = null!;
+    [Required]
+    public string TargetRuntimeIdentifier { get; set; } = null!;
 
-        /// <summary>
-        /// The list of candidate items to filter.
-        /// </summary>
-        [Required]
-        public ITaskItem[] Items { get; set; } = null!;
+    /// <summary>
+    /// The list of candidate items to filter.
+    /// </summary>
+    [Required]
+    public ITaskItem[] Items { get; set; } = null!;
 
-        /// <summary>
-        /// The name of the MSBuild metadata to check on each item. Defaults to "RuntimeIdentifier".
-        /// </summary>
-        public string? RuntimeIdentifierItemMetadata { get; set; } = "RuntimeIdentifier";
+    /// <summary>
+    /// The name of the MSBuild metadata to check on each item. Defaults to "RuntimeIdentifier".
+    /// </summary>
+    public string? RuntimeIdentifierItemMetadata { get; set; } = "RuntimeIdentifier";
 
-        /// <summary>
-        /// Path to the RuntimeIdentifierGraph file.
-        /// </summary>
-        [Required]
-        public string RuntimeIdentifierGraphPath { get; set; } = null!;
+    /// <summary>
+    /// Path to the RuntimeIdentifierGraph file.
+    /// </summary>
+    [Required]
+    public string RuntimeIdentifierGraphPath { get; set; } = null!;
 
-        /// <summary>
-        /// The filtered items that are compatible with the target runtime identifier.
-        /// </summary>
-        [Output]
-        public ITaskItem[]? SelectedItems { get; set; }
+    /// <summary>
+    /// The filtered items that are compatible with the <see cref="TargetRuntimeIdentifier"/>
+    /// </summary>
+    [Output]
+    public ITaskItem[]? SelectedItems { get; set; }
 
-        protected override void ExecuteCore()
+    protected override void ExecuteCore()
+    {
+        if (Items.Length == 0)
         {
-            if (Items.Length == 0)
-            {
-                SelectedItems = Array.Empty<ITaskItem>();
-                return;
-            }
+            SelectedItems = Array.Empty<ITaskItem>();
+            return;
+        }
 
-            string ridMetadata = RuntimeIdentifierItemMetadata ?? "RuntimeIdentifier";
+        string ridMetadata = RuntimeIdentifierItemMetadata ?? "RuntimeIdentifier";
 
-            RuntimeGraph runtimeGraph = new RuntimeGraphCache(this).GetRuntimeGraph(RuntimeIdentifierGraphPath);
+        RuntimeGraph runtimeGraph = new RuntimeGraphCache(this).GetRuntimeGraph(RuntimeIdentifierGraphPath);
 
-            var selectedItems = new List<ITaskItem>();
-            
-            foreach (var item in Items)
-            {
-                string? itemRuntimeIdentifier = item.GetMetadata(ridMetadata);
-                
-                if (string.IsNullOrEmpty(itemRuntimeIdentifier))
-                {
-                    // Item doesn't have the runtime identifier metadata, skip it
-                    continue;
-                }
+        var selectedItems = new List<ITaskItem>();
+
+        foreach (var item in Items)
+        {
+            string? itemRuntimeIdentifier = item.GetMetadata(ridMetadata);
 
-                // Check if the item's runtime identifier is compatible with the target runtime identifier
-                if (runtimeGraph.AreCompatible(TargetRuntimeIdentifier, itemRuntimeIdentifier))
-                {
-                    selectedItems.Add(item);
-                }
+            if (string.IsNullOrEmpty(itemRuntimeIdentifier))
+            {
+                // Item doesn't have the runtime identifier metadata, skip it
+                continue;
             }
 
-            SelectedItems = selectedItems.ToArray();
+            // Check if the item's runtime identifier is compatible with the target runtime identifier
+            if (runtimeGraph.AreCompatible(TargetRuntimeIdentifier, itemRuntimeIdentifier))
+            {
+                selectedItems.Add(item);
+            }
         }
+
+        SelectedItems = selectedItems.ToArray();
     }
-}
\ No newline at end of file
+}