Replace generic dictionary for commands with specialized collection type.

src/ImageSharp.Web/Commands/CommandCollection.cs

@@ -0,0 +1,181 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Runtime.CompilerServices;
+
+namespace SixLabors.ImageSharp.Web.Commands
+{
+    /// <summary>
+    /// Represents an ordered collection of processing commands.
+    /// </summary>
+    public sealed class CommandCollection : KeyedCollection<string, KeyValuePair<string, string>>
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CommandCollection"/> class.
+        /// </summary>
+        public CommandCollection()
+            : this(StringComparer.OrdinalIgnoreCase)
+        {
+        }
+
+        private CommandCollection(IEqualityComparer<string> comparer)
+            : base(comparer)
+        {
+        }
+
+        /// <summary>
+        /// Gets an <see cref="IEnumerable{String}"/> representing the keys of the collection.
+        /// </summary>
+        public IEnumerable<string> Keys
+        {
+            get
+            {
+                foreach (KeyValuePair<string, string> item in this)
+                {
+                    yield return this.GetKeyForItem(item);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the value associated with the specified key.
+        /// </summary>
+        /// <param name="key">The key of the value to get or set.</param>
+        /// <returns>
+        /// The value associated with the specified key. If the specified key is not found,
+        /// a get operation throws a <see cref="KeyNotFoundException"/>, and
+        /// a set operation creates a new element with the specified key.
+        /// </returns>
+        /// <exception cref="ArgumentNullException"><paramref name="key"/> is null.</exception>
+        /// <exception cref="KeyNotFoundException">An element with the specified key does not exist in the collection.</exception>
+        public new string this[string key]
+        {
+            get
+            {
+                if (!this.TryGetValue(key, out string value))
+                {
+                    ThrowKeyNotFound();
+                }
+
+                return value;
+            }
+
+            set
+            {
+                if (this.TryGetValue(key, out KeyValuePair<string, string> item))
+                {
+                    this.SetItem(this.IndexOf(item), new(key, value));
+                }
+                else
+                {
+                    this.Add(key, value);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Adds an element with the provided key and value to the <see cref="CommandCollection"/>.
+        /// </summary>
+        /// <param name="key">The <see cref="string"/> to use as the key of the element to add.</param>
+        /// <param name="value">The <see cref="string"/> to use as the value of the element to add.</param>
+        /// <exception cref="ArgumentNullException"><paramref name="key"/> is null.</exception>
+        public void Add(string key, string value) => this.Add(new(key, value));
+
+        /// <summary>
+        /// Inserts an element into the <see cref="CommandCollection"/> at the
+        /// specified index.
+        /// </summary>
+        /// <param name="index">The zero-based index at which item should be inserted.</param>
+        /// <param name="key">The <see cref="string"/> to use as the key of the element to insert.</param>
+        /// <param name="value">The <see cref="string"/> to use as the value of the element to insert.</param>
+        /// <exception cref="ArgumentOutOfRangeException">index is less than zero. -or- index is greater than <see cref="P:CommandCollection.Count"/>.</exception>
+        public void Insert(int index, string key, string value) => this.Insert(index, new(key, value));
+
+        /// <summary>
+        /// Gets the value associated with the specified key.
+        /// </summary>
+        /// <param name="key">The key whose value to get.</param>
+        /// <param name="value">
+        /// When this method returns, the value associated with the specified key, if the
+        /// key is found; otherwise, the default value for the type of the value parameter.
+        /// This parameter is passed uninitialized.
+        /// </param>
+        /// <returns>
+        /// <see langword="true"/> if the object that implements <see cref="CommandCollection"/> contains
+        /// an element with the specified key; otherwise, <see langword="false"/>.
+        /// </returns>
+        /// <exception cref="ArgumentNullException"><paramref name="key"/> is null.</exception>
+        public bool TryGetValue(string key, out string value)
+        {
+            if (this.TryGetValue(key, out KeyValuePair<string, string> keyValue))
+            {
+                value = keyValue.Value;
+                return true;
+            }
+
+            value = default;
+            return false;
+        }
+
+        /// <summary>
+        /// Searches for an element that matches the conditions defined by the specified
+        /// predicate, and returns the zero-based index of the first occurrence within the
+        /// entire <see cref="CommandCollection"/>.
+        /// </summary>
+        /// <param name="match">
+        /// The <see cref="Predicate{T}"/> delegate that defines the conditions of the element to
+        /// search for.
+        /// </param>
+        /// <returns>
+        /// The zero-based index of the first occurrence of an element that matches the conditions
+        /// defined by match, if found; otherwise, -1.
+        /// </returns>
+        /// <exception cref="ArgumentNullException"><paramref name="match"/> is null.</exception>
+        public int FindIndex(Predicate<string> match)
+        {
+            Guard.NotNull(match, nameof(match));
+
+            int index = 0;
+            foreach (KeyValuePair<string, string> item in this)
+            {
+                if (match(item.Key))
+                {
+                    return index;
+                }
+
+                index++;
+            }
+
+            return -1;
+        }
+
+        /// <summary>
+        /// Searches for the specified key and returns the zero-based index of the first
+        /// occurrence within the entire <see cref="CommandCollection"/>.
+        /// </summary>
+        /// <param name="key">The key to locate in the <see cref="CommandCollection"/>.</param>
+        /// <returns>
+        /// The zero-based index of the first occurrence of key within the entire <see cref="CommandCollection"/>,
+        /// if found; otherwise, -1.
+        /// </returns>
+        public int IndexOf(string key)
+        {
+            if (this.TryGetValue(key, out KeyValuePair<string, string> item))
+            {
+                return this.IndexOf(item);
+            }
+
+            return -1;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        protected override string GetKeyForItem(KeyValuePair<string, string> item) => item.Key;
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private static void ThrowKeyNotFound() => throw new KeyNotFoundException();
+    }
+}

src/ImageSharp.Web/Commands/DictionaryExtensions.cs → src/ImageSharp.Web/Commands/CommandCollectionExtensions.cs

@@ -6,22 +6,20 @@
 namespace SixLabors.ImageSharp.Web.Commands
 {
     /// <summary>
-    /// Extension methods for <see cref="IDictionary{TKey, TValue}"/>.
+    /// Extension methods for <see cref="CommandCollectionExtensions"/>.
     /// </summary>
-    public static class DictionaryExtensions
+    public static class CommandCollectionExtensions
     {
         /// <summary>
         /// Gets the value associated with the specified key or the default value.
         /// </summary>
-        /// <param name="dictionary">The dictionary instance.</param>
+        /// <param name="collection">The collection instance.</param>
         /// <param name="key">The key of the value to get.</param>
-        /// <typeparam name="TValue">The value type.</typeparam>
-        /// <typeparam name="TKey">The key type.</typeparam>
         /// <returns>The value associated with the specified key or the default value.</returns>
-        public static TValue GetValueOrDefault<TValue, TKey>(this IDictionary<TKey, TValue> dictionary, TKey key)
+        public static string GetValueOrDefault(this CommandCollection collection, string key)
         {
-            dictionary.TryGetValue(key, out TValue result);
-            return result;
+            collection.TryGetValue(key, out KeyValuePair<string, string> result);
+            return result.Value;
         }
     }
 }

src/ImageSharp.Web/Commands/IRequestParser.cs

@@ -16,6 +16,6 @@ public interface IRequestParser
         /// </summary>
         /// <param name="context">Encapsulates all HTTP-specific information about an individual HTTP request.</param>
         /// <returns>The <see cref="IDictionary{TKey,TValue}"/>.</returns>
-        IDictionary<string, string> ParseRequestCommands(HttpContext context);
+        CommandCollection ParseRequestCommands(HttpContext context);
     }
 }

src/ImageSharp.Web/Commands/PresetOnlyQueryCollectionRequestParser.cs

@@ -1,4 +1,4 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
 using System;
@@ -16,7 +16,7 @@ namespace SixLabors.ImageSharp.Web.Commands
     /// </summary>
     public class PresetOnlyQueryCollectionRequestParser : IRequestParser
     {
-        private readonly IDictionary<string, IDictionary<string, string>> presets;
+        private readonly IDictionary<string, CommandCollection> presets;
 
         /// <summary>
         /// The command constant for the preset query parameter.
@@ -31,31 +31,39 @@ public PresetOnlyQueryCollectionRequestParser(IOptions<PresetOnlyQueryCollection
             this.presets = ParsePresets(presetOptions.Value.Presets);
 
         /// <inheritdoc/>
-        public IDictionary<string, string> ParseRequestCommands(HttpContext context)
+        public CommandCollection ParseRequestCommands(HttpContext context)
         {
             if (context.Request.Query.Count == 0 || !context.Request.Query.ContainsKey(QueryKey))
             {
-                return new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+                // We return new here and below to ensure the collection is still mutable via events.
+                return new();
             }
 
-            var requestedPreset = context.Request.Query["preset"][0];
-            return this.presets.GetValueOrDefault(requestedPreset) ?? new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+            string requestedPreset = context.Request.Query[QueryKey][0];
+            if (this.presets.TryGetValue(requestedPreset, out CommandCollection collection))
+            {
+                return collection;
+            }
+
+            return new();
         }
 
-        private static IDictionary<string, IDictionary<string, string>> ParsePresets(
+        private static IDictionary<string, CommandCollection> ParsePresets(
             IDictionary<string, string> unparsedPresets) =>
             unparsedPresets
                 .Select(keyValue =>
-                    new KeyValuePair<string, IDictionary<string, string>>(keyValue.Key, ParsePreset(keyValue.Value)))
+                    new KeyValuePair<string, CommandCollection>(keyValue.Key, ParsePreset(keyValue.Value)))
                 .ToDictionary(keyValue => keyValue.Key, keyValue => keyValue.Value, StringComparer.OrdinalIgnoreCase);
 
-        private static IDictionary<string, string> ParsePreset(string unparsedPresetValue)
+        private static CommandCollection ParsePreset(string unparsedPresetValue)
         {
+            // TODO: Investigate skipping the double allocation here.
+            // In .NET 6 we can directly use the QueryStringEnumerable type and enumerate stright to our command collection
             Dictionary<string, StringValues> parsed = QueryHelpers.ParseQuery(unparsedPresetValue);
-            var transformed = new Dictionary<string, string>(parsed.Count, StringComparer.OrdinalIgnoreCase);
-            foreach (KeyValuePair<string, StringValues> keyValue in parsed)
+            CommandCollection transformed = new();
+            foreach (KeyValuePair<string, StringValues> pair in parsed)
             {
-                transformed[keyValue.Key] = keyValue.Value.ToString();
+                transformed.Add(new(pair.Key, pair.Value.ToString()));
             }
 
             return transformed;

src/ImageSharp.Web/Commands/QueryCollectionRequestParser.cs

@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
-using System;
 using System.Collections.Generic;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.WebUtilities;
@@ -15,18 +14,21 @@ namespace SixLabors.ImageSharp.Web.Commands
     public sealed class QueryCollectionRequestParser : IRequestParser
     {
         /// <inheritdoc/>
-        public IDictionary<string, string> ParseRequestCommands(HttpContext context)
+        public CommandCollection ParseRequestCommands(HttpContext context)
         {
             if (context.Request.Query.Count == 0)
             {
-                return new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+                // We return new to ensure the collection is still mutable via events.
+                return new();
             }
 
+            // TODO: Investigate skipping the double allocation here.
+            // In .NET 6 we can directly use the QueryStringEnumerable type and enumerate stright to our command collection
             Dictionary<string, StringValues> parsed = QueryHelpers.ParseQuery(context.Request.QueryString.ToUriComponent());
-            var transformed = new Dictionary<string, string>(parsed.Count, StringComparer.OrdinalIgnoreCase);
+            CommandCollection transformed = new();
             foreach (KeyValuePair<string, StringValues> pair in parsed)
             {
-                transformed[pair.Key] = pair.Value.ToString();
+                transformed.Add(new(pair.Key, pair.Value.ToString()));
             }
 
             return transformed;

src/ImageSharp.Web/Middleware/ImageCommandContext.cs

@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
-using System.Collections.Generic;
 using System.Globalization;
 using Microsoft.AspNetCore.Http;
 using SixLabors.ImageSharp.Web.Commands;
@@ -22,7 +21,7 @@ public class ImageCommandContext
         /// <param name="culture">The culture used to parse commands.</param>
         public ImageCommandContext(
             HttpContext context,
-            IDictionary<string, string> commands,
+            CommandCollection commands,
             CommandParser parser,
             CultureInfo culture)
         {
@@ -38,9 +37,9 @@ public ImageCommandContext(
         public HttpContext Context { get; }
 
         /// <summary>
-        /// Gets the dictionary containing the collection of URI derived processing commands.
+        /// Gets the collection of URI derived processing commands.
         /// </summary>
-        public IDictionary<string, string> Commands { get; }
+        public CommandCollection Commands { get; }
 
         /// <summary>
         /// Gets the command parser for parsing URI derived processing commands.

src/ImageSharp.Web/Middleware/ImageProcessingContext.cs

@@ -4,6 +4,7 @@
 using System.Collections.Generic;
 using System.IO;
 using Microsoft.AspNetCore.Http;
+using SixLabors.ImageSharp.Web.Commands;
 
 namespace SixLabors.ImageSharp.Web.Middleware
 {
@@ -23,7 +24,7 @@ public class ImageProcessingContext
         public ImageProcessingContext(
             HttpContext context,
             Stream stream,
-            IDictionary<string, string> commands,
+            CommandCollection commands,
             string contentType,
             string extension)
         {
@@ -47,10 +48,10 @@ public ImageProcessingContext(
         /// <summary>
         /// Gets the parsed collection of processing commands.
         /// </summary>
-        public IDictionary<string, string> Commands { get; }
+        public CommandCollection Commands { get; }
 
         /// <summary>
-        /// Gets the content type for for the processed image.
+        /// Gets the content type for the processed image.
         /// </summary>
         public string ContentType { get; }