Merge pull request #188 from PhyxionNL/patch-1

Avoid most allocations in GetExtensionFromUri

Author: JimBobSquarePants

src/ImageSharp.Web/FormatUtilities.cs

@@ -19,71 +19,78 @@ namespace SixLabors.ImageSharp.Web
     /// </summary>
     public sealed class FormatUtilities
     {
-        private readonly IImageFormat[] imageFormats;
-        private readonly Dictionary<IImageFormat, string[]> fileExtensions = new Dictionary<IImageFormat, string[]>();
-        private readonly Dictionary<string, string> fileExtension = new Dictionary<string, string>();
+        private readonly List<string> extensions = new();
+        private readonly Dictionary<string, string> extensionsByMimeType = new();
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="FormatUtilities"/> class.
+        /// Initializes a new instance of the <see cref="FormatUtilities" /> class.
         /// </summary>
         /// <param name="options">The middleware options.</param>
         public FormatUtilities(IOptions<ImageSharpMiddlewareOptions> options)
         {
             Guard.NotNull(options, nameof(options));
 
-            // The formats contained in the configuration are used a lot in hash generation
-            // so we need them to be enumerated to remove allocations and allow indexing.
-            this.imageFormats = options.Value.Configuration.ImageFormats.ToArray();
-            for (int i = 0; i < this.imageFormats.Length; i++)
+            foreach (IImageFormat imageFormat in options.Value.Configuration.ImageFormats)
             {
-                string[] extensions = this.imageFormats[i].FileExtensions.ToArray();
-                this.fileExtensions[this.imageFormats[i]] = extensions;
-                this.fileExtension[this.imageFormats[i].DefaultMimeType] = extensions[0];
+                string[] extensions = imageFormat.FileExtensions.ToArray();
+
+                foreach (string extension in extensions)
+                {
+                    this.extensions.Add(extension);
+                }
+
+                this.extensionsByMimeType[imageFormat.DefaultMimeType] = extensions[0];
             }
         }
 
         /// <summary>
         /// Gets the file extension for the given image uri.
         /// </summary>
         /// <param name="uri">The full request uri.</param>
-        /// <returns>The <see cref="string"/>.</returns>
+        /// <returns>The <see cref="string" />.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public string GetExtensionFromUri(string uri)
         {
-            // TODO: Investigate using span to reduce allocations here.
-            string[] parts = uri.Split('?');
-            if (parts.Length > 1 && QueryHelpers.ParseQuery(parts[1]).TryGetValue(FormatWebProcessor.Format, out StringValues ext))
+            int query = uri.IndexOf('?');
+            ReadOnlySpan<char> path;
+
+            if (query > -1)
+            {
+                if (uri.Contains(FormatWebProcessor.Format, StringComparison.OrdinalIgnoreCase) && QueryHelpers.ParseQuery(uri.Substring(query)).TryGetValue(FormatWebProcessor.Format, out StringValues ext))
+                {
+                    return ext;
+                }
+
+                path = uri.AsSpan(0, query);
+            }
+            else
             {
-                return ext;
+                path = uri;
             }
 
-            string path = parts[0];
-            string extension = null;
-            int index = 0;
-            for (int i = 0; i < this.imageFormats.Length; i++)
+            int extensionIndex;
+            if ((extensionIndex = path.LastIndexOf('.')) != -1)
             {
-                for (int j = 0; j < this.fileExtensions[this.imageFormats[i]].Length; j++)
+                ReadOnlySpan<char> pathExtension = path.Slice(extensionIndex + 1);
+
+                foreach (string extension in this.extensions)
                 {
-                    int li = path.LastIndexOf($".{this.fileExtensions[this.imageFormats[i]][j]}", StringComparison.OrdinalIgnoreCase);
-                    if (li < index)
+                    if (pathExtension.Equals(extension, StringComparison.OrdinalIgnoreCase))
                     {
-                        continue;
+                        return extension;
                     }
-
-                    index = li;
-                    extension = this.fileExtensions[this.imageFormats[i]][j];
                 }
             }
 
-            return extension;
+            return null;
         }
 
         /// <summary>
         /// Gets the correct extension for the given content type (mime-type).
         /// </summary>
         /// <param name="contentType">The content type (mime-type).</param>
-        /// <returns>The <see cref="string"/>.</returns>
+        /// <returns>The <see cref="string" />.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public string GetExtensionFromContentType(string contentType) => this.fileExtension[contentType];
+        public string GetExtensionFromContentType(string contentType) => this.extensionsByMimeType[contentType];
     }
 }