wip

Author: JoshClose

performance/CsvHelper.Benchmarks/CsvHelper.Benchmarks.v3.ncrunchproject

@@ -0,0 +1,5 @@
+<ProjectConfiguration>
+  <Settings>
+    <IgnoreThisComponentCompletely>True</IgnoreThisComponentCompletely>
+  </Settings>
+</ProjectConfiguration>

src/CsvHelper.Website/CsvHelper.Website.csproj

@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net9.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>

src/CsvHelper/Compatibility/BitOperations.cs

@@ -0,0 +1,23 @@
+#if !NET8_0_OR_GREATER
+namespace System.Numerics;
+
+internal static class BitOperations
+{
+	public static int TrailingZeroCount(int value)
+	{
+		if (value == 0)
+		{
+			return 32;
+		}
+
+		var result = 0;
+		while ((value & 1) == 0)
+		{
+			value >>= 1;
+			result++;
+		}
+
+		return result;
+	}
+}
+#endif

src/CsvHelper/Compatibility/IsExternalInit.cs

@@ -0,0 +1,5 @@
+#if !NET8_0_OR_GREATER
+namespace System.Runtime.CompilerServices;
+
+internal static class IsExternalInit { }
+#endif

src/CsvHelper/Compatibility/ListExtensions.cs

@@ -0,0 +1,12 @@
+#if NET462 || NET47
+namespace System.Linq;
+
+internal static class ListExtensions
+{
+	public static List<T> Append<T>(this List<T> list, T item)
+	{
+		list.Add(item);
+		return list;
+	}
+}
+#endif

src/CsvHelper/Compatibility/TextReaderExtensions.cs

@@ -0,0 +1,29 @@
+#if !NET8_0_OR_GREATER && !NETSTANDARD2_1_OR_GREATER
+using System.Buffers;
+
+namespace System.IO;
+
+internal static class TextReaderExtensions
+{
+	public static int ReadBlock(this TextReader textReader, Span<char> buffer)
+	{
+		char[] array = ArrayPool<char>.Shared.Rent(buffer.Length);
+
+		try
+		{
+			int numRead = textReader.ReadBlock(array, 0, buffer.Length);
+			if ((uint)numRead > (uint)buffer.Length)
+			{
+				throw new IOException("Invalid read length.");
+			}
+			new Span<char>(array, 0, numRead).CopyTo(buffer);
+
+			return numRead;
+		}
+		finally
+		{
+			ArrayPool<char>.Shared.Return(array);
+		}
+	}
+}
+#endif

src/CsvHelper/Compatibility/TextWriterExtensions.cs

@@ -0,0 +1,23 @@
+#if !NET8_0_OR_GREATER && !NETSTANDARD2_1_OR_GREATER
+using System.Buffers;
+
+namespace System.IO;
+
+internal static class TextWriterExtensions
+{
+	public static void Write(this TextWriter textWriter, ReadOnlySpan<char> buffer)
+	{
+		char[] array = ArrayPool<char>.Shared.Rent(buffer.Length);
+
+		try
+		{
+			buffer.CopyTo(new Span<char>(array));
+			textWriter.Write(array, 0, buffer.Length);
+		}
+		finally
+		{
+			ArrayPool<char>.Shared.Return(array);
+		}
+	}
+}
+#endif

src/CsvHelper/Configuration/CsvOptions.cs

@@ -0,0 +1,86 @@
+using System.Globalization;
+
+namespace CsvHelper.Configuration;
+
+/// <summary>
+/// Options common to both parsing and serialization of CSV data.
+/// </summary>
+public abstract record CsvOptions
+{
+	/// <summary>
+	/// The character used to separate fields in the CSV data.<br/>
+	/// Defaults to <see cref="TextInfo.ListSeparator"/>.
+	/// </summary>
+	public char Delimiter { get; init; } = ',';
+
+	/// <summary>
+	/// The character used to escape special characters in the CSV data.<br/>
+	/// Defaults to <c>"</c> (double quote).
+	/// </summary>
+	public char Escape { get; init; } = '\"';
+
+	/// <summary>
+	/// The character used to indicate a new line in the CSV data.<br/>
+	/// If not set, \r\n will be used.<br/>
+	/// Defaults to <c>null</c>.
+	/// </summary>
+	public char? NewLine { get; init; }
+
+	/// <summary>
+	/// The mode used for parsing or serializing CSV data.<br/>
+	/// Defaults to <see cref="CsvMode.RFC4180"/>.
+	/// </summary>
+	public CsvMode Mode { get; init; }
+
+	internal int BufferSize = 0x1000;
+
+	internal virtual void Validate()
+	{
+		if (Delimiter == Escape)
+		{
+			throw new ConfigurationException($"{nameof(Delimiter)} and {nameof(Escape)} cannot be the same.");
+		}
+
+		if (Delimiter == NewLine)
+		{
+			throw new ConfigurationException($"{nameof(Delimiter)} and {nameof(NewLine)} cannot be the same.");
+		}
+
+		if (Escape == NewLine)
+		{
+			throw new ConfigurationException($"{nameof(Escape)} and {nameof(NewLine)} cannot be the same.");
+		}
+
+		if (Delimiter < 1)
+		{
+			throw new ConfigurationException($"{nameof(Delimiter)} must be greater than 0.");
+		}
+
+		if (Escape < 1)
+		{
+			throw new ConfigurationException($"{nameof(Escape)} must be greater than 0.");
+		}
+
+		if (NewLine < 1)
+		{
+			throw new ConfigurationException($"{nameof(NewLine)} must be greater than 0.");
+		}
+	}
+
+	/// <summary>
+	/// Copies the current options to a new instance of <see cref="CsvOptions"/>.<br/>
+	/// </summary>
+	/// <param name="options">The new options to copy values to.</param>
+	/// <returns>A new options with values copied to it.</returns>
+	protected CsvOptions CopyTo(CsvOptions options)
+	{
+		return options with
+		{
+			Delimiter = Delimiter,
+			Escape = Escape,
+			NewLine = NewLine,
+			Mode = Mode,
+			BufferSize = BufferSize
+		};
+	}
+}

src/CsvHelper/Configuration/CsvParserOptions.cs

@@ -0,0 +1,89 @@
+namespace CsvHelper.Configuration;
+
+/// <summary>
+/// Options for parsing CSV data.
+/// </summary>
+public record CsvParserOptions : CsvOptions
+{
+	/// <summary>
+	/// A value indicating whether fields should be cached for improved performance.
+	/// </summary>
+	public bool CacheFields { get; init; }
+
+	/// <summary>
+	/// Strategy use to find special characters in the CSV data.
+	/// </summary>
+	public ParsingStrategy? Strategy { get; init; }
+
+	/// <summary>
+	/// Creates a new instance of <see cref="CsvSerializerOptions"/> using common values from this instance.
+	/// </summary>
+	public CsvSerializerOptions ToSerializerOptions()
+	{
+		return (CsvSerializerOptions)CopyTo(new CsvSerializerOptions());
+	}
+
+	internal StringCreator StringCreator = (chars, i)
+#if NET8_0_OR_GREATER || NETSTANDARD2_1_OR_GREATER
+		=> new string(chars);
+#else
+		=> chars.ToString();
+#endif
+
+	internal int ParsedRowsSize = 8;
+
+	internal int ParsedFieldsSize = 8 * 32;
+
+	internal CsvModeParse ModeParse = Rfc4180Mode.Parse;
+
+	internal ICsvParsingStrategy ParsingStrategyImplementation = new ThrowStrategy();
+
+	internal char[] ValidSpecialCharsForIntrinsics = Enumerable
+		.Range(32, 127 - 32)
+		.Select(i => (char)i)
+		.ToList()
+		.Append('\t')
+		.Append('\r')
+		.Append('\n')
+		.ToArray();
+
+	internal override void Validate()
+	{
+		base.Validate();
+
+		// IndexOfAny does not use Vector256, so any char is valid for a special char.
+		if (Strategy == ParsingStrategy.IndexOfAny)
+		{
+			return;
+		}
+
+		if (!ValidSpecialCharsForIntrinsics.Contains(Delimiter))
+		{
+			ThrowInvalidSpecialCharsForIntrinsics(nameof(Delimiter));
+		}
+
+		if (!ValidSpecialCharsForIntrinsics.Contains(Escape))
+		{
+			ThrowInvalidSpecialCharsForIntrinsics(nameof(Escape));
+		}
+
+		if (NewLine.HasValue && !ValidSpecialCharsForIntrinsics.Contains(NewLine.Value))
+		{
+			ThrowInvalidSpecialCharsForIntrinsics(nameof(NewLine));
+		}
+	}
+
+	private void ThrowInvalidSpecialCharsForIntrinsics(string property)
+	{
+		var validChars = string.Join(", ", ValidSpecialCharsForIntrinsics.Select(c => $"'{c}'"));
+		var message = $"{property} must be in the valid range of characters." +
+			Environment.NewLine +
+			$"You can use {nameof(ReplaceTextReader)} to replace invalid chars with valid chars." +
+			Environment.NewLine +
+			$"You can also use parsing strategy {nameof(ParsingStrategy.IndexOfAny)} because it does not suffer this limitation, though parsing will be slower." +
+			Environment.NewLine +
+			$"Valid chars: {validChars}";
+
+		throw new ConfigurationException(message);
+	}
+}

src/CsvHelper/Configuration/CsvSerializerOptions.cs

@@ -0,0 +1,15 @@
+namespace CsvHelper.Configuration;
+
+/// <summary>
+/// Options for serializing CSV data.
+/// </summary>
+public record CsvSerializerOptions : CsvOptions
+{
+	/// <summary>
+	/// The function used to determine if a field should be escaped.<br/>
+	/// Default is <c>null</c>, which means fields will be escaped according to the RFC 4180 standard.
+	/// </summary>
+	public ShouldEscape? ShouldEscape { get; init; }
+
+	internal CsvModeEscape ModeEscape = Rfc4180Mode.Escape;
+}