Performance: Faster integer conversion.

Because we know that the numbers we convert are valid integers and dont contain anything except the numericals and a minus sign, we can convert the byte array faster than int.Parse().

Saves some ~10% for both integer and string deserialization, depending on the exact inputs tested. Arrays and objects also benefit because of the length segment they have.

Author: StringEpsilon

CHANGELOG.md

@@ -15,7 +15,9 @@
 - Reduced time to decode / re-encode the input string.
 - Reduced memory allocations both in the input re-encoding and the deserialization.
 - Delay the materialization of strings when deserializing. This can avoid string allocations entirely for integers,
-  doubles and floats. 
+  doubles and booleans. 
+- Improved performance for implicit deserialization of integers as well as minor improvements for implicit 
+  deserialization of arrays.
 - Improved serialization performance for strings, integers, `IList<T>`, `ExpandoObject`, Dictionaries and `PhpDynamicObject`
 
 ## Internal

PhpSerializerNET.Test/Deserialize/IntegerDeserialization.cs

@@ -15,10 +15,19 @@ public class IntegerDeserializationTest {
 	[InlineData("i:1;", 1)]
 	[InlineData("i:2147483647;", int.MaxValue)]
 	[InlineData("i:-2147483648;", int.MinValue)]
-	public void DeserializeZero(string input, int expected) {
+	public void Deserialize(string input, int expected) {
 		Assert.Equal(expected, PhpSerialization.Deserialize<int>(input));
 	}
 
+	[Theory]
+	[InlineData("i:0;", 0)]
+	[InlineData("i:1;", 1)]
+	[InlineData("i:2147483647;", int.MaxValue)]
+	[InlineData("i:-2147483648;", int.MinValue)]
+	public void DeserializeImplicit(string input, long expected) {
+		Assert.Equal(expected, PhpSerialization.Deserialize(input));
+	}
+
 	[Fact]
 	public void DeserializeToNullable() {
 		var result = PhpSerialization.Deserialize<int?>("i:1;");

PhpSerializerNET/Deserialization/PhpDeserializer.cs

@@ -9,13 +9,11 @@ This Source Code Form is subject to the terms of the Mozilla Public
 using System.Globalization;
 using System.Linq;
 using System.Reflection;
-using System.Text;
 
 namespace PhpSerializerNET;
 
 internal ref struct PhpDeserializer {
 	private readonly PhpDeserializationOptions _options;
-	private Encoding _inputEncoding;
 	private readonly Span<PhpToken> _tokens;
 	private readonly ReadOnlySpan<byte> _input;
 	private int _currentToken = 0;
@@ -24,7 +22,6 @@ internal PhpDeserializer(Span<PhpToken> tokens, ReadOnlySpan<byte> input, PhpDes
 		_options = options;
 		_input = input;
 		_tokens = tokens;
-		_inputEncoding = _options.InputEncoding;
 	}
 
 	internal object Deserialize() {

PhpSerializerNET/Deserialization/PhpTokenizer.cs

@@ -42,12 +42,11 @@ private ValueSpan GetNumbers() {
 
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	private int GetLength() {
-		if (this._input[this._position + 1] == ':') {
-			return _input[_position++] - 48;
+		int result = 0;
+		for (; this._input[this._position] != ':'; this._position++) {
+			result = result * 10 + (this._input[_position] - 48);
 		}
-		int start = this._position;
-		while (this._input[++this._position] != (byte)':') { }
-		return int.Parse(this._input.Slice(start, this._position - start), CultureInfo.InvariantCulture);
+		return result;
 	}
 
 	[MethodImpl(MethodImplOptions.AggressiveOptimization)]

PhpSerializerNET/Deserialization/ValueSpan.cs

@@ -10,7 +10,7 @@ namespace PhpSerializerNET;
 using System.Text;
 
 internal readonly struct ValueSpan {
-	private static ValueSpan _empty = new ValueSpan(0,0);
+	private static ValueSpan _empty = new ValueSpan(0, 0);
 	internal readonly int Start;
 	internal readonly int Length;
 
@@ -26,19 +26,32 @@ internal ValueSpan(int start, int length) {
 	internal double GetDouble(ReadOnlySpan<byte> input) {
 		var value = input.Slice(Start, Length);
 		return value switch {
-			[(byte)'I', (byte)'N', (byte)'F'] => double.PositiveInfinity,
-			[(byte)'-', (byte)'I', (byte)'N', (byte)'F'] => double.NegativeInfinity,
-			[(byte)'N', (byte)'A', (byte)'N'] => double.NaN,
+		[(byte)'I', (byte)'N', (byte)'F'] => double.PositiveInfinity,
+		[(byte)'-', (byte)'I', (byte)'N', (byte)'F'] => double.NegativeInfinity,
+		[(byte)'N', (byte)'A', (byte)'N'] => double.NaN,
 			_ => double.Parse(value, CultureInfo.InvariantCulture),
 		};
 	}
 
 	internal bool GetBool(ReadOnlySpan<byte> input) => input[this.Start] == '1';
 
-	internal long GetLong(ReadOnlySpan<byte> input) => long.Parse(
-		input.Slice(this.Start, this.Length),
-		CultureInfo.InvariantCulture
-	);
+	internal long GetLong(ReadOnlySpan<byte> input) {
+		// All the PHP integers we deal with here can only be the number characters and an optional "-".
+		// See also the Validator code.
+		// 'long.Parse()' has to take into account that we can skip here, making this manual approach faster.
+		var span = input.Slice(this.Start, this.Length);
+		int i = 0;
+		bool isNegative = false;
+		if (span[0] == '-') {
+			i++;
+			isNegative = true;
+		}
+		long result = 0;
+		for (; i < span.Length; i++) {
+			result = result * 10 + (span[i] - 48);
+		}
+		return isNegative ? result * -1 : result;
+	}
 
 	internal string GetString(ReadOnlySpan<byte> input, Encoding inputEncoding) {
 		return inputEncoding.GetString(input.Slice(this.Start, this.Length));