performance imporvements, extensions, AI code fixes

Author: petesramek

benchmarks/PolylineAlgorithm.Benchmarks/PolylineAlgorithm.Benchmarks.csproj

@@ -2,8 +2,8 @@
 
 	<PropertyGroup>
 		<OutputType>Exe</OutputType>
-		<TargetFrameworks>net8.0;net9.0</TargetFrameworks>
-		<LangVersion>13.0</LangVersion>
+		<TargetFrameworks>net8.0;net9.0;net10.0;</TargetFrameworks>
+		<LangVersion>14.0</LangVersion>
 		<Nullable>enable</Nullable>
 		<ImplicitUsings>enable</ImplicitUsings>
 		<InvariantGlobalization>true</InvariantGlobalization>

benchmarks/PolylineAlgorithm.Benchmarks/PolylineBenchmark.cs

@@ -14,11 +14,14 @@ namespace PolylineAlgorithm.Benchmarks;
 /// Benchmarks for the <see cref="PolylineValue"/> struct.
 /// </summary>
 public class PolylineBenchmark {
-    private static readonly Consumer consumer = new();
+    private static readonly Consumer _consumer = new();
 
     [Params(1, 100, 1_000)]
     public int Count;
 
+    [Params(1000, 10_000, 100_000)]
+    public int Iterations;
+
 #pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider adding the 'required' modifier or declaring as nullable.
     /// <summary>
     /// Gets the character array representing the encoded polyline.
@@ -69,47 +72,55 @@ public void SetupData() {
     /// </summary>
     /// <returns>The encoded polyline.</returns>
     [Benchmark]
-    public Polyline Polyline_FromString() {
-        var polyline = Polyline
+    public void Polyline_FromString() {
+        for (int i = 0; i < Count; i++) {
+            var polyline = Polyline
             .FromString(StringValue);
 
-        return polyline;
+            _consumer.Consume(polyline);
+        }
     }
 
     /// <summary>
     /// Benchmarks the encoding of an enumeration of coordinates into a polyline.
     /// </summary>
     /// <returns>The encoded polyline.</returns>
     [Benchmark]
-    public Polyline Polyline_FromCharArray() {
-        var polyline = Polyline
+    public void Polyline_FromCharArray() {
+        for (int i = 0; i < Iterations; i++) {
+            var polyline = Polyline
             .FromCharArray(CharArrayValue);
 
-        return polyline;
+            _consumer.Consume(polyline);
+        }
     }
 
     /// <summary>
     /// Benchmarks the encoding of an enumeration of coordinates into a polyline.
     /// </summary>
     /// <returns>The encoded polyline.</returns>
     [Benchmark]
-    public Polyline Polyline_FromMemory() {
-        var polyline = Polyline
+    public void Polyline_FromMemory() {
+        for (int i = 0; i < Iterations; i++) {
+            var polyline = Polyline
             .FromMemory(MemoryValue);
 
-        return polyline;
+            _consumer.Consume(polyline);
+        }
     }
 
     /// <summary>
     /// Benchmarks the encoding of an enumeration of coordinates into a polyline.
     /// </summary>
     /// <returns>The encoded polyline.</returns>
     [Benchmark]
-    public string Polyline_ToString() {
-        var stringValue = PolylineValue
+    public void Polyline_ToString() {
+        for (int i = 0; i < Iterations; i++) {
+            var stringValue = PolylineValue
             .ToString();
 
-        return stringValue;
+            _consumer.Consume(stringValue);
+        }
     }
 
 
@@ -119,35 +130,41 @@ public string Polyline_ToString() {
     /// <returns>The encoded polyline.</returns>
     [Benchmark]
     public void Polyline_CopyTo() {
-        PolylineValue
+        for (int i = 0; i < Iterations; i++) {
+            PolylineValue
             .CopyTo(CopyToDestination);
 
-        CopyToDestination
-             .Consume(consumer);
+            CopyToDestination
+                 .Consume(_consumer);
+        }
     }
 
     /// <summary>
     /// Benchmarks the encoding of an enumeration of coordinates into a polyline.
     /// </summary>
     /// <returns>The encoded polyline.</returns>
     [Benchmark]
-    public bool Polyline_Equals_SameValue() {
-        var equals = PolylineValue
+    public void Polyline_Equals_SameValue() {
+        for (int i = 0; i < Iterations; i++) {
+            var equals = PolylineValue
             .Equals(PolylineValue);
 
-        return equals;
+            _consumer.Consume(equals);
+        }
     }
 
     /// <summary>
     /// Benchmarks the encoding of an enumeration of coordinates into a polyline.
     /// </summary>
     /// <returns>The encoded polyline.</returns>
     [Benchmark]
-    public bool Polyline_Equals_DifferentValue() {
-        var equals = PolylineValue
+    public void Polyline_Equals_DifferentValue() {
+        for (int i = 0; i < Iterations; i++) {
+            var equals = PolylineValue
             .Equals(PolylineNotEqualValue);
 
-        return equals;
+            _consumer.Consume(equals);
+        }
     }
 
 
@@ -156,10 +173,12 @@ public bool Polyline_Equals_DifferentValue() {
     /// </summary>
     /// <returns>The encoded polyline.</returns>
     [Benchmark]
-    public bool Polyline_Equals_DifferentType() {
-        var equals = PolylineValue
+    public void Polyline_Equals_DifferentType() {
+        for (int i = 0; i < Iterations; i++) {
+            var equals = PolylineValue
             .Equals(StringValue);
 
-        return equals;
+            _consumer.Consume(equals);
+        }
     }
 }

benchmarks/PolylineAlgorithm.Benchmarks/PolylineDecoderBenchmark.cs

@@ -19,6 +19,9 @@ public class PolylineDecoderBenchmark {
     [Params(1, 100, 1_000)]
     public int Count;
 
+    [Params(1000, 10_000, 100_000)]
+    public int Iterations;
+
 #pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider adding the 'required' modifier or declaring as nullable.
     /// <summary>
     /// Gets the string value representing the encoded polyline.
@@ -30,7 +33,7 @@ public class PolylineDecoderBenchmark {
     /// <summary>
     /// The polyline decoder instance.
     /// </summary>
-    public PolylineDecoder Decoder = new();
+    public readonly PolylineDecoder Decoder = new();
 
     /// <summary>
     /// Sets up the data for the benchmarks.
@@ -45,8 +48,10 @@ public void SetupData() {
     /// </summary>
     [Benchmark]
     public void PolylineDecoder_Decode() {
-        Decoder
-            .Decode(Polyline)
-            .Consume(_consumer);
+        for (int i = 0; i < Iterations; i++) {
+            Decoder
+                .Decode(Polyline)
+                .Consume(_consumer);
+        }
     }
 }

benchmarks/PolylineAlgorithm.Benchmarks/PolylineEncoderBenchmark.cs

@@ -6,17 +6,24 @@
 namespace PolylineAlgorithm.Benchmarks;
 
 using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Engines;
 using PolylineAlgorithm;
+using PolylineAlgorithm.Extensions;
 using PolylineAlgorithm.Utility;
 using System.Collections.Generic;
 
 /// <summary>
 /// Benchmarks for the <see cref="PolylineEncoder"/> class.
 /// </summary>
 public class PolylineEncoderBenchmark {
+    private readonly Consumer _consumer = new();
+
     [Params(1, 100, 1_000)]
     public int Count;
 
+    [Params(1000, 10_000, 100_000)]
+    public int Iterations;
+
 #pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider adding the 'required' modifier or declaring as nullable.
     /// <summary>
     /// Gets the enumeration of coordinates to be encoded.
@@ -32,7 +39,7 @@ public class PolylineEncoderBenchmark {
     /// <summary>
     /// The polyline encoder instance.
     /// </summary>
-    public PolylineEncoder Encoder = new();
+    public readonly PolylineEncoder Encoder = new();
 
     /// <summary>
     /// Sets up the data for the benchmarks.
@@ -48,22 +55,26 @@ public void SetupData() {
     /// </summary>
     /// <returns>The encoded polyline.</returns>
     [Benchmark]
-    public Polyline PolylineEncoder_Encode_List() {
-        var polyline = Encoder
-            .Encode(List!);
+    public void PolylineEncoder_Encode_List() {
+        for (int i = 0; i < Iterations; i++) {
+            var polyline = Encoder
+                .Encode(List!);
 
-        return polyline;
+            _consumer.Consume(polyline);
+        }
     }
 
     /// <summary>
     /// Benchmarks the encoding of an enumeration of coordinates into a polyline.
     /// </summary>
     /// <returns>The encoded polyline.</returns>
     [Benchmark]
-    public Polyline PolylineEncoder_Encode_Enumerator() {
-        var polyline = Encoder
+    public void PolylineEncoder_Encode_Enumerator() {
+        for (int i = 0; i < Iterations; i++) {
+            var polyline = Encoder
             .Encode(Enumeration!);
 
-        return polyline;
+            _consumer.Consume(polyline);
+        }
     }
 }

src/PolylineAlgorithm/Abstraction/AbstractPolylineDecoder.cs

@@ -11,7 +11,6 @@ namespace PolylineAlgorithm.Abstraction;
 using PolylineAlgorithm.Internal.Logging;
 using PolylineAlgorithm.Properties;
 using System;
-using System.Diagnostics.CodeAnalysis;
 
 /// <summary>
 /// Decodes encoded polyline strings into sequences of geographic coordinates.
@@ -83,13 +82,13 @@ public IEnumerable<TCoordinate> Decode(TPolyline polyline) {
 
         while (true) {
             // Check if we have reached the end of the sequence
-            if (position < sequence.Length) {
+            if (position >= sequence.Length) {
                 break;
             }
 
             // Read the next value from the polyline encoding
-            if (!PolylineEncoding.TryReadValue(ref latitude, sequence, ref position)
-                || !PolylineEncoding.TryReadValue(ref longitude, sequence, ref position)
+            if (!PolylineEncoding.TryReadValue(ref latitude, ref sequence, ref position)
+                || !PolylineEncoding.TryReadValue(ref longitude, ref sequence, ref position)
             ) {
                 logger
                     .LogInvalidPolylineWarning(position);
@@ -118,11 +117,11 @@ static void ValidateNullPolyline(TPolyline polyline, ILogger logger) {
         static void ValidateEmptySequence(ILogger logger, ReadOnlyMemory<char> sequence) {
             if (sequence.Length < Defaults.Polyline.Block.Length.Min) {
                 logger
-                    .LogPolylineCannotBeShorterThanWarning(nameof(sequence), sequence.Length, Defaults.Polyline.Block.Length.Min);
+                    .LogPolylineCannotBeShorterThanWarning(nameof(polyline), sequence.Length, Defaults.Polyline.Block.Length.Min);
                 logger.
                     LogOperationFailedInfo(nameof(Decode));
 
-                throw new ArgumentException(string.Format(ExceptionMessageResource.PolylineCannotBeShorterThanExceptionMessage, sequence.Length), nameof(sequence));
+                throw new ArgumentException(string.Format(ExceptionMessageResource.PolylineCannotBeShorterThanExceptionMessage, sequence.Length), nameof(polyline));
             }
         }
     }

src/PolylineAlgorithm/Abstraction/AbstractPolylineEncoder.cs

@@ -11,7 +11,6 @@ namespace PolylineAlgorithm.Abstraction;
 using PolylineAlgorithm.Internal.Logging;
 using PolylineAlgorithm.Properties;
 using System;
-using System.Collections;
 using System.Collections.Generic;
 using System.Diagnostics;
 
@@ -61,39 +60,31 @@ protected AbstractPolylineEncoder(PolylineEncodingOptions options) {
     /// <exception cref="ArgumentException">
     /// Thrown when <paramref name="coordinates"/> is an empty enumeration.
     /// </exception>
-    public TPolyline Encode(IEnumerable<TCoordinate> coordinates) {
+    public TPolyline Encode(ReadOnlySpan<TCoordinate> coordinates) {
         var logger = Options
             .LoggerFactory
             .CreateLogger<AbstractPolylineEncoder<TCoordinate, TPolyline>>();
 
         logger
             .LogOperationStartedInfo(nameof(Encode));
 
-        Debug.Assert(coordinates is not null, "Coordinates cannot be null.");
+        Debug.Assert(coordinates.Length >= 0, "Count must be non-negative.");
 
-        ValidateNullCoordinates(coordinates, logger);
-
-        int count = GetCount(coordinates);
-
-        Debug.Assert(count >= 0, "Count must be non-negative.");
-
-        ValidateEmptyCoordinates(logger, count);
+        ValidateEmptyCoordinates(coordinates, logger);
 
         CoordinateVariance variance = new();
 
         int position = 0;
         int consumed = 0;
-        int length = GetMaxBufferLength(count);
+        int length = GetMaxBufferLength(coordinates.Length);
 
         Span<char> buffer = stackalloc char[length];
 
-        using var enumerator = coordinates.GetEnumerator();
-
-        while (enumerator.MoveNext()) {
+        for (var i = 0; i < coordinates.Length; i++) {
             variance
                 .Next(
-                    PolylineEncoding.Normalize(GetLatitude(enumerator.Current), CoordinateValueType.Latitude),
-                    PolylineEncoding.Normalize(GetLongitude(enumerator.Current), CoordinateValueType.Longitude)
+                    PolylineEncoding.Normalize(GetLatitude(coordinates[i]), CoordinateValueType.Latitude),
+                    PolylineEncoding.Normalize(GetLongitude(coordinates[i]), CoordinateValueType.Longitude)
                 );
 
             ValidateBuffer(logger, variance, position, buffer);
@@ -118,11 +109,6 @@ public TPolyline Encode(IEnumerable<TCoordinate> coordinates) {
 
         return CreatePolyline(buffer[..position].ToString().AsMemory());
 
-        static int GetCount(IEnumerable<TCoordinate> coordinates) => coordinates switch {
-            ICollection collection => collection.Count,
-            _ => coordinates.Count(),
-        };
-
         static int GetRequiredLength(CoordinateVariance variance) =>
             PolylineEncoding.GetCharCount(variance.Latitude) + PolylineEncoding.GetCharCount(variance.Longitude);
 
@@ -164,8 +150,8 @@ static void ValidateNullCoordinates(IEnumerable<TCoordinate> coordinates, ILogge
             }
         }
 
-        static void ValidateEmptyCoordinates(ILogger logger, int count) {
-            if (count < 1) {
+        static void ValidateEmptyCoordinates(ReadOnlySpan<TCoordinate> coordinates, ILogger logger) {
+            if (coordinates.Length < 1) {
                 logger
                     .LogEmptyArgumentWarning(nameof(coordinates));
                 logger

src/PolylineAlgorithm/Abstraction/IPolylineEncoder.cs

@@ -4,9 +4,6 @@
 //
 
 namespace PolylineAlgorithm.Abstraction;
-
-using System.Collections.Generic;
-
 /// <summary>
 /// Defines a contract for encoding a sequence of geographic coordinates into an encoded polyline string.
 /// </summary>
@@ -20,5 +17,5 @@ public interface IPolylineEncoder<TCoordinate, TPolyline> {
     /// <returns>
     /// A <typeparamref name="TPolyline"/> containing the encoded polyline string that represents the input coordinates.
     /// </returns>
-    TPolyline Encode(IEnumerable<TCoordinate> coordinates);
+    TPolyline Encode(ReadOnlySpan<TCoordinate> coordinates);
 }