Remove most boxing and allow custom enum converters

Author: JimBobSquarePants

src/ImageSharp.Web/Commands/CommandParser.cs

@@ -39,32 +39,40 @@ public CommandParser(IEnumerable<ICommandConverter> converters)
         /// <returns>The converted instance or the default.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public T ParseValue<T>(string value, CultureInfo culture)
-            => (T)this.ParseValue(typeof(T), value, culture);
-
-        /// <summary>
-        /// Parses the given string value converting it to the given type.
-        /// </summary>
-        /// <param name="type"> The type to convert the string to.</param>
-        /// <param name="value">The string value to parse.</param>
-        /// <param name="culture">The <see cref="CultureInfo"/> to use as the current culture.</param>
-        /// <returns>The converted instance or the default value.</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public object ParseValue(Type type, string value, CultureInfo culture)
         {
-            DebugGuard.NotNull(type, nameof(type));
             DebugGuard.NotNull(culture, nameof(culture));
 
-            // This allows us to reuse the same converter for infinite enum types.
-            Type matchType = type.IsEnum ? typeof(Enum) : type;
+            Type type = typeof(T);
+            ICommandConverter converter = Array.Find(this.converters, x => x.Type.Equals(type));
 
-            ICommandConverter converter = Array.Find(this.converters, x => x.Type.Equals(matchType));
+            if (converter != null)
+            {
+                return ((ICommandConverter<T>)converter).ConvertFrom(
+                    this,
+                    culture,
+                    WebUtility.UrlDecode(value),
+                    type);
+            }
 
-            if (converter is null)
+            // This special case allows us to reuse the same converter for infinite enum types
+            // if one has not already been configured.
+            if (type.IsEnum)
             {
-                ThrowNotSupported(type);
+                converter = Array.Find(this.converters, x => x.Type.Equals(typeof(Enum)));
+                if (converter != null)
+                {
+                    return (T)((ICommandConverter<object>)converter).ConvertFrom(
+                        this,
+                        culture,
+                        WebUtility.UrlDecode(value),
+                        type);
+                }
             }
 
-            return converter.ConvertFrom(this, culture, WebUtility.UrlDecode(value), type);
+            // We don't actually return here.
+            // The compiler just cannot see our exception.
+            ThrowNotSupported(type);
+            return default;
         }
 
         [MethodImpl(MethodImplOptions.NoInlining)]

src/ImageSharp.Web/Commands/Converters/ArrayConverter{T}.cs

@@ -4,24 +4,51 @@
 using System;
 using System.Collections.Generic;
 using System.Globalization;
+using System.Linq;
+using System.Runtime.CompilerServices;
 
 namespace SixLabors.ImageSharp.Web.Commands.Converters
 {
     /// <summary>
-    /// Converts the value of an string to a generic array.
+    /// Converts the value of a string to a generic array.
     /// </summary>
     /// <typeparam name="T">The parameter type to convert to.</typeparam>
-    internal sealed class ArrayConverter<T> : ListConverter<T>
+    internal sealed class ArrayConverter<T> : ICommandConverter<T[]>
     {
         /// <inheritdoc/>
-        public override Type Type => typeof(T[]);
+        public Type Type => typeof(T[]);
 
         /// <inheritdoc/>
-        public override object ConvertFrom(
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public T[] ConvertFrom(
             CommandParser parser,
             CultureInfo culture,
             string value,
             Type propertyType)
-            => ((List<T>)base.ConvertFrom(parser, culture, value, propertyType)).ToArray();
+        {
+            if (string.IsNullOrWhiteSpace(value))
+            {
+                return Array.Empty<T>();
+            }
+
+            var result = new List<T>();
+            foreach (string pill in GetStringArray(value, culture))
+            {
+                T item = parser.ParseValue<T>(pill, culture);
+                if (item != null)
+                {
+                    result.Add(item);
+                }
+            }
+
+            return result.ToArray();
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static string[] GetStringArray(string input, CultureInfo culture)
+        {
+            char separator = culture.TextInfo.ListSeparator[0];
+            return input.Split(separator).Select(s => s.Trim()).ToArray();
+        }
     }
 }

src/ImageSharp.Web/Commands/Converters/ColorConverter.cs

@@ -5,14 +5,15 @@
 using System.Collections.Generic;
 using System.Globalization;
 using System.Reflection;
+using System.Runtime.CompilerServices;
 using System.Text.RegularExpressions;
 
 namespace SixLabors.ImageSharp.Web.Commands.Converters
 {
     /// <summary>
     /// Allows the conversion of strings into rgba32 pixel colors.
     /// </summary>
-    internal class ColorConverter : ICommandConverter
+    internal class ColorConverter : ICommandConverter<Color>
     {
         /// <summary>
         /// The web color hexadecimal regex. Matches strings arranged
@@ -34,11 +35,12 @@ internal class ColorConverter : ICommandConverter
         public Type Type => typeof(Color);
 
         /// <inheritdoc/>
-        public object ConvertFrom(CommandParser parser, CultureInfo culture, string value, Type propertyType)
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Color ConvertFrom(CommandParser parser, CultureInfo culture, string value, Type propertyType)
         {
             if (string.IsNullOrWhiteSpace(value))
             {
-                return default(Color);
+                return default;
             }
 
             // Numeric r,g,b - r,g,b,a
@@ -81,10 +83,6 @@ public object ConvertFrom(CommandParser parser, CultureInfo culture, string valu
             return table.ContainsKey(value) ? table[value] : default;
         }
 
-        /// <summary>
-        /// Initializes color table mapping color constants.
-        /// </summary>
-        /// <returns>The <see cref="IDictionary{String, Color}"/>.</returns>
         private static IDictionary<string, Color> InitializeColorConstantsTable()
         {
             IDictionary<string, Color> table = new Dictionary<string, Color>(StringComparer.OrdinalIgnoreCase);

src/ImageSharp.Web/Commands/Converters/EnumConverter.cs

@@ -4,21 +4,24 @@
 using System;
 using System.Globalization;
 using System.Linq;
+using System.Runtime.CompilerServices;
 
 namespace SixLabors.ImageSharp.Web.Commands.Converters
 {
     /// <summary>
     /// The enum converter. Allows conversion to enumerations.
     /// </summary>
-    internal sealed class EnumConverter : ICommandConverter
+    internal sealed class EnumConverter : ICommandConverter<object>
     {
         public Type Type => typeof(Enum);
 
         /// <inheritdoc/>
         /// <remarks>
-        /// Unlike other converters the type here does not match the passed type.
+        /// Unlike other converters the <see cref="Type"/> property does not
+        /// match the <paramref name="propertyType"/> value.
         /// This allows us to reuse the same converter for infinite enum types.
         /// </remarks>
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public object ConvertFrom(
             CommandParser parser,
             CultureInfo culture,
@@ -59,6 +62,7 @@ public object ConvertFrom(
         /// <param name="input">The input string to split.</param>
         /// <param name="separator">The separator to split string by.</param>
         /// <returns>The <see cref="T:String[]"/>.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private static string[] GetStringArray(string input, char separator)
             => input.Split(separator).Select(s => s.Trim()).ToArray();
     }

src/ImageSharp.Web/Commands/Converters/ICommandConverter.cs

@@ -8,15 +8,20 @@ namespace SixLabors.ImageSharp.Web.Commands.Converters
 {
     /// <summary>
     /// Defines a contract for converting the value of a string into a different data type.
-    /// Implementations of this interface should be stateless by design.
+    /// Implementations should be stateless by design and also implement <see cref="ICommandConverter{T}"/>.
     /// </summary>
     public interface ICommandConverter
     {
         /// <summary>
-        /// Gets the type of property this converter converts.
+        /// Gets the type this converter returns.
         /// </summary>
         Type Type { get; }
+    }
 
+    /// <inheritdoc/>
+    /// <typeparam name="T">The type this converter returns.</typeparam>
+    public interface ICommandConverter<T> : ICommandConverter
+    {
         /// <summary>
         /// Converts the given string to the type of this converter, using the specified culture information.
         /// </summary>
@@ -30,6 +35,6 @@ public interface ICommandConverter
         /// <param name="value">The <see cref="string"/> to convert. </param>
         /// <param name="propertyType">The property type that the converter will convert to.</param>
         /// <exception cref="NotSupportedException">The conversion cannot be performed.</exception>
-        object ConvertFrom(CommandParser parser, CultureInfo culture, string value, Type propertyType);
+        T ConvertFrom(CommandParser parser, CultureInfo culture, string value, Type propertyType);
     }
 }

…ds/Converters/IntegralNumberConverter.cs …Converters/IntegralNumberConverter{T}.cssrc/ImageSharp.Web/Commands/Converters/IntegralNumberConverter.cs renamed to src/ImageSharp.Web/Commands/Converters/IntegralNumberConverter{T}.cs src/ImageSharp.Web/Commands/Converters/IntegralNumberConverter.cs renamed to src/ImageSharp.Web/Commands/Converters/IntegralNumberConverter{T}.cs

@@ -9,15 +9,15 @@ namespace SixLabors.ImageSharp.Web.Commands.Converters
     /// <summary>
     /// The generic converter for integral types.
     /// </summary>
-    /// <typeparam name="T">The type of object to convert to.</typeparam>
-    internal sealed class IntegralNumberConverter<T> : ICommandConverter
+    /// <inheritdoc/>
+    internal sealed class IntegralNumberConverter<T> : ICommandConverter<T>
         where T : struct, IConvertible, IComparable<T>
     {
         /// <inheritdoc/>
         public Type Type => typeof(T);
 
         /// <inheritdoc/>
-        public object ConvertFrom(
+        public T ConvertFrom(
             CommandParser parser,
             CultureInfo culture,
             string value,
@@ -26,7 +26,7 @@ public object ConvertFrom(
             if (string.IsNullOrWhiteSpace(value)
                 || Array.IndexOf(TypeConstants.IntegralTypes, propertyType) < 0)
             {
-                return default(T);
+                return default;
             }
 
             // Round the value to the nearest decimal value

src/ImageSharp.Web/Commands/Converters/ListConverter{T}.cs

@@ -5,19 +5,21 @@
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
+using System.Runtime.CompilerServices;
 
 namespace SixLabors.ImageSharp.Web.Commands.Converters
 {
     /// <summary>
-    /// Converts the value of an string to a generic list.
+    /// Converts the value of a string to a generic list.
     /// </summary>
-    /// <typeparam name="T">The type to convert from.</typeparam>
-    internal class ListConverter<T> : ICommandConverter
+    /// <typeparam name="T">The type of result to return.</typeparam>
+    internal sealed class ListConverter<T> : ICommandConverter<List<T>>
     {
-        public virtual Type Type => typeof(List<T>);
+        public Type Type => typeof(List<T>);
 
         /// <inheritdoc/>
-        public virtual object ConvertFrom(
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public List<T> ConvertFrom(
             CommandParser parser,
             CultureInfo culture,
             string value,
@@ -29,26 +31,20 @@ public virtual object ConvertFrom(
                 return result;
             }
 
-            Type type = typeof(T);
-            foreach (string pill in this.GetStringArray(value, culture))
+            foreach (string pill in GetStringArray(value, culture))
             {
-                object item = parser.ParseValue(type, pill, culture);
+                T item = parser.ParseValue<T>(pill, culture);
                 if (item != null)
                 {
-                    result.Add((T)item);
+                    result.Add(item);
                 }
             }
 
             return result;
         }
 
-        /// <summary>
-        /// Splits a string by separator to return an array of string values.
-        /// </summary>
-        /// <param name="input">The input string to split.</param>
-        /// <param name="culture">A <see cref="CultureInfo"/>. The current culture to split string by.</param>
-        /// <returns>The <see cref="T:String[]"/>.</returns>
-        protected string[] GetStringArray(string input, CultureInfo culture)
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static string[] GetStringArray(string input, CultureInfo culture)
         {
             char separator = culture.TextInfo.ListSeparator[0];
             return input.Split(separator).Select(s => s.Trim()).ToArray();

src/ImageSharp.Web/Commands/Converters/SimpleCommandConverter{T}.cs

@@ -3,30 +3,31 @@
 
 using System;
 using System.Globalization;
-using System.Text;
+using System.Runtime.CompilerServices;
 
 namespace SixLabors.ImageSharp.Web.Commands.Converters
 {
     /// <summary>
     /// The generic converter for simple types that implement <see cref="IConvertible"/>.
     /// </summary>
     /// <typeparam name="T">The type of object to convert to.</typeparam>
-    internal sealed class SimpleCommandConverter<T> : ICommandConverter
+    internal sealed class SimpleCommandConverter<T> : ICommandConverter<T>
         where T : IConvertible
     {
         /// <inheritdoc/>
         public Type Type => typeof(T);
 
         /// <inheritdoc/>
-        public object ConvertFrom(
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public T ConvertFrom(
             CommandParser parser,
             CultureInfo culture,
             string value,
             Type propertyType)
         {
             if (string.IsNullOrWhiteSpace(value))
             {
-                return default(T);
+                return default;
             }
 
             Type t = typeof(T);

src/ImageSharp.Web/Processors/ResizeWebProcessor.cs

@@ -168,10 +168,16 @@ private static IResampler GetSampler(IDictionary<string, string> commands)
             {
                 switch (sampler.ToLowerInvariant())
                 {
-                    case "nearest": return KnownResamplers.NearestNeighbor;
+                    case "nearest":
+                    case "nearestneighbor":
+                        return KnownResamplers.NearestNeighbor;
                     case "box": return KnownResamplers.Box;
-                    case "mitchell": return KnownResamplers.MitchellNetravali;
-                    case "catmull": return KnownResamplers.CatmullRom;
+                    case "mitchell":
+                    case "mitchellnetravali":
+                        return KnownResamplers.MitchellNetravali;
+                    case "catmull":
+                    case "catmullrom":
+                        return KnownResamplers.CatmullRom;
                     case "lanczos2": return KnownResamplers.Lanczos2;
                     case "lanczos3": return KnownResamplers.Lanczos3;
                     case "lanczos5": return KnownResamplers.Lanczos5;