Add Name property and InteractionInputCollection with comprehensive tests

Co-authored-by: JamesNK <[email protected]>

Author: Copilot

src/Aspire.Hosting/IInteractionService.cs

@@ -1,6 +1,7 @@
 // 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;
 using System.Diagnostics.CodeAnalysis;
 
 namespace Aspire.Hosting;
@@ -80,9 +81,9 @@ public interface IInteractionService
     /// <param name="options">Optional configuration for the input dialog interaction.</param>
     /// <param name="cancellationToken">A token to cancel the operation.</param>
     /// <returns>
-    /// An <see cref="InteractionResult{T}"/> containing the user's inputs.
+    /// An <see cref="InteractionResult{T}"/> containing the user's inputs as an <see cref="InteractionInputCollection"/>.
     /// </returns>
-    Task<InteractionResult<IReadOnlyList<InteractionInput>>> PromptInputsAsync(string title, string? message, IReadOnlyList<InteractionInput> inputs, InputsDialogInteractionOptions? options = null, CancellationToken cancellationToken = default);
+    Task<InteractionResult<InteractionInputCollection>> PromptInputsAsync(string title, string? message, IReadOnlyList<InteractionInput> inputs, InputsDialogInteractionOptions? options = null, CancellationToken cancellationToken = default);
 
     /// <summary>
     /// Prompts the user with a notification.
@@ -103,6 +104,12 @@ public interface IInteractionService
 [Experimental(InteractionService.DiagnosticId, UrlFormat = "https://aka.ms/aspire/diagnostics/{0}")]
 public sealed class InteractionInput
 {
+    /// <summary>
+    /// Gets or sets the name for the input. Used for accessing inputs by name from a keyed collection.
+    /// If not specified, a name will be generated automatically.
+    /// </summary>
+    public string? Name { get; init; }
+
     /// <summary>
     /// Gets or sets the label for the input.
     /// </summary>
@@ -164,6 +171,183 @@ public int? MaxLength
     internal List<string> ValidationErrors { get; } = [];
 }
 
+/// <summary>
+/// A collection of interaction inputs that supports both indexed and name-based access.
+/// </summary>
+[Experimental(InteractionService.DiagnosticId, UrlFormat = "https://aka.ms/aspire/diagnostics/{0}")]
+public sealed class InteractionInputCollection : IReadOnlyList<InteractionInput>
+{
+    private readonly IReadOnlyList<InteractionInput> _inputs;
+    private readonly IReadOnlyDictionary<string, InteractionInput> _inputsByName;
+
+    internal InteractionInputCollection(IReadOnlyList<InteractionInput> inputs)
+    {
+        // Create a new list with proper names assigned
+        var processedInputs = new List<InteractionInput>();
+        var inputsByName = new Dictionary<string, InteractionInput>(StringComparer.OrdinalIgnoreCase);
+        var usedNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+        
+        // First pass: collect explicit names and check for duplicates
+        foreach (var input in inputs)
+        {
+            if (!string.IsNullOrWhiteSpace(input.Name))
+            {
+                if (usedNames.Contains(input.Name))
+                {
+                    throw new InvalidOperationException($"Duplicate input name '{input.Name}' found. Input names must be unique.");
+                }
+                usedNames.Add(input.Name);
+            }
+        }
+        
+        // Second pass: create new inputs with generated names where needed
+        for (int i = 0; i < inputs.Count; i++)
+        {
+            var input = inputs[i];
+            string finalName;
+            
+            if (!string.IsNullOrWhiteSpace(input.Name))
+            {
+                finalName = input.Name;
+            }
+            else
+            {
+                // Generate a unique name based on the label or index
+                string baseName = GenerateBaseName(input.Label);
+                finalName = baseName;
+                int suffix = 1;
+                
+                while (usedNames.Contains(finalName))
+                {
+                    finalName = $"{baseName}_{suffix}";
+                    suffix++;
+                }
+                
+                usedNames.Add(finalName);
+            }
+            
+            // Create a new input with the final name if it was generated
+            var finalInput = string.IsNullOrWhiteSpace(input.Name) ? 
+                new InteractionInput
+                {
+                    Name = finalName,
+                    Label = input.Label,
+                    Description = input.Description,
+                    EnableDescriptionMarkdown = input.EnableDescriptionMarkdown,
+                    InputType = input.InputType,
+                    Required = input.Required,
+                    Options = input.Options,
+                    Value = input.Value,
+                    Placeholder = input.Placeholder,
+                    MaxLength = input.MaxLength
+                } : input;
+            
+            processedInputs.Add(finalInput);
+            inputsByName[finalName] = finalInput;
+        }
+        
+        _inputs = processedInputs;
+        _inputsByName = inputsByName;
+    }
+
+    private static string GenerateBaseName(string label)
+    {
+        if (string.IsNullOrWhiteSpace(label))
+        {
+            return "Input";
+        }
+        
+        // Convert to a valid identifier-like name
+        var chars = label.ToCharArray();
+        var result = new System.Text.StringBuilder();
+        
+        for (int i = 0; i < chars.Length; i++)
+        {
+            char c = chars[i];
+            if (char.IsLetterOrDigit(c))
+            {
+                result.Append(c);
+            }
+            else if (result.Length > 0 && result[result.Length - 1] != '_')
+            {
+                result.Append('_');
+            }
+        }
+        
+        // Ensure we have a valid name
+        string name = result.ToString().Trim('_');
+        return string.IsNullOrEmpty(name) ? "Input" : name;
+    }
+
+    /// <summary>
+    /// Gets an input by its name.
+    /// </summary>
+    /// <param name="name">The name of the input.</param>
+    /// <returns>The input with the specified name.</returns>
+    /// <exception cref="KeyNotFoundException">Thrown when no input with the specified name exists.</exception>
+    public InteractionInput this[string name]
+    {
+        get
+        {
+            if (_inputsByName.TryGetValue(name, out var input))
+            {
+                return input;
+            }
+            throw new KeyNotFoundException($"No input with name '{name}' was found.");
+        }
+    }
+
+    /// <summary>
+    /// Gets an input by its index.
+    /// </summary>
+    /// <param name="index">The zero-based index of the input.</param>
+    /// <returns>The input at the specified index.</returns>
+    public InteractionInput this[int index] => _inputs[index];
+
+    /// <summary>
+    /// Gets the number of inputs in the collection.
+    /// </summary>
+    public int Count => _inputs.Count;
+
+    /// <summary>
+    /// Tries to get an input by its name.
+    /// </summary>
+    /// <param name="name">The name of the input.</param>
+    /// <param name="input">When this method returns, contains the input with the specified name, if found; otherwise, null.</param>
+    /// <returns>true if an input with the specified name was found; otherwise, false.</returns>
+    public bool TryGetByName(string name, out InteractionInput? input)
+    {
+        return _inputsByName.TryGetValue(name, out input);
+    }
+
+    /// <summary>
+    /// Determines whether the collection contains an input with the specified name.
+    /// </summary>
+    /// <param name="name">The name to locate in the collection.</param>
+    /// <returns>true if the collection contains an input with the specified name; otherwise, false.</returns>
+    public bool ContainsName(string name)
+    {
+        return _inputsByName.ContainsKey(name);
+    }
+
+    /// <summary>
+    /// Gets the names of all inputs in the collection.
+    /// </summary>
+    public IEnumerable<string> Names => _inputsByName.Keys;
+
+    /// <summary>
+    /// Returns an enumerator that iterates through the collection.
+    /// </summary>
+    /// <returns>An enumerator that can be used to iterate through the collection.</returns>
+    public IEnumerator<InteractionInput> GetEnumerator() => _inputs.GetEnumerator();
+
+    /// <summary>
+    /// Returns an enumerator that iterates through the collection.
+    /// </summary>
+    /// <returns>An enumerator that can be used to iterate through the collection.</returns>
+    IEnumerator IEnumerable.GetEnumerator() => _inputs.GetEnumerator();
+}
+
 /// <summary>
 /// Specifies the type of input for an <see cref="InteractionInput"/>.
 /// </summary>
@@ -217,7 +401,7 @@ public sealed class InputsDialogValidationContext
     /// <summary>
     /// Gets the inputs that are being validated.
     /// </summary>
-    public required IReadOnlyList<InteractionInput> Inputs { get; init; }
+    public required InteractionInputCollection Inputs { get; init; }
 
     /// <summary>
     /// Gets the cancellation token for the validation operation.

src/Aspire.Hosting/InteractionService.cs

@@ -88,24 +88,27 @@ public async Task<InteractionResult<InteractionInput>> PromptInputAsync(string t
         return InteractionResult.Ok(result.Data[0]);
     }
 
-    public async Task<InteractionResult<IReadOnlyList<InteractionInput>>> PromptInputsAsync(string title, string? message, IReadOnlyList<InteractionInput> inputs, InputsDialogInteractionOptions? options = null, CancellationToken cancellationToken = default)
+    public async Task<InteractionResult<InteractionInputCollection>> PromptInputsAsync(string title, string? message, IReadOnlyList<InteractionInput> inputs, InputsDialogInteractionOptions? options = null, CancellationToken cancellationToken = default)
     {
         EnsureServiceAvailable();
 
         cancellationToken.ThrowIfCancellationRequested();
 
         options ??= InputsDialogInteractionOptions.Default;
 
-        var newState = new Interaction(title, message, options, new Interaction.InputsInteractionInfo(inputs), cancellationToken);
+        // Create the collection early to validate names and generate missing ones
+        var inputCollection = new InteractionInputCollection(inputs);
+
+        var newState = new Interaction(title, message, options, new Interaction.InputsInteractionInfo(inputCollection), cancellationToken);
         AddInteractionUpdate(newState);
 
         using var _ = cancellationToken.Register(OnInteractionCancellation, state: newState);
 
         var completion = await newState.CompletionTcs.Task.ConfigureAwait(false);
         var inputState = completion.State as IReadOnlyList<InteractionInput>;
         return inputState == null
-            ? InteractionResult.Cancel<IReadOnlyList<InteractionInput>>()
-            : InteractionResult.Ok(inputState);
+            ? InteractionResult.Cancel<InteractionInputCollection>()
+            : InteractionResult.Ok(new InteractionInputCollection(inputState));
     }
 
     public async Task<InteractionResult<bool>> PromptNotificationAsync(string title, string message, NotificationInteractionOptions? options = null, CancellationToken cancellationToken = default)
@@ -433,12 +436,12 @@ public NotificationInteractionInfo(MessageIntent intent, string? linkText, strin
 
     internal sealed class InputsInteractionInfo : InteractionInfoBase
     {
-        public InputsInteractionInfo(IReadOnlyList<InteractionInput> inputs)
+        public InputsInteractionInfo(InteractionInputCollection inputs)
         {
             Inputs = inputs;
         }
 
-        public IReadOnlyList<InteractionInput> Inputs { get; }
+        public InteractionInputCollection Inputs { get; }
     }
 }