{"id":30178359,"url":"https://github.com/nietras/Sep","last_synced_at":"2025-08-12T05:20:38.861Z","repository":{"id":142930373,"uuid":"602555092","full_name":"nietras/Sep","owner":"nietras","description":"World's Fastest .NET CSV Parser. Modern, minimal, fast, zero allocation, reading and writing of separated values (`csv`, `tsv` etc.). Cross-platform, trimmable and AOT/NativeAOT compatible.","archived":false,"fork":false,"pushed_at":"2025-07-29T21:36:05.000Z","size":1247,"stargazers_count":1224,"open_issues_count":4,"forks_count":48,"subscribers_count":10,"default_branch":"main","last_synced_at":"2025-08-04T01:12:46.857Z","etag":null,"topics":["csharp","csv","csv-parser","csv-reader","csv-writer","dotnet","performance","simd"],"latest_commit_sha":null,"homepage":"http://nietras.com","language":"C#","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/nietras.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":"CONTRIBUTING.md","funding":null,"license":"LICENSE","code_of_conduct":"CODE_OF_CONDUCT.md","threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":"SECURITY.md","support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null}},"created_at":"2023-02-16T13:12:25.000Z","updated_at":"2025-08-03T10:58:04.000Z","dependencies_parsed_at":"2024-12-16T22:48:20.400Z","dependency_job_id":"e2af224d-f86d-4131-b9ed-63fa3808086a","html_url":"https://github.com/nietras/Sep","commit_stats":null,"previous_names":[],"tags_count":39,"template":false,"template_full_name":null,"purl":"pkg:github/nietras/Sep","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/nietras%2FSep","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/nietras%2FSep/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/nietras%2FSep/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/nietras%2FSep/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/nietras","download_url":"https://codeload.github.com/nietras/Sep/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/nietras%2FSep/sbom","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":270005591,"owners_count":24510939,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","status":"online","status_checked_at":"2025-08-12T02:00:09.011Z","response_time":80,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["csharp","csv","csv-parser","csv-reader","csv-writer","dotnet","performance","simd"],"created_at":"2025-08-12T05:20:37.187Z","updated_at":"2025-08-12T05:20:38.814Z","avatar_url":"https://github.com/nietras.png","language":"C#","funding_links":[],"categories":["Uncategorized","C# #","Misc","Audio"],"sub_categories":["Uncategorized","GUI - other"],"readme":"# Sep - the World's Fastest .NET CSV Parser\n![.NET](https://img.shields.io/badge/net8.0%20net9.0-5C2D91?logo=.NET\u0026labelColor=gray)\n![C#](https://img.shields.io/badge/C%23-13.0-239120?labelColor=gray)\n[![Build Status](https://github.com/nietras/Sep/actions/workflows/dotnet.yml/badge.svg?branch=main)](https://github.com/nietras/Sep/actions/workflows/dotnet.yml)\n[![Super-Linter](https://github.com/nietras/Sep/actions/workflows/super-linter.yml/badge.svg)](https://github.com/marketplace/actions/super-linter)\n[![codecov](https://codecov.io/gh/nietras/Sep/branch/main/graph/badge.svg?token=WN56CR3X0D)](https://codecov.io/gh/nietras/Sep)\n[![CodeQL](https://github.com/nietras/Sep/workflows/CodeQL/badge.svg)](https://github.com/nietras/Sep/actions?query=workflow%3ACodeQL)\n[![Nuget](https://img.shields.io/nuget/v/Sep?color=purple)](https://www.nuget.org/packages/Sep/)\n[![Release](https://img.shields.io/github/v/release/nietras/Sep)](https://github.com/nietras/Sep/releases/)\n[![downloads](https://img.shields.io/nuget/dt/Sep)](https://www.nuget.org/packages/Sep)\n![Size](https://img.shields.io/github/repo-size/nietras/Sep.svg)\n[![License](https://img.shields.io/github/license/nietras/Sep)](https://github.com/nietras/Sep/blob/main/LICENSE)\n[![Blog](https://img.shields.io/badge/blog-nietras.com-4993DD)](https://nietras.com)\n![GitHub Repo stars](https://img.shields.io/github/stars/nietras/Sep?style=flat)\n\nModern, minimal, fast, zero allocation, reading and writing of separated values\n(`csv`, `tsv` etc.). Cross-platform, trimmable and AOT/NativeAOT compatible.\nFeaturing an opinionated API design and pragmatic implementation targetted at\nmachine learning use cases.\n\n⭐ Please star this project if you like it. ⭐\n\n**🌃  Modern** - utilizes features such as\n[`Span\u003cT\u003e`](https://learn.microsoft.com/en-us/archive/msdn-magazine/2018/january/csharp-all-about-span-exploring-a-new-net-mainstay),\n[Generic Math](https://devblogs.microsoft.com/dotnet/dotnet-7-generic-math/)\n([`ISpanParsable\u003cT\u003e`](https://learn.microsoft.com/en-us/dotnet/api/system.ispanparsable-1)/\n[`ISpanFormattable`](https://learn.microsoft.com/en-us/dotnet/api/system.ispanformattable)),\n[`ref struct`](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/ref-struct),\n[`ArrayPool\u003cT\u003e`](https://learn.microsoft.com/en-us/dotnet/api/system.buffers.arraypool-1)\nand similar from [.NET 7+ and C#\n11+](https://nietras.com/2022/11/26/dotnet-and-csharp-versions/) for a modern\nand highly efficient implementation.\n\n**🔎 Minimal** - a succinct yet expressive API with few options and no hidden\nchanges to input or output. What you read/write is what you get. E.g. by default\nthere is no \"automatic\" escaping/unescaping of quotes or trimming of spaces. To\nenable this see [SepReaderOptions](#sepreaderoptions) and\n[Unescaping](#unescaping) and [Trimming](#trimming). See\n[SepWriterOptions](#sepwriteroptions) for [Escaping](#escaping).\n\n**🚀 Fast** - blazing fast with both architecture specific and cross-platform\nSIMD vectorized parsing incl. 64/128/256/512-bit paths e.g. AVX2, AVX-512 (.NET\n8.0+), NEON. Uses [csFastFloat](https://github.com/CarlVerret/csFastFloat) for\nfast parsing of floating points. See [detailed\nbenchmarks](#comparison-benchmarks) for cross-platform results.\n\n**🌪️ Multi-threaded** - unparalleled speed with highly efficient parallel CSV\nparsing that is [up to 35x faster than\nCsvHelper](#floats-reader-comparison-benchmarks), see\n[ParallelEnumerate](#parallelenumerate-and-enumerate) and\n[benchmarks](#comparison-benchmarks).\n\n**🌀 Async support** - efficient `ValueTask` based `async/await` support.\nRequires C# 13.0+ and for .NET 9.0+ includes `SepReader` implementing\n`IAsyncEnumerable\u003c\u003e`. See [Async Support](#async-support) for details.\n\n**🗑️ Zero allocation** - intelligent and efficient memory management allowing\nfor zero allocations after warmup incl. supporting use cases of reading or\nwriting arrays of values (e.g. features) easily without repeated allocations.\n\n**✅ Thorough tests** - great code coverage and focus on edge case testing incl.\nrandomized [fuzz testing](https://en.wikipedia.org/wiki/Fuzzing).\n\n**🌐 Cross-platform** - works on any platform, any architecture supported by\nNET. 100% managed and written in beautiful modern C#.\n\n**✂️ Trimmable and AOT/NativeAOT compatible** - no problematic reflection or\ndynamic code generation. Hence, fully\n[trimmable](https://learn.microsoft.com/en-us/dotnet/core/deploying/trimming/prepare-libraries-for-trimming)\nand\n[Ahead-of-Time](https://learn.microsoft.com/en-us/dotnet/core/deploying/native-aot/)\ncompatible. With a simple console tester program executable possible in just a\nfew MBs. 💾\n\n**🗣️ Opinionated and pragmatic** - conforms to the essentials of\n[RFC-4180](https://www.ietf.org/rfc/rfc4180.txt), but takes an opinionated and\npragmatic approach towards this especially with regards to quoting and line\nends. See section [RFC-4180](#rfc-4180).\n\n[Example](#example) | [Naming and Terminology](#naming-and-terminology) | [API](#application-programming-interface-api) | [Limitations and Constraints](#limitations-and-constraints) | [Comparison Benchmarks](#comparison-benchmarks) | [Example Catalogue](#example-catalogue) | [RFC-4180](#rfc-4180) | [FAQ](#frequently-asked-questions-faq)  | [Public API Reference](#public-api-reference)\n\n## Example\n```csharp\nvar text = \"\"\"\n           A;B;C;D;E;F\n           Sep;🚀;1;1.2;0.1;0.5\n           CSV;✅;2;2.2;0.2;1.5\n           \"\"\";\n\nusing var reader = Sep.Reader().FromText(text);   // Infers separator 'Sep' from header\nusing var writer = reader.Spec.Writer().ToText(); // Writer defined from reader 'Spec'\n                                                  // Use .FromFile(...)/ToFile(...) for files\nvar idx = reader.Header.IndexOf(\"B\");\nvar nms = new[] { \"E\", \"F\" };\n\nforeach (var readRow in reader)           // Read one row at a time\n{\n    var a = readRow[\"A\"].Span;            // Column as ReadOnlySpan\u003cchar\u003e\n    var b = readRow[idx].ToString();      // Column to string (might be pooled)\n    var c = readRow[\"C\"].Parse\u003cint\u003e();    // Parse any T : ISpanParsable\u003cT\u003e\n    var d = readRow[\"D\"].Parse\u003cfloat\u003e();  // Parse float/double fast via csFastFloat\n    var s = readRow[nms].Parse\u003cdouble\u003e(); // Parse multiple columns as Span\u003cT\u003e\n                                          // - Sep handles array allocation and reuse\n    foreach (ref var v in s) { v *= 10; }\n\n    using var writeRow = writer.NewRow(); // Start new row. Row written on Dispose.\n    writeRow[\"A\"].Set(a);                 // Set by ReadOnlySpan\u003cchar\u003e\n    writeRow[\"B\"].Set(b);                 // Set by string\n    writeRow[\"C\"].Set($\"{c * 2}\");        // Set via InterpolatedStringHandler, no allocs\n    writeRow[\"D\"].Format(d / 2);          // Format any T : ISpanFormattable\n    writeRow[nms].Format(s);              // Format multiple columns directly\n    // Columns are added on first access as ordered, header written when first row written\n}\n\nvar expected = \"\"\"\n               A;B;C;D;E;F\n               Sep;🚀;2;0.6;1;5\n               CSV;✅;4;1.1;2;15\n               \n               \"\"\";                       // Empty line at end is for line ending,\n                                          // which is always written.\nAssert.AreEqual(expected, writer.ToString());\n\n// Above example code is for demonstration purposes only.\n// Short names and repeated constants are only for demonstration.\n```\n\n## Naming and Terminology\nSep uses naming and terminology that is not based on [RFC-4180](#rfc-4180), but\nis more tailored to usage in machine learning or similar. Additionally, Sep\ntakes a pragmatic approach towards names by using short names and abbreviations\nwhere it makes sense and there should be no ambiguity given the context. That\nis, using `Sep` for `Separator` and `Col` for `Column` to keep code succinct.\n\n|Term | Description |\n|-----|-------------|\n|`Sep` | Short for separator, also called *delimiter*. E.g. comma (`,`) is the separator for the separated values in a `csv`-file. |\n|`Header` | Optional first row defining names of columns. |\n|`Row` | A row is a collection of col(umn)s, which may span multiple lines. Also called *record*. |\n|`Col` | Short for column, also called *field*. |\n|`Line` | Horizontal set of characters until a line ending; `\\r\\n`, `\\r`, `\\n`. |\n|`Index` | 0-based that is `RowIndex` will be 0 for first row (or the header if present). |\n|`Number` | 1-based that is `LineNumber` will be 1 for the first line (as in `notepad`). Given a row may span multiple lines a row can have a *From* line number and a *ToExcl* line number matching the C# range indexing syntax `[LineNumberFrom..LineNumberToExcl]`. |\n\n## Application Programming Interface (API)\nBesides being the succinct name of the library, `Sep` is both the main entry\npoint to using the library and the container for a validated separator. That is,\n`Sep` is basically defined as:\n```csharp\npublic readonly record struct Sep(char Separator);\n```\nThe separator `char` is validated upon construction and is guaranteed to be\nwithin a limited range and not being a `char` like `\"` (quote) or similar. This\ncan be seen in [src/Sep/Sep.cs](src/Sep/Sep.cs). The separator is constrained\nalso for internal optimizations, so you cannot use any `char` as a separator.\n\n⚠ Note that all types are within the namespace `nietras.SeparatedValues` and not\n`Sep` since it is problematic to have a type and a namespace with the same name.\n\nTo get started you can use `Sep` as the static entry point to building either a\nreader or writer. That is, for `SepReader`:\n```csharp\nusing var reader = Sep.Reader().FromFile(\"titanic.csv\");\n```\nwhere `.Reader()` is a convenience method corresponding to:\n```csharp\nusing var reader = Sep.Auto.Reader().FromFile(\"titanic.csv\");\n```\nwhere `Sep? Auto =\u003e null;` is a static property that returns `null` for a\nnullable `Sep` to signify that the separator should be inferred from the first\nrow, which might be a header. If the first row does not contain any of the by\ndefault supported separators or there are no rows, the default separator will be\nused.\n\n⚠ Note Sep uses `;` as the default separator, since this is what was used in an\ninternal proprietary library which Sep was built to replace. This is also to\navoid issues with comma `,` being used as a decimal separator in some locales.\nWithout having to resort to quoting.\n\nIf you want to specify the separator you can write:\n```csharp\nusing var reader = Sep.New(',').Reader().FromFile(\"titanic.csv\");\n```\nor\n```csharp\nvar sep = new Sep(',');\nusing var reader = sep.Reader().FromFile(\"titanic.csv\");\n```\nSimilarly, for `SepWriter`:\n```csharp\nusing var writer = Sep.Writer().ToFile(\"titanic.csv\");\n```\nor\n```csharp\nusing var writer = Sep.New(',').Writer().ToFile(\"titanic.csv\");\n```\nwhere you have to specify a valid separator, since it cannot be inferred. To\nfascillitate easy flow of the separator and `CultureInfo` both `SepReader` and\n`SepWriter` expose a `Spec` property of type [`SepSpec`](src/Sep/SepSpec.cs) that simply defines those\ntwo. This means you can write:\n```csharp\nusing var reader = Sep.Reader().FromFile(\"titanic.csv\");\nusing var writer = reader.Spec.Writer().ToFile(\"titanic-survivors.csv\");\n```\nwhere the `writer` then will use the separator inferred by the reader, for\nexample.\n\n### API Pattern\nIn general, both reading and writing follow a similar pattern:\n```text\nSep/Spec =\u003e SepReaderOptions =\u003e SepReader =\u003e Row =\u003e Col(s) =\u003e Span/ToString/Parse\nSep/Spec =\u003e SepWriterOptions =\u003e SepWriter =\u003e Row =\u003e Col(s) =\u003e Set/Format\n```\nwhere each continuation flows fluently from the preceding type. For example,\n`Reader()` is an extension method to `Sep` or `SepSpec` that returns a\n`SepReaderOptions`. Similarly, `Writer()` is an extension method to `Sep` or\n`SepSpec` that returns a `SepWriterOptions`.\n\n[`SepReaderOptions`](src/Sep/SepReaderOptions.cs)  and\n[`SepWriterOptions`](src/Sep/SepWriterOptions.cs) are optionally configurable.\nThat and the APIs for reader and writer is covered in the following sections.\n\nFor a complete example, see the [example](#example) above or the\n[ReadMeTest.cs](src/Sep.XyzTest/ReadMeTest.cs).\n\n⚠ Note that it is important to understand that Sep `Row`/`Col`/`Cols` are [`ref\nstruct`](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/ref-struct)s\n(please follow the `ref struct` link and understand how this limits the usage of\nthose). This is due to these types being simple *facades* or indirections to the\nunderlying reader or writer. That means you cannot use LINQ or create an array\nof all rows like `reader.ToArray()`. While for .NET9+ the reader is now\n`IEnumerable\u003c\u003e` since `ref struct`s can now be used in interfaces that have\n[`where T: allows ref\nstruct`](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/proposals/csharp-13.0/ref-struct-interfaces)\nthis still does not mean it is LINQ compatible. Hence, if you need store per row\nstate or similar you need to parse or copy to different types instead. The same\napplies to `Col`/`Cols` which point to internal state that is also reused. This\nis to avoid repeated allocations for each row and get the best possible\nperformance, while still defining a well structured and straightforward API that\nguides users to relevant functionality. See [Why SepReader Was Not IEnumerable\nUntil .NET 9 and Is Not LINQ\nCompatible](#why-sepreader-was-not-ienumerable-until-net-9-and-is-not-linq-compatible)\nfor more.\n\n⚠ For a full overview of public types and methods see [Public API\nReference](#public-api-reference).\n\n### SepReader API\n`SepReader` API has the following structure (in pseudo-C# code):\n```csharp\nusing var reader = Sep.Reader(o =\u003e o).FromFile/FromText/From...;\nvar header = reader.Header;\nvar _ = header.IndexOf/IndicesOf/NamesStartingWith...;\nforeach (var row in reader)\n{\n    var _ = row[colName/colNames].Span/ToString/Parse\u003cT\u003e...;\n    var _ = row[colIndex/colIndices].Span/ToString/Parse\u003cT\u003e...;\n}\n```\nThat is, to use `SepReader` follow the points below:\n\n 1. Optionally define `Sep` or use default automatically inferred separator.\n 1. Specify reader with optional configuration of `SepReaderOptions`. For\n    example, if a csv-file does not have a header this can be configured via:\n    ```csharp\n    Sep.Reader(o =\u003e o with { HasHeader = false })\n    ```\n    For all options see [SepReaderOptions](#sepreaderoptions).\n 1. Specify source e.g. file, text (`string`), `TextWriter`, etc. via `From`\n    extension methods.\n 1. Optionally access the header. For example, to get all columns starting with\n    `GT_` use:\n    ```csharp\n    var colNames = header.NamesStarting(\"GT_\");\n    var colIndices = header.IndicesOf(colNames);\n    ```\n 1. Enumerate rows. One row at a time.\n 1. Access a column by name or index. Or access multiple columns with names and\n    indices. `Sep` internally handles pooled allocation and reuse of arrays for\n    multiple columns.\n 1. Use `Span` to access the column directly as a `ReadOnlySpan\u003cchar\u003e`. Or use\n    `ToString` to convert to a `string`. Or use `Parse\u003cT\u003e` where `T :\n    ISpanParsable\u003cT\u003e` to parse the column `char`s to a specific type.\n\n#### SepReaderOptions\nThe following options are available:\n```csharp\n/// \u003csummary\u003e\n/// Specifies the separator used, if `null` then automatic detection \n/// is used based on first row in source.\n/// \u003c/summary\u003e\npublic Sep? Sep { get; init; } = null;\n/// \u003csummary\u003e\n/// Specifies initial internal `char` buffer length.\n/// \u003c/summary\u003e\n/// \u003cremarks\u003e\n/// The length will likely be rounded up to the nearest power of 2. A\n/// smaller buffer may end up being used if the underlying source for \u003csee\n/// cref=\"System.IO.TextReader\"/\u003e is known to be smaller. Prefer to keep the\n/// default length as that has been tuned for performance and cache sizes.\n/// Avoid making this unnecessarily large as that will likely not improve\n/// performance and may waste memory.\n/// \u003c/remarks\u003e\npublic int InitialBufferLength { get; init; } = SepDefaults.InitialBufferLength;\n/// \u003csummary\u003e\n/// Specifies the culture used for parsing. \n/// May be `null` for default culture.\n/// \u003c/summary\u003e\npublic CultureInfo? CultureInfo { get; init; } = SepDefaults.CultureInfo;\n/// \u003csummary\u003e\n/// Indicates whether the first row is a header row.\n/// \u003c/summary\u003e\npublic bool HasHeader { get; init; } = true;\n/// \u003csummary\u003e\n/// Specifies \u003csee cref=\"IEqualityComparer{T}\" /\u003e to use \n/// for comparing header column names and looking up index.\n/// \u003c/summary\u003e\npublic IEqualityComparer\u003cstring\u003e ColNameComparer { get; init; } = SepDefaults.ColNameComparer;\n/// \u003csummary\u003e\n/// Specifies the method factory used to convert a column span \n/// of `char`s to a `string`.\n/// \u003c/summary\u003e\npublic SepCreateToString CreateToString { get; init; } = SepToString.Direct;\n/// \u003csummary\u003e\n/// Disables using [csFastFloat](https://github.com/CarlVerret/csFastFloat)\n/// for parsing `float` and `double`.\n/// \u003c/summary\u003e\npublic bool DisableFastFloat { get; init; } = false;\n/// \u003csummary\u003e\n/// Disables checking if column count is the same for all rows.\n/// \u003c/summary\u003e\npublic bool DisableColCountCheck { get; init; } = false;\n/// \u003csummary\u003e\n/// Disables detecting and parsing quotes.\n/// \u003c/summary\u003e\npublic bool DisableQuotesParsing { get; init; } = false;\n/// \u003csummary\u003e\n/// Unescape quotes on column access.\n/// \u003c/summary\u003e\n/// \u003cremarks\u003e\n/// When true, if a column starts with a quote then the two outermost quotes\n/// are removed and every second inner quote is removed. Note that\n/// unquote/unescape happens in-place, which means the \u003csee\n/// cref=\"SepReader.Row.Span\" /\u003e will be modified and contain \"garbage\"\n/// state after unescaped cols before next col. This is for efficiency to\n/// avoid allocating secondary memory for unescaped columns. Header\n/// columns/names will also be unescaped.\n/// Requires \u003csee cref=\"DisableQuotesParsing\"/\u003e to be false.\n/// \u003c/remarks\u003e\npublic bool Unescape { get; init; } = false;\n/// \u003csummary\u003e\n/// Option for trimming spaces (` ` - ASCII 32) on column access.\n/// \u003c/summary\u003e\n/// \u003cremarks\u003e\n/// By default no trimming is done. See \u003csee cref=\"SepTrim\"/\u003e for options.\n/// Note that trimming may happen in-place e.g. if also unescaping, which\n/// means the \u003csee cref=\"SepReader.Row.Span\" /\u003e will be modified and contain\n/// \"garbage\" state for trimmed/unescaped cols. This is for efficiency to\n/// avoid allocating secondary memory for trimmed/unescaped columns. Header\n/// columns/names will also be trimmed. Note that only the space ` ` (ASCII\n/// 32) character is trimmed, not any whitespace character.\n/// \u003c/remarks\u003e\npublic SepTrim Trim { get; init; } = SepTrim.None;\n/// \u003csummary\u003e\n/// Forwarded to \u003csee\n/// cref=\"System.Threading.Tasks.ValueTask.ConfigureAwait(bool)\"/\u003e or\n/// similar when async methods are called.\n/// \u003c/summary\u003e\npublic bool AsyncContinueOnCapturedContext { get; init; } = false;\n```\n\n#### Unescaping\nWhile great care has been taken to ensure Sep unescaping of quotes is both\ncorrect and fast, there is always the question of how does one respond to\ninvalid input.\n\nThe below table tries to summarize the behavior of Sep vs CsvHelper and Sylvan.\nNote that all do the same for valid input. There are differences for how invalid\ninput is handled. For Sep the design choice has been based on not wanting to\nthrow exceptions and to use a principle that is both reasonably fast and simple.\n\n| Input | Valid | CsvHelper | CsvHelper¹ | Sylvan | Sep² |\n|-|-|-|-|-|-|\n| `a` | True | `a` | `a` | `a` | `a` |\n| `\"\"` | True | | | | |\n| `\"\"\"\"` | True | `\"` | `\"` | `\"` | `\"` |\n| `\"\"\"\"\"\"` | True | `\"\"` | `\"\"` | `\"\"` | `\"\"` |\n| `\"a\"` | True | `a` | `a` | `a` | `a` |\n| `\"a\"\"a\"` | True | `a\"a` | `a\"a` | `a\"a` | `a\"a` |\n| `\"a\"\"a\"\"a\"` | True | `a\"a\"a` | `a\"a\"a` | `a\"a\"a` | `a\"a\"a` |\n| `a\"\"a` | False | EXCEPTION | `a\"\"a` | `a\"\"a` | `a\"\"a` |\n| `a\"a\"a` | False | EXCEPTION | `a\"a\"a` | `a\"a\"a` | `a\"a\"a` |\n| `·\"\"·` | False | EXCEPTION | `·\"\"·` | `·\"\"·` | `·\"\"·` |\n| `·\"a\"·` | False | EXCEPTION | `·\"a\"·` | `·\"a\"·` | `·\"a\"·` |\n| `·\"\"` | False | EXCEPTION | `·\"\"` | `·\"\"` | `·\"\"` |\n| `·\"a\"` | False | EXCEPTION | `·\"a\"` | `·\"a\"` | `·\"a\"` |\n| `a\"\"\"a` | False | EXCEPTION | `a\"\"\"a` | `a\"\"\"a` | `a\"\"\"a` |\n| `\"a\"a\"a\"` | False | EXCEPTION | `aa\"a\"` | `a\"a\"a` | `aa\"a` |\n| `\"\"·` | False | EXCEPTION | `·` | `\"` | `·` |\n| `\"a\"·` | False | EXCEPTION | `a·` | `a\"` | `a·` |\n| `\"a\"\"\"a` | False | EXCEPTION | `aa` | EXCEPTION | `a\"a` |\n| `\"a\"\"\"a\"` | False | EXCEPTION | `aa\"` | `a\"a\u003cNULL\u003e` | `a\"a\"` |\n| `\"\"a\"` | False | EXCEPTION | `a\"` | `\"a` | `a\"` |\n| `\"a\"a\"` | False | EXCEPTION | `aa\"` | `a\"a` | `aa\"` |\n| `\"\"a\"a\"\"` | False | EXCEPTION | `a\"a\"\"` | `\"a\"a\"` | `a\"a\"` |\n| `\"\"\"` | False | | | EXCEPTION | `\"` |\n| `\"\"\"\"\"` | False | `\"` | `\"` | EXCEPTION | `\"\"` |\n\n`·` (middle dot) is whitespace to make this visible\n\n¹ CsvHelper with `BadDataFound = null`\n\n² Sep with `Unescape = true` in `SepReaderOptions`\n\n#### Trimming\nSep supports trimming by the [`SepTrim`](src/Sep/SepTrim.cs) flags enum, which\nhas two options as documented there. Below the result of both trimming and\nunescaping is shown in comparison to CsvHelper. Note unescaping is enabled for\nall results shown. It is possible to trim without unescaping too, of course.\n\nAs can be seen Sep supports a simple principle of trimming *before* and *after*\nunescaping with trimming before unescaping being important for unescaping if\nthere is a starting quote after spaces.\n\n| Input | CsvHelper Trim | CsvHelper InsideQuotes | CsvHelper All¹ | Sep Outer | Sep AfterUnescape | Sep All² |\n|-|-|-|-|-|-|-|\n| `a` | `a` | `a` | `a` | `a` | `a` | `a` |\n| `·a` | `a` | `·a` | `a` | `a` | `a` | `a` |\n| `a·` | `a` | `a·` | `a` | `a` | `a` | `a` |\n| `·a·` | `a` | `·a·` | `a` | `a` | `a` | `a` |\n| `·a·a·` | `a·a` | `·a·a·` | `a·a` | `a·a` | `a·a` | `a·a` |\n| `\"a\"` | `a` | `a` | `a` | `a` | `a` | `a` |\n| `\"·a\"` | `·a` | `a` | `a` | `·a` | `a` | `a` |\n| `\"a·\"` | `a·` | `a` | `a` | `a·` | `a` | `a` |\n| `\"·a·\"` | `·a·` | `a` | `a` | `·a·` | `a` | `a` |\n| `\"·a·a·\"` | `·a·a·` | `a·a` | `a·a` | `·a·a·` | `a·a` | `a·a` |\n| `·\"a\"·` | `a` | `·\"a\"·` | `a` | `a` | `\"a\"` | `a` |\n| `·\"·a\"·` | `·a` | `·\"·a\"·` | `a` | `·a` | `\"·a\"` | `a` |\n| `·\"a·\"·` | `a·` | `·\"a·\"·` | `a` | `a·` | `\"a·\"` | `a` |\n| `·\"·a·\"·` | `·a·` | `·\"·a·\"·` | `a` | `·a·` | `\"·a·\"` | `a` |\n| `·\"·a·a·\"·` | `·a·a·` | `·\"·a·a·\"·` | `a·a` | `·a·a·` | `\"·a·a·\"` | `a·a` |\n\n`·` (middle dot) is whitespace to make this visible\n\n¹ CsvHelper with `TrimOptions.Trim | TrimOptions.InsideQuotes`\n\n² Sep with `SepTrim.All = SepTrim.Outer | SepTrim.AfterUnescape` in\n`SepReaderOptions`\n\n#### SepReader Debuggability\nDebuggability is an important part of any library and while this is still a work\nin progress for Sep, `SepReader` does have a unique feature when looking at it\nand it's row or cols in a debug context. Given the below example code:\n```csharp\nvar text = \"\"\"\n           Key;Value\n           A;\"1\n           2\n           3\"\n           B;\"Apple\n           Banana\n           Orange\n           Pear\"\n           \"\"\";\nusing var reader = Sep.Reader().FromText(text);\nforeach (var row in reader)\n{\n    // Hover over reader, row or col when breaking here\n    var col = row[1];\n    if (Debugger.IsAttached \u0026\u0026 row.RowIndex == 2) { Debugger.Break(); }\n    Debug.WriteLine(col.ToString());\n}\n```\nand you are hovering over `reader` when the break is triggered then this will\nshow something like:\n```text\nString Length=55\n```\nThat is, it will show information of the source for the reader, in this case a\nstring of length 55.\n\n##### SepReader.Row Debuggability\nIf you are hovering over `row` then this will show something like:\n```text\n  2:[5..9] = \"B;\\\"Apple\\r\\nBanana\\r\\nOrange\\r\\nPear\\\"\"\n```\nThis has the format shown below.\n```text\n\u003cROWINDEX\u003e:[\u003cLINENUMBERRANGE\u003e] = \"\u003cROW\u003e\"\n```\nNote how this shows line number range `[FromIncl..ToExcl]`, as in C# [range\nexpression](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/proposals/csharp-8.0/ranges#systemrange),\nso that one can easily find the row in question in `notepad` or similar. This\nmeans Sep has to track line endings inside quotes and is an example of a feature\nthat makes Sep a bit slower but which is a price considered worth paying.\n\n\u003e GitHub doesn't show line numbers in code blocks so consider copying the\n\u003e example text to notepad or similar to see the effect.\n\nAdditionally, if you expand the `row` in the debugger (e.g. via the small\ntriangle) you will see each column of the row similar to below.\n```text\n00:'Key'   = \"B\"\n01:'Value' = \"\\\"Apple\\r\\nBanana\\r\\nOrange\\r\\nPear\\\"\"\n```\n\n##### SepReader.Col Debuggability\nIf you hover over `col` you should see:\n```text\n\"\\\"Apple\\r\\nBanana\\r\\nOrange\\r\\nPear\\\"\"\n```\n\n#### Why SepReader Was Not IEnumerable Until .NET 9 and Is Not LINQ Compatible\nAs mentioned earlier Sep only allows enumeration and access to one row at a time\nand `SepReader.Row` is just a simple *facade* or indirection to the underlying\nreader. This is why it is defined as a `ref struct`. In fact, the following\ncode:\n```csharp\nusing var reader = Sep.Reader().FromText(text);\nforeach (var row in reader)\n{ }\n```\ncan also be rewritten as:\n```csharp\nusing var reader = Sep.Reader().FromText(text);\nwhile (reader.MoveNext())\n{\n    var row = reader.Current;\n}\n```\nwhere `row` is just a *facade* for exposing row specific functionality. That is,\n`row` is still basically the `reader` underneath. Hence, let's look at using\nLINQ with `SepReader` implementing `IEnumerable\u003cSepReader.Row\u003e` and the `Row`\n*not* being a `ref struct`. Then, you would be able to write something like below:\n```csharp\nusing var reader = Sep.Reader().FromText(text);\nSepReader.Row[] rows = reader.ToArray();\n```\nGiven `Row` is just a facade for the reader, this would be equivalent to\nwriting:\n```csharp\nusing var reader = Sep.Reader().FromText(text);\nSepReader[] rows = reader.ToArray();\n```\nwhich hopefully makes it clear why this is not a good thing. The array would\neffectively be the reader repeated several times. If this would have to be\nsupported one would have to allocate memory for each row always, which would\nbasically be no different than a `ReadLine` approach as benchmarked in\n[Comparison Benchmarks](#comparison-benchmarks).\n\nThis is perhaps also the reason why no other efficient .NET CSV parser (known to\nauthor) implements an API pattern like Sep, but instead let the reader define\nall functionality directly and hence only let's you access the current row and\ncols on that. This API, however, is in this authors opinion not ideal and can be\na bit confusing, which is why Sep is designed like it is. The downside is the\nabove caveat.\n\nThe main culprit above is that for example `ToArray()` would store a `ref\nstruct` in a heap allocated array, the actual enumeration is not a problem and\nhence implementing `IEnumerable\u003cSepReader.Row\u003e` is not the problem as such. The\nproblem was that prior to .NET 9 it was not possible to implement this interface\nwith `T` being a `ref struct`, but with C# 13 `allows ref struct` and .NET 9\nhaving annotated such interfaces it is now possible and you can assign\n`SepReader` to `IEnumerable`, but most if not all of LINQ will still not work as\nshown below.\n```csharp\nvar text = \"\"\"\n           Key;Value\n           A;1.1\n           B;2.2\n           \"\"\";\nusing var reader = Sep.Reader().FromText(text);\nIEnumerable\u003cSepReader.Row\u003e enumerable = reader;\n// Currently, most LINQ methods do not work for ref types. See below.\n//\n// The type 'SepReader.Row' may not be a ref struct or a type parameter\n// allowing ref structs in order to use it as parameter 'TSource' in the\n// generic type or method 'Enumerable.Select\u003cTSource,\n// TResult\u003e(IEnumerable\u003cTSource\u003e, Func\u003cTSource, TResult\u003e)'\n//\n// enumerable.Select(row =\u003e row[\"Key\"].ToString()).ToArray();\n```\nCalling `Select` should in principle be possible if this was annotated with `allows ref struct`, but it isn't currently.\n\nIf you want to use LINQ or similar you have to first parse or transform the rows\ninto some other type and enumerate it. This is easy to do and instead of\ncounting lines you should focus on how such enumeration can be easily expressed\nusing C# iterators (aka `yield return`). With local functions this can be done\ninside a method like:\n```csharp\nvar text = \"\"\"\n           Key;Value\n           A;1.1\n           B;2.2\n           \"\"\";\nvar expected = new (string Key, double Value)[] {\n    (\"A\", 1.1),\n    (\"B\", 2.2),\n};\n\nusing var reader = Sep.Reader().FromText(text);\nvar actual = Enumerate(reader).ToArray();\n\nCollectionAssert.AreEqual(expected, actual);\n\nstatic IEnumerable\u003c(string Key, double Value)\u003e Enumerate(SepReader reader)\n{\n    foreach (var row in reader)\n    {\n        yield return (row[\"Key\"].ToString(), row[\"Value\"].Parse\u003cdouble\u003e());\n    }\n}\n```\nNow if instead refactoring this to something LINQ-compatible by defining a\ncommon `Enumerate` or similar method it could be:\n```csharp\nvar text = \"\"\"\n           Key;Value\n           A;1.1\n           B;2.2\n           \"\"\";\nvar expected = new (string Key, double Value)[] {\n    (\"A\", 1.1),\n    (\"B\", 2.2),\n};\n\nusing var reader = Sep.Reader().FromText(text);\nvar actual = Enumerate(reader,\n    row =\u003e (row[\"Key\"].ToString(), row[\"Value\"].Parse\u003cdouble\u003e()))\n    .ToArray();\n\nCollectionAssert.AreEqual(expected, actual);\n\nstatic IEnumerable\u003cT\u003e Enumerate\u003cT\u003e(SepReader reader, SepReader.RowFunc\u003cT\u003e select)\n{\n    foreach (var row in reader)\n    {\n        yield return select(row);\n    }\n}\n```\n\nIn fact, Sep provides such a convenience extension method. And, discounting the\n`Enumerate` method, this does have less boilerplate, but not really more\neffective lines of code. The issue here is that this tends to favor factoring\ncode in a way that can become very inefficient quickly. Consider if one wanted\nto only enumerate rows matching a predicate on `Key` which meant only 1% of rows\nwere to be enumerated e.g.:\n```csharp\nvar text = \"\"\"\n           Key;Value\n           A;1.1\n           B;2.2\n           \"\"\";\nvar expected = new (string Key, double Value)[] {\n    (\"B\", 2.2),\n};\n\nusing var reader = Sep.Reader().FromText(text);\nvar actual = reader.Enumerate(\n    row =\u003e (row[\"Key\"].ToString(), row[\"Value\"].Parse\u003cdouble\u003e()))\n    .Where(kv =\u003e kv.Item1.StartsWith('B'))\n    .ToArray();\n\nCollectionAssert.AreEqual(expected, actual);\n```\nThis means you are still parsing the double (which is magnitudes slower than\ngetting just the key) for all rows. Imagine if this was an array of floating\npoints or similar. Not only would you then be parsing a lot of values you would\nalso be allocated 99x arrays that aren't used after filtering with `Where`.\n\nInstead, you should focus on how to express the enumeration in a way that is\nboth efficient and easy to read. For example, the above could be rewritten as:\n```csharp\nvar text = \"\"\"\n           Key;Value\n           A;1.1\n           B;2.2\n           \"\"\";\nvar expected = new (string Key, double Value)[] {\n    (\"B\", 2.2),\n};\n\nusing var reader = Sep.Reader().FromText(text);\nvar actual = Enumerate(reader).ToArray();\n\nCollectionAssert.AreEqual(expected, actual);\n\nstatic IEnumerable\u003c(string Key, double Value)\u003e Enumerate(SepReader reader)\n{\n    foreach (var row in reader)\n    {\n        var keyCol = row[\"Key\"];\n        if (keyCol.Span.StartsWith(\"B\"))\n        {\n            yield return (keyCol.ToString(), row[\"Value\"].Parse\u003cdouble\u003e());\n        }\n    }\n}\n```\n\nTo accomodate this Sep provides an overload for `Enumerate` that is similar to:\n```csharp\nstatic IEnumerable\u003cT\u003e Enumerate\u003cT\u003e(this SepReader reader, SepReader.RowTryFunc\u003cT\u003e trySelect)\n{\n    foreach (var row in reader)\n    {\n        if (trySelect(row, out var value))\n        {\n            yield return value;\n        }\n    }\n}\n```\nWith this the above custom `Enumerate` can be replaced with:\n```csharp\nvar text = \"\"\"\n           Key;Value\n           A;1.1\n           B;2.2\n           \"\"\";\nvar expected = new (string Key, double Value)[] {\n    (\"B\", 2.2),\n};\n\nusing var reader = Sep.Reader().FromText(text);\nvar actual = reader.Enumerate((SepReader.Row row, out (string Key, double Value) kv) =\u003e\n{\n    var keyCol = row[\"Key\"];\n    if (keyCol.Span.StartsWith(\"B\"))\n    {\n        kv = (keyCol.ToString(), row[\"Value\"].Parse\u003cdouble\u003e());\n        return true;\n    }\n    kv = default;\n    return false;\n}).ToArray();\n\nCollectionAssert.AreEqual(expected, actual);\n```\n\nNote how this is pretty much the same length as the previous custom `Enumerate`.\nAlso worse due to how C# requires specifying types for `out` parameters which\nthen requires all parameter types for the lambda to be specified. Hence, in this\ncase the custom `Enumerate` does not take significantly longer to write and is a\nlot more efficient than using LINQ `.Where` (also avoids allocating a string for\nkey for each row) and is easier to debug and perhaps even read. All examples\nabove can be seen in [ReadMeTest.cs](src/Sep.XyzTest/ReadMeTest.cs).\n\nThere is a strong case for having an enumerate API though and that is for\nparallelized enumeration, which will be discussed next.\n\n#### ParallelEnumerate and Enumerate\nAs discussed in the previous section Sep provides `Enumerate` convenience\nextension methods, that should be used carefully. Alongside these there are\n`ParallelEnumerate` extension methods that provide very efficient multi-threaded\nenumeration. See [benchmarks](#comparison-benchmarks) for numbers and [Public\nAPI Reference](#public-api-reference).\n\n`ParallelEnumerate` is build on top of LINQ `AsParallel().AsOrdered()` and will\nreturn exactly the same as `Enumerate` but with enumeration parallelized. This\nwill use more memory during execution and as many threads as possible via the\n.NET thread pool. When using `ParallelEnumerate` one should, therefore (as\nalways), be certain the provided delegate does not refer to or change any\nmutable state.\n\n`ParallelEnumerate` comes with a lot of overhead compared to single-threaded\n`foreach` or `Enumerate` and should be used carefully based on measuring any\npotential benefit. Sep goes a long way to make this very efficient by using\npooled arrays and parsing multiple rows in batches, but if the source only has a\nfew rows then any benefit is unlikely.\n\nDue to `ParallelEnumerate` being based on batches of rows it is also important\nnot to \"abuse\" it in-place of LINQ `AsParallel`. The idea is to use it for\n*parsing* rows, not for doing expensive per row operations like loading an image\nor similar. In that case, you are better off using `AsParallel()` after\n`ParallelEnumerate` or `Enumerate` similarly to:\n\n```csharp\nusing var reader = Sep.Reader().FromFile(\"very-long.csv\");\nvar results = reader.ParallelEnumerate(ParseRow)\n                    .AsParallel().AsOrdered()\n                    .Select(LoadData) // Expensive load\n                    .ToList();\n```\n\nAs a rule of thumb if the time per row exceeds 1 millisecond consider moving the\nexpensive work to after `ParallelEnumerate`/`Enumerate`,\n\n### SepWriter API\n`SepWriter` API has the following structure (in pseudo-C# code):\n```csharp\nusing var writer = Sep.Writer(o =\u003e o).ToFile/ToText/To...;\nforeach (var data in EnumerateData())\n{\n    using var row = writer.NewRow();\n    var _ = row[colName/colNames].Set/Format\u003cT\u003e...;\n    var _ = row[colIndex/colIndices].Set/Format\u003cT\u003e...;\n}\n```\nThat is, to use `SepWriter` follow the points below:\n\n 1. Optionally define `Sep` or use default automatically inferred separator.\n 1. Specify writer with optional configuration of `SepWriterOptions`.\n    For all options see [SepWriterOptions](#sepwriteroptions).\n 1. Specify destination e.g. file, text (`string` via `StringWriter`),\n    `TextWriter`, etc. via `To` extension methods.\n 1. MISSING: `SepWriter` currently does not allow you to define the header up\n    front. Instead, header is defined by the order in which column names are\n    accessed/created when defining the row.\n 1. Define new rows with `NewRow`. ⚠ Be sure to dispose any new rows before\n    starting the next! For convenience Sep provides an overload for `NewRow` that\n    takes a `SepReader.Row` and copies the columns from that row to the new row:\n    ```csharp\n    using var reader = Sep.Reader().FromText(text);\n    using var writer = reader.Spec.Writer().ToText();\n    foreach (var readRow in reader)\n    {   using var writeRow = writer.NewRow(readRow); }\n    ```\n 1. Create a column by selecting by name or index. Or multiple columns via\n    indices and names. `Sep` internally handles pooled allocation and reuse of\n    arrays for multiple columns.\n 1. Use `Set` to set the column value either as a `ReadOnlySpan\u003cchar\u003e`, `string`\n    or via an interpolated string. Or use `Format\u003cT\u003e` where `T : IFormattable`\n    to format `T` to the column value.\n 1. Row is written when `Dispose` is called on the row.\n    \u003e Note this is to allow a row to be defined flexibly with both column\n    \u003e removal, moves and renames in the future. This is not yet supported.\n\n#### SepWriterOptions\nThe following options are available:\n```csharp\n/// \u003csummary\u003e\n/// Specifies the separator used.\n/// \u003c/summary\u003e\npublic Sep Sep { get; init; }\n/// \u003csummary\u003e\n/// Specifies the culture used for parsing. \n/// May be `null` for default culture.\n/// \u003c/summary\u003e\npublic CultureInfo? CultureInfo { get; init; }\n/// \u003csummary\u003e\n/// Specifies whether to write a header row \n/// before data rows. Requires all columns \n/// to have a name. Otherwise, columns can be\n/// added by indexing alone.\n/// \u003c/summary\u003e\npublic bool WriteHeader { get; init; } = true;\n/// \u003csummary\u003e\n/// Disables checking if column count is the \n/// same for all rows.\n/// \u003c/summary\u003e\n/// \u003cremarks\u003e\n/// When true, the \u003csee cref=\"ColNotSetOption\"/\u003e\n/// will define how columns that are not set\n/// are handled. For example, whether to skip\n/// or write an empty column if a column has\n/// not been set for a given row.\n/// \u003cpara\u003e\n/// If any columns are skipped, then columns of\n/// a row may, therefore, be out of sync with\n/// column names if \u003csee cref=\"WriteHeader\"/\u003e\n/// is true.\n/// \u003c/para\u003e\n/// As such, any number of columns can be\n/// written as long as done sequentially.\n/// \u003c/remarks\u003e\npublic bool DisableColCountCheck { get; init; } = false;\n/// \u003csummary\u003e\n/// Specifies how to handle columns that are \n/// not set.\n/// \u003c/summary\u003e\npublic SepColNotSetOption ColNotSetOption { get; init; } = SepColNotSetOption.Throw;\n/// \u003csummary\u003e\n/// Specifies whether to escape column names \n/// and values when writing.\n/// \u003c/summary\u003e\n/// \u003cremarks\u003e\n/// When true, if a column contains a separator \n/// (e.g. `;`), carriage return (`\\r`), line \n/// feed (`\\n` or quote (`\"`) then the column \n/// is prefixed and suffixed with quotes `\"` \n/// and any quote in the column is escaped by\n/// adding an extra quote so it becomes `\"\"`.\n/// Note that escape applies to column names \n/// too, but only the written name.\n/// \u003c/remarks\u003e\npublic bool Escape { get; init; } = false;\n/// \u003csummary\u003e\n/// Forwarded to \u003csee\n/// cref=\"System.Threading.Tasks.ValueTask.ConfigureAwait(bool)\"/\u003e or\n/// similar when async methods are called.\n/// \u003c/summary\u003e\npublic bool AsyncContinueOnCapturedContext { get; init; } = false;\n```\n\n#### Escaping\nEscaping is not enabled by default in Sep, but when it is it gives the same\nresults as other popular CSV librares as shown below. Although, CsvHelper\nappears to be escaping spaces as well, which is not necessary.\n\n| Input | CsvHelper | Sylvan | Sep¹ |\n|-|-|-|-|\n| `` | | | |\n| `·` | `\"·\"` | `·` | `·` |\n| `a` | `a` | `a` | `a` |\n| `;` | `\";\"` | `\";\"` | `\";\"` |\n| `,` | `,` | `,` | `,` |\n| `\"` | `\"\"\"\"` | `\"\"\"\"` | `\"\"\"\"` |\n| `\\r` | `\"\\r\"` | `\"\\r\"` | `\"\\r\"` |\n| `\\n` | `\"\\n\"` | `\"\\n\"` | `\"\\n\"` |\n| `a\"aa\"aaa` | `\"a\"\"aa\"\"aaa\"` | `\"a\"\"aa\"\"aaa\"` | `\"a\"\"aa\"\"aaa\"` |\n| `a;aa;aaa` | `\"a;aa;aaa\"` | `\"a;aa;aaa\"` | `\"a;aa;aaa\"` |\n\nSeparator/delimiter is set to semi-colon `;` (default for Sep)\n\n`·` (middle dot) is whitespace to make this visible\n\n`\\r`, `\\n` are carriage return and line feed special characters to make these visible\n\n¹ Sep with `Escape = true` in `SepWriterOptions`\n\n## Async Support\nSep supports efficient `ValueTask` based asynchronous reading and writing.\n\nHowever, given both `SepReader.Row` and `SepWriter.Row` are `ref struct`s, as\nthey point to internal state and should only be used one at a time,\n`async/await` usage is only supported on C# 13.0+ as this has support for **\"ref\nand unsafe in iterators and async methods\"** as covered in [What's new in C#\n13](https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-13). Please\nconsult details in that for limitations and constraints due to this.\n\nSimilarly, `SepReader` only implements `IAsyncEnumerable\u003cSepReader.Row\u003e` (and\n`IEnumerable\u003cSepReader.Row\u003e`) for .NET 9.0+/C# 13.0+ since then the interfaces\nhave been annotated with `allows ref struct` for `T`.\n\nAsync support is provided on the existing `SepReader` and `SepWriter` types\nsimilar to how `TextReader` and `TextWriter` support both sync and async usage.\nThis means you as a developer are responsible for calling async methods and\nusing `await` when necessary. See below for a simple example and consult tests\non GitHub for more examples.\n\n```csharp\nvar text = \"\"\"\n           A;B;C;D;E;F\n           Sep;🚀;1;1.2;0.1;0.5\n           CSV;✅;2;2.2;0.2;1.5\n           \n           \"\"\"; // Empty line at end is for line ending\n\nusing var reader = await Sep.Reader().FromTextAsync(text);\nawait using var writer = reader.Spec.Writer().ToText();\nawait foreach (var readRow in reader)\n{\n    await using var writeRow = writer.NewRow(readRow);\n}\nAssert.AreEqual(text, writer.ToString());\n```\n\nNote how for `SepReader` the `FromTextAsync` is suffixed with `Async` to\nindicate async creation, this is due to the reader having to read the first row\nof the source at creation to determine both separator and, if file has a header,\ncolumn names of the header. The `From*Async` call then has to be `await`ed.\nAfter that rows can be enumerated asynchronously simply by putting `await`\nbefore `foreach`. If one forgets to do that the rows will be enumerated\nsynchronously.\n\nFor `SepWriter` the usage is kind of reversed. `To*` methods have no `Async`\nvariants, since creation is synchronous. That is, `StreamWriter` is created by a\nsimple constructor call. Nothing is written until a header or row is defined and\n`Dispose`/`DisposeAsync` is called on the row.\n\nFor reader nothing needs to be asynchronously disposed, so `using` does not\nrequire `await`. However, for `SepWriter` dispose may have to write/flush data\nto underlying `TextWriter` and hence it should be using `DisposeAsync`, so you\nmust use `await using`.\n\nTo support cancellation many methods have overloads that accept a\n`CancellationToken` like the `From*Async` methods for creating a `SepReader` or\nfor example `NewRow` for `SepWriter`. Consult [Public API\nReference](#public-api-reference) for full set of available methods.\n\nAdditionally, both [SepReaderOptions](#sepreaderoptions) and\n[SepWriterOptions](#sepwriteroptions) feature the `bool\nAsyncContinueOnCapturedContext` option that is forwarded to internal\n`ConfigureAwait` calls, see the [ConfigureAwait\nFAQ](https://devblogs.microsoft.com/dotnet/configureawait-faq/) for details on\nthat.\n\n## Limitations and Constraints\nSep is designed to be minimal and fast. As such, it has some limitations and\nconstraints:\n\n* Comments `#` are not directly supported. You can skip a row by:\n   ```csharp\n   foreach (var row in reader)\n   {\n        // Skip row if starts with #\n        if (!row.Span.StartsWith(\"#\"))\n        {\n             // ...\n        }\n   }\n   ```\n   This does not allow skipping lines before a header row starting with `#`\n   though. In [Example Catalogue](#example-catalogue) a full example is given\n   detailing how to skip lines before header.\n\n## Comparison Benchmarks\nTo investigate the performance of Sep it is compared to:\n\n* [CsvHelper](https://github.com/JoshClose/csvhelper) - *the* most commonly\n   used CSV library with a staggering\n   ![downloads](https://img.shields.io/nuget/dt/csvhelper) downloads on NuGet. Fully\n   featured and battle tested.\n* [Sylvan](https://github.com/MarkPflug/Sylvan) - is well-known and has\n   previously been shown to be [the fastest CSV libraries for\n   parsing](https://www.joelverhagen.com/blog/2020/12/fastest-net-csv-parsers)\n   (Sep changes that 😉).\n* `ReadLine`/`WriteLine` - basic naive implementations that read line by line\n   and split on separator. While writing columns, separators and line endings\n   directly. Does not handle quotes or similar correctly.\n\nAll benchmarks are run from/to memory either with:\n\n* `StringReader` or `StreamReader + MemoryStream`\n* `StringWriter` or `StreamWriter + MemoryStream`\n\nThis to avoid confounding factors from reading from or writing to disk.\n\nWhen using `StringReader`/`StringWriter` each `char` counts as 2 bytes, when\nmeasuring throughput e.g. `MB/s`. When using `StreamReader`/`StreamWriter`\ncontent is UTF-8 encoded and each `char` typically counts as 1 byte, as content\nusually limited to 1 byte per char in UTF-8.  Note that in .NET for `TextReader`\nand `TextWriter` data is converted to/from `char`, but for reading such\nconversion can often be just as fast as `Memmove`.\n\nBy default only `StringReader`/`StringWriter` results are shown, if a result is\nbased on `StreamReader`/`StreamWriter` it will be called out. Usually, results\nfor `StreamReader`/`StreamWriter` are in line with `StringReader`/`StringWriter`\nbut with half the throughput due to 1 byte vs 2 bytes. For brevity they are not\nshown here.\n\nFor all benchmark results, Sep has been defined as the `Baseline` in\n[BenchmarkDotNet](https://benchmarkdotnet.org/). This means `Ratio` will be 1.00\nfor Sep. For the others `Ratio` will then show how many *times* faster Sep is\nthan that. Or how many *times* more bytes are allocated in `Alloc Ratio`.\n\n\u003e Disclaimer: Any comparison made is based on a number of preconditions and\n\u003e assumptions. Sep is a new library written from the ground up to use the latest\n\u003e and greatest features in .NET. CsvHelper has a long history and has to take\n\u003e into account backwards compatibility and still supporting older runtimes, so\n\u003e may not be able to easily utilize more recent features. Same goes for Sylvan.\n\u003e Additionally, Sep has a different feature set compared to the two. Performance\n\u003e is a feature, but not the only feature. Keep that in mind when evaluating\n\u003e results.\n\n### Runtime and Platforms\nThe following runtime is used for benchmarking:\n\n* `NET 9.0.X`\n\nNOTE: [Garbage Collection\nDATAS](https://maoni0.medium.com/dynamically-adapting-to-application-sizes-2d72fcb6f1ea)\nmode is disabled since this severely impacts (e.g. [1.7x\nslower](https://github.com/dotnet/runtime/issues/109047)) performance for some\nbenchmarks due to the bursty accumulated allocations. That is,\n`GarbageCollectionAdaptationMode` is set to `0`.\n\nThe following platforms are used for benchmarking:\n\n* `AMD EPYC 7763` (Virtual) X64 Platform Information\n  ```ini\n  OS=Ubuntu 22.04.5 LTS (Jammy Jellyfish)\n  AMD EPYC 7763, 1 CPU, 4 logical and 2 physical cores\n  ```\n* `AMD Ryzen 7 PRO 7840U` (Laptop on battery) X64 Platform Information\n  ```ini\n  OS=Windows 11 (10.0.22631.4460/23H2/2023Update/SunValley3)\n  AMD Ryzen 7 PRO 7840U w/ Radeon 780M Graphics, 1 CPU, 16 logical and 8 physical cores\n  ```\n* `AMD 5950X` (Desktop) X64 Platform Information (no longer available)\n  ```ini\n  OS=Windows 10 (10.0.19044.2846/21H2/November2021Update)\n  AMD Ryzen 9 5950X, 1 CPU, 32 logical and 16 physical cores\n  ```\n* `AMD 9950X` (Desktop) X64 Platform Information\n  ```ini\n  OS=Windows 10 (10.0.19044.3086/21H2/November2021Update)\n  AMD Ryzen 9 9950X, 1 CPU, 32 logical and 16 physical cores\n  ```\n* `Apple M1` (Virtual) ARM64 Platform Information\n  ```ini\n  OS=macOS Sonoma 14.7.1 (23H222) [Darwin 23.6.0]\n  Apple M1 (Virtual), 1 CPU, 3 logical and 3 physical cores\n  ```\n\n### Reader Comparison Benchmarks\nThe following reader scenarios are benchmarked:\n\n* [NCsvPerf](https://github.com/joelverhagen/NCsvPerf) from [The fastest CSV\n   parser in\n   .NET](https://www.joelverhagen.com/blog/2020/12/fastest-net-csv-parsers)\n* [**Floats**](#floats-reader-comparison-benchmarks) as for example in machine learning.\n\nDetails for each can be found in the following. However, for each of these 3\ndifferent scopes are benchmarked to better assertain the low-level performance\nof each library and approach and what parts of the parsing consume the most\ntime:\n\n* **Row** - for this scope only the row is enumerated. That is, for Sep all\n   that is done is:\n   ```csharp\n   foreach (var row in reader) { }\n   ```\n   this should capture parsing both row and columns but without accessing these.\n   Note that some libraries (like Sylvan) will defer work for columns to when\n   these are accessed.\n* **Cols** - for this scope all rows and all columns are enumerated. If\n   possible columns are accessed as spans, if not as strings, which then might\n   mean a string has to be allocated. That is, for Sep this is:\n   ```csharp\n   foreach (var row in reader)\n   {\n       for (var i = 0; i \u003c row.ColCount; i++)\n       {\n           var span = row[i].Span;\n       }\n   }\n   ```\n* **XYZ** - finally the full scope is performed which is specific to each of\n   the scenarios.\n\nAdditionally, as Sep supports multi-threaded parsing via `ParallelEnumerate`\nbenchmarks results with `_MT` in the method name are multi-threaded. These show\nSep provides unparalleled performance compared to any other CSV parser.\n\nThe overhead of Sep async support is also benchmarked and can be seen with\n`_Async` in the method name. Note that this is the absolute best case for async\ngiven there is no real IO involved and hence no actual asynchronous work or\ncontinuations (thus no `Task` allocations) since benchmarks run from memory\nonly. This is fine as the main purpose of the benchmark is to gauge the overhead\nof the async code path.\n\n#### NCsvPerf PackageAssets Reader Comparison Benchmarks\n[NCsvPerf](https://github.com/joelverhagen/NCsvPerf) from [The fastest CSV\n   parser in\n   .NET](https://www.joelverhagen.com/blog/2020/12/fastest-net-csv-parsers) is a\n   benchmark which in [Joel Verhagen](https://twitter.com/joelverhagen) own\n   words was defined with:\n\n\u003e My goal was to find the fastest low-level CSV parser. Essentially, all I\n\u003e wanted was a library that gave me a string[] for each line where each field in\n\u003e the line was an element in the array.\n\nWhat is great about this work is it tests a whole of 35 different libraries and\napproaches to this. Providing a great overview of those and their performance on\nthis specific scenario. Given Sylvan is the fastest of those it is used as the\none to beat here, while CsvHelper is used to compare to the most commonly used\nlibrary.\n\nThe source used for this benchmark [PackageAssetsBench.cs](src/Sep.ComparisonBenchmarks/PackageAssetsBench.cs) is a\n[PackageAssets.csv](https://raw.githubusercontent.com/joelverhagen/NCsvPerf/main/NCsvPerf/TestData/PackageAssets.csv)\nwith NuGet package information in 25 columns with rows like:\n```text\n75fcf875-017d-4579-bfd9-791d3e6767f0,2020-11-28T01:50:41.2449947+00:00,Akinzekeel.BlazorGrid,0.9.1-preview,2020-11-27T22:42:54.3100000+00:00,AvailableAssets,RuntimeAssemblies,,,net5.0,,,,,,lib/net5.0/BlazorGrid.dll,BlazorGrid.dll,.dll,lib,net5.0,.NETCoreApp,5.0.0.0,,,0.0.0.0\n75fcf875-017d-4579-bfd9-791d3e6767f0,2020-11-28T01:50:41.2449947+00:00,Akinzekeel.BlazorGrid,0.9.1-preview,2020-11-27T22:42:54.3100000+00:00,AvailableAssets,CompileLibAssemblies,,,net5.0,,,,,,lib/net5.0/BlazorGrid.dll,BlazorGrid.dll,.dll,lib,net5.0,.NETCoreApp,5.0.0.0,,,0.0.0.0\n75fcf875-017d-4579-bfd9-791d3e6767f0,2020-11-28T01:50:41.2449947+00:00,Akinzekeel.BlazorGrid,0.9.1-preview,2020-11-27T22:42:54.3100000+00:00,AvailableAssets,ResourceAssemblies,,,net5.0,,,,,,lib/net5.0/de/BlazorGrid.resources.dll,BlazorGrid.resources.dll,.dll,lib,net5.0,.NETCoreApp,5.0.0.0,,,0.0.0.0\n75fcf875-017d-4579-bfd9-791d3e6767f0,2020-11-28T01:50:41.2449947+00:00,Akinzekeel.BlazorGrid,0.9.1-preview,2020-11-27T22:42:54.3100000+00:00,AvailableAssets,MSBuildFiles,,,any,,,,,,build/Microsoft.AspNetCore.StaticWebAssets.props,Microsoft.AspNetCore.StaticWebAssets.props,.props,build,any,Any,0.0.0.0,,,0.0.0.0\n75fcf875-017d-4579-bfd9-791d3e6767f0,2020-11-28T01:50:41.2449947+00:00,Akinzekeel.BlazorGrid,0.9.1-preview,2020-11-27T22:42:54.3100000+00:00,AvailableAssets,MSBuildFiles,,,any,,,,,,build/Akinzekeel.BlazorGrid.props,Akinzekeel.BlazorGrid.props,.props,build,any,Any,0.0.0.0,,,0.0.0.0\n```\nFor `Scope = Asset` the columns are parsed into a\n[`PackageAsset`](src/Sep.ComparisonBenchmarks/PackageAsset.cs) class, which\nconsists of 25 properties of which 22 are `string`s. Each asset is accumulated\ninto a `List\u003cPackageAsset\u003e`. Each column is accessed as a `string` regardless.\n\nThis means this benchmark is dominated by turning columns into `string`s for the\ndecently fast parsers. Hence, the fastest libraries in this test employ string\npooling. That is, basically a custom dictionary from `ReadOnlySpan\u003cchar\u003e` to\n`string`, which avoids allocating a new `string` for repeated values. And as can\nbe seen in the csv-file there are a lot of repeated values. Both Sylvan and\nCsvHelper do this in the benchmark. So does Sep and as with Sep this is an\noptional configuration that has to be explicitly enable. For Sep this means the\nreader is created with something like:\n```csharp\nusing var reader = Sep.Reader(o =\u003e o with\n{\n    HasHeader = false,\n    CreateToString = SepToString.PoolPerCol(maximumStringLength: 128),\n})\n.From(CreateReader());\n```\nWhat is unique for Sep is that it allows defining a pool per column e.g. via\n`SepToString.PoolPerCol(...)`. This is based on the fact\nthat often each column has its own set of values or strings that may be repeated\nwithout any overlap to other columns. This also allows one to define per column\nspecific handling of `ToString` behavior. Whether to pool or not. Or even to use\na statically defined pool.\n\nSep supports unescaping via an option, see [SepReaderOptions](#sepreaderoptions)\nand [Unescaping](#unescaping). Therefore, Sep has two methods being tested. The\ndefault `Sep` without unescaping and `Sep_Unescape` where unescaping is enabled.\nNote that only if there are quotes will there be any unescaping, but to support\nunescape one has to track extra state during parsing which means there is a\nslight cost no matter what, most notably for the `Cols` scope. Sep is still the\nfastest of all (by far in many cases).\n\n##### PackageAssets Benchmark Results\nThe results below show Sep is **the fastest .NET CSV Parser** (for this\nbenchmark on these platforms and machines 😀). While for pure parsing allocating\nonly a fraction of the memory due to extensive use of pooling and the\n`ArrayPool\u003cT\u003e`.\n\nThis is in many aspects due to Sep having extremely optimized string pooling and\noptimized hashing of `ReadOnlySpan\u003cchar\u003e`, and thus not really due the the\ncsv-parsing itself, since that is not a big part of the time consumed. At least\nnot for a decently fast csv-parser.\n\nWith `ParallelEnumerate` (MT) Sep is **\u003e2x faster than Sylvan and up to 9x\nfaster than CsvHelper**.\n\nAt the lowest level of enumerating rows only, that is csv parsing only, **Sep\nhits a staggering 21 GB/s on 9950X**. Single-threaded.\n\n###### AMD.EPYC.7763 - PackageAssets Benchmark Results (Sep 0.11.0.0, Sylvan  1.4.2.0, CsvHelper 33.1.0.26)\n\n| Method       | Scope | Rows    | Mean         | Ratio | MB  | MB/s   | ns/row | Allocated     | Alloc Ratio |\n|------------- |------ |-------- |-------------:|------:|----:|-------:|-------:|--------------:|------------:|\n| Sep______    | Row   | 50000   |     3.586 ms |  1.00 |  29 | 8110.7 |   71.7 |       1.03 KB |        1.00 |\n| Sep_Async    | Row   | 50000   |     3.646 ms |  1.02 |  29 | 7978.2 |   72.9 |       1.03 KB |        1.00 |\n| Sep_Unescape | Row   | 50000   |     3.564 ms |  0.99 |  29 | 8161.3 |   71.3 |       1.15 KB |        1.12 |\n| Sylvan___    | Row   | 50000   |     4.421 ms |  1.23 |  29 | 6578.6 |   88.4 |       7.66 KB |        7.47 |\n| ReadLine_    | Row   | 50000   |    22.687 ms |  6.33 |  29 | 1282.0 |  453.7 |    88608.3 KB |   86,414.19 |\n| CsvHelper    | Row   | 50000   |    63.425 ms | 17.69 |  29 |  458.6 | 1268.5 |      20.12 KB |       19.62 |\n|              |       |         |              |       |     |        |        |               |             |\n| Sep______    | Cols  | 50000   |     4.788 ms |  1.00 |  29 | 6075.3 |   95.8 |       1.03 KB |        1.00 |\n| Sep_Unescape | Cols  | 50000   |     5.757 ms |  1.20 |  29 | 5052.2 |  115.1 |       1.04 KB |        1.00 |\n| Sylvan___    | Cols  | 50000   |     8.431 ms |  1.76 |  29 | 3450.1 |  168.6 |       8.03 KB |        7.78 |\n| ReadLine_    | Cols  | 50000   |    24.198 ms |  5.05 |  29 | 1202.0 |  484.0 |   88608.32 KB |   85,841.93 |\n| CsvHelper    | Cols  | 50000   |   110.904 ms | 23.17 |  29 |  262.3 | 2218.1 |     445.93 KB |      432.01 |\n|              |       |         |              |       |     |        |        |               |             |\n| Sep______    | Asset | 50000   |    40.065 ms |  1.00 |  29 |  726.0 |  801.3 |   13802.85 KB |        1.00 |\n| Sep_MT___    | Asset | 50000   |    28.673 ms |  0.72 |  29 | 1014.4 |  573.5 |   13858.63 KB |        1.00 |\n| Sylvan___    | Asset | 50000   |    51.127 ms |  1.28 |  29 |  568.9 | 1022.5 |   13962.26 KB |        1.01 |\n| ReadLine_    | Asset | 50000   |   122.110 ms |  3.05 |  29 |  238.2 | 2442.2 |  102134.64 KB |        7.40 |\n| CsvHelper    | Asset | 50000   |   127.405 ms |  3.18 |  29 |  228.3 | 2548.1 |   13974.95 KB |        1.01 |\n|              |       |         |              |       |     |        |        |               |             |\n| Sep______    | Asset | 1000000 |   860.730 ms |  1.00 | 581 |  676.0 |  860.7 |  266670.27 KB |        1.00 |\n| Sep_MT___    | Asset | 1000000 |   500.834 ms |  0.58 | 581 | 1161.8 |  500.8 |  274965.85 KB |        1.03 |\n| Sylvan___    | Asset | 1000000 | 1,039.885 ms |  1.21 | 581 |  559.6 | 1039.9 |   266826.6 KB |        1.00 |\n| ReadLine_    | Asset | 1000000 | 2,666.458 ms |  3.10 | 581 |  218.2 | 2666.5 | 2038838.18 KB |        7.65 |\n| CsvHelper    | Asset | 1000000 | 2,589.531 ms |  3.01 | 581 |  224.7 | 2589.5 |  266841.23 KB |        1.00 |\n\n###### AMD.Ryzen.7.PRO.7840U.w.Radeon.780M - PackageAssets Benchmark Results (Sep 0.10.0.0, Sylvan  1.4.1.0, CsvHelper 33.0.1.24)\n\n| Method       | Scope | Rows    | Mean         | Ratio | MB  | MB/s   | ns/row | Allocated     | Alloc Ratio |\n|------------- |------ |-------- |-------------:|------:|----:|-------:|-------:|--------------:|------------:|\n| Sep______    | Row   | 50000   |     3.449 ms |  1.00 |  29 | 8461.8 |   69.0 |       1.02 KB |        1.00 |\n| Sep_Async    | Row   | 50000   |     3.650 ms |  1.06 |  29 | 7995.5 |   73.0 |       1.02 KB |        1.00 |\n| Sep_Unescape | Row   | 50000   |     3.565 ms |  1.03 |  29 | 8184.9 |   71.3 |       1.02 KB |        1.00 |\n| Sylvan___    | Row   | 50000   |     4.536 ms |  1.32 |  29 | 6432.6 |   90.7 |       7.66 KB |        7.50 |\n| ReadLine_    | Row   | 50000   |    20.179 ms |  5.85 |  29 | 1446.1 |  403.6 |   88608.27 KB |   86,744.62 |\n| CsvHelper    | Row   | 50000   |    62.865 ms | 18.23 |  29 |  464.2 | 1257.3 |      20.07 KB |       19.64 |\n|              |       |         |              |       |     |        |        |               |             |\n| Sep______    | Cols  | 50000   |     5.030 ms |  1.00 |  29 | 5801.5 |  100.6 |       1.03 KB |        1.00 |\n| Sep_Unescape | Cols  | 50000   |     5.806 ms |  1.15 |  29 | 5025.7 |  116.1 |       1.03 KB |        1.00 |\n| Sylvan___    | Cols  | 50000   |     7.502 ms |  1.49 |  29 | 3889.7 |  150.0 |       7.67 KB |        7.46 |\n| ReadLine_    | Cols  | 50000   |    21.399 ms |  4.25 |  29 | 1363.7 |  428.0 |   88608.28 KB |   86,167.97 |\n| CsvHelper    | Cols  | 50000   |   109.575 ms | 21.78 |  29 |  266.3 | 2191.5 |     448.88 KB |      436.51 |\n|              |       |         |              |       |     |        |        |               |             |\n| Sep______    | Asset | 50000   |    52.163 ms |  1.00 |  29 |  559.4 | 1043.3 |   13803.17 KB |        1.00 |\n| Sep_MT___    | Asset | 50000   |    32.842 ms |  0.63 |  29 |  888.5 |  656.8 |   13920.79 KB |        1.01 |\n| Sylvan___    | Asset | 50000   |    58.391 ms |  1.12 |  29 |  499.8 | 1167.8 |   13962.64 KB |        1.01 |\n| ReadLine_    | Asset | 50000   |   171.508 ms |  3.30 |  29 |  170.1 | 3430.2 |  102134.46 KB |        7.40 |\n| CsvHelper    | Asset | 50000   |   132.390 ms |  2.55 |  29 |  220.4 | 2647.8 |   13971.94 KB |        1.01 |\n|              |       |         |              |       |     |        |        |               |             |\n| Sep______    | Asset | 1000000 |   992.044 ms |  1.00 | 583 |  588.5 |  992.0 |  266670.83 KB |        1.00 |\n| Sep_MT___    | Asset | 1000000 |   487.203 ms |  0.49 | 583 | 1198.2 |  487.2 |  269058.01 KB |        1.01 |\n| Sylvan___    | Asset | 1000000 | 1,195.871 ms |  1.21 | 583 |  488.2 | 1195.9 |  266826.02 KB |        1.00 |\n| ReadLine_    | Asset | 1000000 | 3,254.174 ms |  3.28 | 583 |  179.4 | 3254.2 | 2038843.73 KB |        7.65 |\n| CsvHelper    | Asset | 1000000 | 2,644.197 ms |  2.67 | 583 |  220.8 | 2644.2 |  266841.13 KB |        1.00 |\n\n###### AMD.Ryzen.9.5950X - PackageAssets Benchmark Results (Sep 0.9.0.0, Sylvan  1.3.9.0, CsvHelper 33.0.1.24)\n\n| Method       | Scope | Rows    | Mean         | Ratio | MB  | MB/s    | ns/row | Allocated     | Alloc Ratio |\n|------------- |------ |-------- |-------------:|------:|----:|--------:|-------:|--------------:|------------:|\n| Sep______    | Row   | 50000   |     2.230 ms |  1.00 |  29 | 13088.4 |   44.6 |       1.09 KB |        1.00 |\n| Sep_Async    | Row   | 50000   |     2.379 ms |  1.07 |  29 | 12264.0 |   47.6 |       1.02 KB |        0.93 |\n| Sep_Unescape | Row   | 50000   |     2.305 ms |  1.03 |  29 | 12657.6 |   46.1 |       1.02 KB |        0.93 |\n| Sylvan___    | Row   | 50000   |     2.993 ms |  1.33 |  29 |  9750.2 |   59.9 |       7.65 KB |        7.52 |\n| ReadLine_    | Row   | 50000   |    12.106 ms |  5.36 |  29 |  2410.5 |  242.1 |   88608.25 KB |   87,077.59 |\n| CsvHelper    | Row   | 50000   |    43.313 ms | 19.19 |  29 |   673.7 |  866.3 |      20.04 KB |       19.69 |\n|              |       |         |              |       |     |         |        |               |             |\n| Sep______    | Cols  | 50000   |     3.211 ms |  1.00 |  29 |  9089.3 |   64.2 |       1.02 KB |        1.00 |\n| Sep_Unescape | Cols  | 50000   |     3.845 ms |  1.20 |  29 |  7589.1 |   76.9 |       1.02 KB |        1.00 |\n| Sylvan___    | Cols  | 50000   |     5.065 ms |  1.58 |  29 |  5760.9 |  101.3 |       7.66 KB |        7.52 |\n| ReadLine_    | Cols  | 50000   |    12.850 ms |  4.00 |  29 |  2270.9 |  257.0 |   88608.25 KB |   86,910.78 |\n| CsvHelper    | Cols  | 50000   |    68.999 ms | 21.49 |  29 |   422.9 | 1380.0 |     445.85 KB |      437.31 |\n|              |       |         |              |       |     |         |        |               |             |\n| Sep______    | Asset | 50000   |    33.615 ms |  1.00 |  29 |   868.1 |  672.3 |   13802.47 KB |        1.00 |\n| Sep_MT___    | Asset | 50000   |    20.231 ms |  0.60 |  29 |  1442.4 |  404.6 |    13992.1 KB |        1.01 |\n| Sylvan___    | Asset | 50000   |    34.762 ms |  1.03 |  29 |   839.5 |  695.2 |    13962.2 KB |        1.01 |\n| ReadLine_    | Asset | 50000   |    97.204 ms |  2.89 |  29 |   300.2 | 1944.1 |   102133.9 KB |        7.40 |\n| CsvHelper    | Asset | 50000   |    83.550 ms |  2.49 |  29 |   349.3 | 1671.0 |   13970.66 KB |        1.01 |\n|              |       |         |              |       |     |         |        |               |             |\n| Sep______    | Asset | 1000000 |   629.552 ms |  1.00 | 583 |   927.3 |  629.6 |  266669.13 KB |        1.00 |\n| Sep_MT___    | Asset | 1000000 |   261.089 ms |  0.41 | 583 |  2236.0 |  261.1 |  267793.45 KB |        1.00 |\n| Sylvan___    | Asset | 1000000 |   761.171 ms |  1.21 | 583 |   767.0 |  761.2 |  266825.09 KB |        1.00 |\n| ReadLine_    | Asset | 1000000 | 1,636.526 ms |  2.60 | 583 |   356.7 | 1636.5 | 2038835.59 KB |        7.65 |\n| CsvHelper    | Asset | 1000000 | 1,754.461 ms |  2.79 | 583 |   332.7 | 1754.5 |  266833.16 KB |        1.00 |\n\n###### AMD.Ryzen.9.9950X - PackageAssets Benchmark Results (Sep 0.10.0.0, Sylvan  1.4.1.0, CsvHelper 33.0.1.24)\n\n| Method       | Scope | Rows    | Mean         | Ratio | MB  | MB/s    | ns/row | Allocated     | Alloc Ratio |\n|------------- |------ |-------- |-------------:|------:|----:|--------:|-------:|--------------:|------------:|\n| Sep______    | Row   | 50000   |     1.365 ms |  1.00 |  29 | 21384.9 |   27.3 |       1.01 KB |        1.00 |\n| Sep_Async    | Row   | 50000   |     1.455 ms |  1.07 |  29 | 20059.6 |   29.1 |       1.01 KB |        1.00 |\n| Sep_Unescape | Row   | 50000   |     1.399 ms |  1.02 |  29 | 20865.5 |   28.0 |       1.01 KB |        1.00 |\n| Sylvan___    | Row   | 50000   |     1.934 ms |  1.42 |  29 | 15085.4 |   38.7 |       7.72 KB |        7.63 |\n| ReadLine_    | Row   | 50000   |     8.833 ms |  6.47 |  29 |  3303.7 |  176.7 |   88608.25 KB |   87,581.89 |\n| CsvHelper    | Row   | 50000   |    24.072 ms | 17.64 |  29 |  1212.3 |  481.4 |         20 KB |       19.76 |\n|              |       |         |              |       |     |         |        |               |             |\n| Sep______    | Cols  | 50000   |     1.895 ms |  1.00 |  29 | 15399.8 |   37.9 |       1.02 KB |        1.00 |\n| Sep_Unescape | Cols  | 50000   |     2.321 ms |  1.22 |  29 | 12573.8 |   46.4 |       1.02 KB |        1.00 |\n| Sylvan___    | Cols  | 50000   |     3.141 ms |  1.66 |  29 |  9290.5 |   62.8 |       7.66 KB |        7.54 |\n| ReadLine_    | Cols  | 50000   |     9.248 ms |  4.88 |  29 |  3155.2 |  185.0 |   88608.25 KB |   87,245.04 |\n| CsvHelper    | Cols  | 50000   |    44.453 ms | 23.46 |  29 |   656.4 |  889.1 |      445.7 KB |      438.84 |\n|              |       |         |              |       |     |         |        |               |             |\n| Sep______    | Asset | 50000   |    26.486 ms |  1.00 |  29 |  1101.7 |  529.7 |   13802.57 KB |        1.00 |\n| Sep_MT___    | Asset | 50000   |    16.693 ms |  0.63 |  29 |  1748.1 |  333.9 |   13992.75 KB |        1.01 |\n| Sylvan___    | Asset | 50000   |    29.711 ms |  1.12 |  29 |   982.2 |  594.2 |   13963.15 KB |        1.01 |\n| ReadLine_    | Asset | 50000   |    82.744 ms |  3.13 |  29 |   352.7 | 1654.9 |  102134.11 KB |        7.40 |\n| CsvHelper    | Asset | 50000   |    54.704 ms |  2.07 |  29 |   533.4 | 1094.1 |   13970.84 KB |        1.01 |\n|              |       |         |              |       |     |         |        |               |             |\n| Sep______    | Asset | 1000000 |   473.474 ms |  1.00 | 583 |  1233.0 |  473.5 |   266668.7 KB |        1.00 |\n| Sep_MT___    | Asset | 1000000 |   207.790 ms |  0.44 | 583 |  2809.5 |  207.8 |  268542.84 KB |        1.01 |\n| Sylvan___    | Asset | 1000000 |   573.016 ms |  1.21 | 583 |  1018.8 |  573.0 |  266825.02 KB |        1.00 |\n| ReadLine_    | Asset | 1000000 | 1,303.550 ms |  2.75 | 583 |   447.8 | 1303.5 | 2038835.55 KB |        7.65 |\n| CsvHelper    | Asset | 1000000 | 1,149.642 ms |  2.43 | 583 |   507.8 | 1149.6 |  266841.26 KB |        1.00 |\n\n###### Apple.M1.(Virtual) - PackageAssets Benchmark Results (Sep 0.11.0.0, Sylvan  1.4.2.0, CsvHelper 33.1.0.26)\n\n| Method       | Scope | Rows    | Mean         | Ratio | MB  | MB/s   | ns/row | Allocated    | Alloc Ratio |\n|------------- |------ |-------- |-------------:|------:|----:|-------:|-------:|-------------:|------------:|\n| Sep______    | Row   | 50000   |     3.049 ms |  1.00 |  29 | 9539.7 |   61.0 |       1780 B |        1.00 |\n| Sep_Async    | Row   | 50000   |     3.090 ms |  1.01 |  29 | 9412.3 |   61.8 |        968 B |        0.54 |\n| Sep_Unescape | Row   | 50000   |     2.995 ms |  0.98 |  29 | 9711.6 |   59.9 |        967 B |        0.54 |\n| Sylvan___    | Row   | 50000   |    19.494 ms |  6.39 |  29 | 1492.1 |  389.9 |       6958 B |        3.91 |\n| ReadLine_    | Row   | 50000   |    18.381 ms |  6.03 |  29 | 1582.4 |  367.6 |   90734884 B |   50,974.65 |\n| CsvHelper    | Row   | 50000   |    43.358 ms | 14.22 |  29 |  670.8 |  867.2 |      20692 B |       11.62 |\n|              |       |         |              |       |     |        |        |              |             |\n| Sep______    | Cols  | 50000   |     4.070 ms |  1.00 |  29 | 7146.0 |   81.4 |        974 B |        1.00 |\n| Sep_Unescape | Cols  | 50000   |     4.508 ms |  1.11 |  29 | 6452.2 |   90.2 |        975 B |        1.00 |\n| Sylvan___    | Cols  | 50000   |    21.949 ms |  5.39 |  29 | 1325.1 |  439.0 |       6725 B |        6.90 |\n| ReadLine_    | Cols  | 50000   |    19.604 ms |  4.82 |  29 | 1483.7 |  392.1 |   90734891 B |   93,156.97 |\n| CsvHelper    | Cols  | 50000   |    71.862 ms | 17.66 |  29 |  404.7 | 1437.2 |     457440 B |      469.65 |\n|              |       |         |              |       |     |        |        |              |             |\n| Sep______    | Asset | 50000   |    31.638 ms |  1.00 |  29 |  919.3 |  632.8 |   14134042 B |        1.00 |\n| Sep_MT___    | Asset | 50000   |    20.132 ms |  0.64 |  29 | 1444.7 |  402.6 |   14312402 B |        1.01 |\n| Sylvan___    | Asset | 50000   |    52.805 ms |  1.67 |  29 |  550.8 | 1056.1 |   14296822 B |        1.01 |\n| ReadLine_    | Asset | 50000   |    93.011 ms |  2.95 |  29 |  312.7 | 1860.2 |  104585942 B |        7.40 |\n| CsvHelper    | Asset | 50000   |    77.498 ms |  2.46 |  29 |  375.3 | 1550.0 |   14306376 B |        1.01 |\n|              |       |         |              |       |     |        |        |              |             |\n| Sep______    | Asset | 1000000 |   563.469 ms |  1.00 | 581 | 1032.7 |  563.5 |  273070312 B |        1.00 |\n| Sep_MT___    | Asset | 1000000 |   454.372 ms |  0.81 | 581 | 1280.6 |  454.4 |  283171600 B |        1.04 |\n| Sylvan___    | Asset | 1000000 | 1,066.748 ms |  1.89 | 581 |  545.5 | 1066.7 |  273235400 B |        1.00 |\n| ReadLine_    | Asset | 1000000 | 1,778.023 ms |  3.16 | 581 |  327.3 | 1778.0 | 2087769280 B |        7.65 |\n| CsvHelper    | Asset | 1000000 | 1,593.827 ms |  2.83 | 581 |  365.1 | 1593.8 |  273247744 B |        1.00 |\n\n###### Cobalt.100 - PackageAssets Benchmark Results (Sep 0.11.0.0, Sylvan  1.4.2.0, CsvHelper 33.1.0.26)\n\n| Method       | Scope | Rows    | Mean         | Ratio | MB  | MB/s   | ns/row | Allocated    | Alloc Ratio |\n|------------- |------ |-------- |-------------:|------:|----:|-------:|-------:|-------------:|------------:|\n| Sep______    | Row   | 50000   |     4.770 ms |  1.00 |  29 | 6117.7 |   95.4 |        972 B |        1.00 |\n| Sep_Async    | Row   | 50000   |     5.006 ms |  1.05 |  29 | 5829.1 |  100.1 |        972 B |        1.00 |\n| Sep_Unescape | Row   | 50000   |     4.789 ms |  1.00 |  29 | 6092.9 |   95.8 |        970 B |        1.00 |\n| Sylvan___    | Row   | 50000   |    19.965 ms |  4.19 |  29 | 1461.6 |  399.3 |       6656 B |        6.85 |\n| ReadLine_    | Row   | 50000   |    24.603 ms |  5.16 |  29 | 1186.1 |  492.1 |   90734858 B |   93,348.62 |\n| CsvHelper    | Row   | 50000   |    52.364 ms | 10.98 |  29 |  557.3 | 1047.3 |      20435 B |       21.02 |\n|              |       |         |              |       |     |        |        |              |             |\n| Sep______    | Cols  | 50000   |     6.103 ms |  1.00 |  29 | 4781.5 |  122.1 |        955 B |        1.00 |\n| Sep_Unescape | Cols  | 50000   |     6.852 ms |  1.12 |  29 | 4258.9 |  137.0 |        953 B |        1.00 |\n| Sylvan___    | Cols  | 50000   |    24.055 ms |  3.94 |  29 | 1213.1 |  481.1 |       6686 B |        7.00 |\n| ReadLine_    | Cols  | 50000   |    25.907 ms |  4.25 |  29 | 1126.4 |  518.1 |   90734829 B |   95,010.29 |\n| CsvHelper    | Cols  | 50000   |    89.741 ms | 14.70 |  29 |  325.2 | 1794.8 |     456396 B |      477.90 |\n|              |       |         |              |       |     |        |        |              |             |\n| Sep______    | Asset | 50000   |    45.045 ms |  1.00 |  29 |  647.8 |  900.9 |   14134146 B |        1.00 |\n| Sep_MT___    | Asset | 50000   |    28.571 ms |  0.64 |  29 | 1021.4 |  571.4 |   14198453 B |        1.00 |\n| Sylvan___    | Asset | 50000   |    66.218 ms |  1.47 |  29 |  440.7 | 1324.4 |   14296192 B |        1.01 |\n| ReadLine_    | Asset | 50000   |   131.307 ms |  2.92 |  29 |  222.2 | 2626.1 |  104585118 B |        7.40 |\n| CsvHelper    | Asset | 50000   |   110.400 ms |  2.46 |  29 |  264.3 | 2208.0 |   14305660 B |        1.01 |\n|              |       |         |              |       |     |        |        |              |             |\n| Sep______    | Asset | 1000000 |   907.416 ms |  1.00 | 583 |  643.3 |  907.4 |  273069856 B |        1.00 |\n| Sep_MT___    | Asset | 1000000 |   425.985 ms |  0.47 | 583 | 1370.4 |  426.0 |  281372840 B |        1.03 |\n| Sylvan___    | Asset | 1000000 | 1,374.743 ms |  1.52 | 583 |  424.6 | 1374.7 |  273228480 B |        1.00 |\n| ReadLine_    | Asset | 1000000 | 2,282.225 ms |  2.52 | 583 |  255.8 | 2282.2 | 2087766512 B |        7.65 |\n| CsvHelper    | Asset | 1000000 | 2,247.721 ms |  2.48 | 583 |  259.7 | 2247.7 |  273249784 B |        1.00 |\n\n\n##### PackageAssets Benchmark Results (SERVER GC)\nThe package assets benchmark (Scope `Asset`) has a very high base load in the\nform of the accumulated instances of `PackageAsset` and since Sep is so fast the\nGC becomes a significant bottleneck for the benchmark, especially for\nmulti-threaded parsing. Switching to [SERVER\nGC](https://learn.microsoft.com/en-us/dotnet/standard/garbage-collection/workstation-server-gc)\ncan, therefore, provide significant speedup as can be seen below.\n\nWith `ParallelEnumerate` and server GC Sep is **\u003e4x faster than Sylvan and up to\n18x faster than CsvHelper**. Breaking 8 GB/s parsing speed on package assets on\n9950X.\n\n###### AMD.EPYC.7763 - PackageAssets Benchmark Results (SERVER GC) (Sep 0.11.0.0, Sylvan  1.4.2.0, CsvHelper 33.1.0.26)\n\n| Method    | Scope | Rows    | Mean        | Ratio | MB  | MB/s   | ns/row | Allocated  | Alloc Ratio |\n|---------- |------ |-------- |------------:|------:|----:|-------:|-------:|-----------:|------------:|\n| Sep______ | Asset | 50000   |    32.70 ms |  1.00 |  29 |  889.5 |  653.9 |   13.48 MB |        1.00 |\n| Sep_MT___ | Asset | 50000   |    16.64 ms |  0.51 |  29 | 1748.0 |  332.8 |   13.53 MB |        1.00 |\n| Sylvan___ | Asset | 50000   |    44.32 ms |  1.36 |  29 |  656.2 |  886.5 |   13.63 MB |        1.01 |\n| ReadLine_ | Asset | 50000   |    58.67 ms |  1.79 |  29 |  495.7 | 1173.4 |   99.74 MB |        7.40 |\n| CsvHelper | Asset | 50000   |   120.06 ms |  3.67 |  29 |  242.3 | 2401.2 |   13.64 MB |        1.01 |\n|           |       |         |             |       |     |        |        |            |             |\n| Sep______ | Asset | 1000000 |   667.19 ms |  1.00 | 581 |  872.1 |  667.2 |  260.41 MB |        1.00 |\n| Sep_MT___ | Asset | 1000000 |   343.62 ms |  0.52 | 581 | 1693.4 |  343.6 |  269.07 MB |        1.03 |\n| Sylvan___ | Asset | 1000000 |   884.52 ms |  1.33 | 581 |  657.8 |  884.5 |  260.57 MB |        1.00 |\n| ReadLine_ | Asset | 1000000 | 1,238.66 ms |  1.86 | 581 |  469.8 | 1238.7 | 1991.05 MB |        7.65 |\n| CsvHelper | Asset | 1000000 | 2,422.78 ms |  3.63 | 581 |  240.2 | 2422.8 |  260.58 MB |        1.00 |\n\n###### AMD.Ryzen.7.PRO.7840U.w.Radeon.780M - PackageAssets Benchmark Results (SERVER GC) (Sep 0.10.0.0, Sylvan  1.4.1.0, CsvHelper 33.0.1.24)\n\n| Method    | Scope | Rows    | Mean         | Ratio | MB  | MB/s   | ns/row | Allocated  | Alloc Ratio |\n|---------- |------ |-------- |-------------:|------:|----:|-------:|-------:|-----------:|------------:|\n| Sep______ | Asset | 50000   |    32.427 ms |  1.00 |  29 |  899.9 |  648.5 |   13.48 MB |        1.00 |\n| Sep_MT___ | Asset | 50000   |     9.377 ms |  0.29 |  29 | 3112.1 |  187.5 |   13.57 MB |        1.01 |\n| Sylvan___ | Asset | 50000   |    43.724 ms |  1.35 |  29 |  667.4 |  874.5 |   13.63 MB |        1.01 |\n| ReadLine_ | Asset | 50000   |    48.915 ms |  1.51 |  29 |  596.6 |  978.3 |   99.74 MB |        7.40 |\n| CsvHelper | Asset | 50000   |   118.160 ms |  3.64 |  29 |  247.0 | 2363.2 |   13.65 MB |        1.01 |\n|           |       |         |              |       |     |        |        |            |             |\n| Sep______ | Asset | 1000000 |   680.684 ms |  1.00 | 583 |  857.6 |  680.7 |  260.41 MB |        1.00 |\n| Sep_MT___ | Asset | 1000000 |   264.669 ms |  0.39 | 583 | 2205.7 |  264.7 |  262.35 MB |        1.01 |\n| Sylvan___ | Asset | 1000000 |   910.222 ms |  1.34 | 583 |  641.4 |  910.2 |  260.57 MB |        1.00 |\n| ReadLine_ | Asset | 1000000 | 1,043.395 ms |  1.54 | 583 |  559.5 | 1043.4 | 1991.05 MB |        7.65 |\n| CsvHelper | Asset | 1000000 | 2,433.801 ms |  3.58 | 583 |  239.9 | 2433.8 |  260.58 MB |        1.00 |\n\n###### AMD.Ryzen.9.5950X - PackageAssets Benchmark Results (SERVER GC) (Sep 0.9.0.0, Sylvan  1.3.9.0, CsvHelper 33.0.1.24)\n\n| Method    | Scope | Rows    | Mean         | Ratio | MB  | MB/s   | ns/row | Allocated  | Alloc Ratio |\n|---------- |------ |-------- |-------------:|------:|----:|-------:|-------:|-----------:|------------:|\n| Sep______ | Asset | 50000   |    20.951 ms |  1.00 |  29 | 1392.9 |  419.0 |   13.48 MB |        1.00 |\n| Sep_MT___ | Asset | 50000   |     6.614 ms |  0.32 |  29 | 4411.8 |  132.3 |   13.64 MB |        1.01 |\n| Sylvan___ | Asset | 50000   |    27.761 ms |  1.33 |  29 | 1051.2 |  555.2 |   13.63 MB |        1.01 |\n| ReadLine_ | Asset | 50000   |    33.516 ms |  1.60 |  29 |  870.7 |  670.3 |   99.74 MB |        7.40 |\n| CsvHelper | Asset | 50000   |    77.007 ms |  3.68 |  29 |  378.9 | 1540.1 |   13.64 MB |        1.01 |\n|           |       |         |              |       |     |        |        |            |             |\n| Sep______ | Asset | 1000000 |   432.887 ms |  1.00 | 583 | 1348.6 |  432.9 |  260.41 MB |        1.00 |\n| Sep_MT___ | Asset | 1000000 |   119.430 ms |  0.28 | 583 | 4888.1 |  119.4 |  261.39 MB |        1.00 |\n| Sylvan___ | Asset | 1000000 |   559.550 ms |  1.29 | 583 | 1043.3 |  559.6 |  260.57 MB |        1.00 |\n| ReadLine_ | Asset | 1000000 |   573.637 ms |  1.33 | 583 | 1017.7 |  573.6 | 1991.05 MB |        7.65 |\n| CsvHelper | Asset | 1000000 | 1,537.602 ms |  3.55 | 583 |  379.7 | 1537.6 |  260.58 MB |        1.00 |\n\n###### AMD.Ryzen.9.9950X - PackageAssets Benchmark Results (SERVER GC) (Sep 0.10.0.0, Sylvan  1.4.1.0, CsvHelper 33.0.1.24)\n\n| Method    | Scope | Rows    | Mean         | Ratio | MB  | MB/s   | ns/row | Allocated  | Alloc Ratio |\n|---------- |------ |-------- |-------------:|------:|----:|-------:|-------:|-----------:|------------:|\n| Sep______ | Asset | 50000   |    14.536 ms |  1.00 |  29 | 2007.5 |  290.7 |   13.48 MB |        1.00 |\n| Sep_MT___ | Asset | 50000   |     3.606 ms |  0.25 |  29 | 8091.8 |   72.1 |   13.65 MB |        1.01 |\n| Sylvan___ | Asset | 50000   |    20.457 ms |  1.41 |  29 | 1426.5 |  409.1 |   13.63 MB |        1.01 |\n| ReadLine_ | Asset | 50000   |    20.307 ms |  1.40 |  29 | 1437.0 |  406.1 |   99.74 MB |        7.40 |\n| CsvHelper | Asset | 50000   |    54.022 ms |  3.72 |  29 |  540.2 | 1080.4 |   13.64 MB |        1.01 |\n|           |       |         |              |       |     |        |        |            |             |\n| Sep______ | Asset | 1000000 |   291.979 ms |  1.00 | 583 | 1999.4 |  292.0 |  260.41 MB |        1.00 |\n| Sep_MT___ | Asset | 1000000 |    72.213 ms |  0.25 | 583 | 8084.1 |   72.2 |  261.63 MB |        1.00 |\n| Sylvan___ | Asset | 1000000 |   413.265 ms |  1.42 | 583 | 1412.6 |  413.3 |  260.57 MB |        1.00 |\n| ReadLine_ | Asset | 1000000 |   377.033 ms |  1.29 | 583 | 1548.4 |  377.0 | 1991.04 MB |        7.65 |\n| CsvHelper | Asset | 1000000 | 1,005.323 ms |  3.44 | 583 |  580.7 | 1005.3 |  260.58 MB |        1.00 |\n\n###### Apple.M1.(Virtual) - PackageAssets Benchmark Results (SERVER GC) (Sep 0.11.0.0, Sylvan  1.4.2.0, CsvHelper 33.1.0.26)\n\n| Method    | Scope | Rows    | Mean        | Ratio | MB  | MB/s   | ns/row | Allocated  | Alloc Ratio |\n|---------- |------ |-------- |------------:|------:|----:|-------:|-------:|-----------:|------------:|\n| Sep______ | Asset | 50000   |    25.60 ms |  1.00 |  29 | 1136.3 |  512.0 |   13.48 MB |        1.00 |\n| Sep_MT___ | Asset | 50000   |    18.61 ms |  0.73 |  29 | 1562.6 |  372.3 |   13.57 MB |        1.01 |\n| Sylvan___ | Asset | 50000   |    66.50 ms |  2.61 |  29 |  437.4 | 1330.0 |   13.63 MB |        1.01 |\n| ReadLine_ | Asset | 50000   |    53.19 ms |  2.08 |  29 |  546.9 | 1063.8 |   99.74 MB |        7.40 |\n| CsvHelper | Asset | 50000   |    91.97 ms |  3.60 |  29 |  316.2 | 1839.5 |   13.64 MB |        1.01 |\n|           |       |         |             |       |     |        |        |            |             |\n| Sep______ | Asset | 1000000 |   594.24 ms |  1.02 | 581 |  979.2 |  594.2 |  260.41 MB |        1.00 |\n| Sep_MT___ | Asset | 1000000 |   300.93 ms |  0.51 | 581 | 1933.6 |  300.9 |  271.08 MB |        1.04 |\n| Sylvan___ | Asset | 1000000 |   974.34 ms |  1.66 | 581 |  597.2 |  974.3 |  260.57 MB |        1.00 |\n| ReadLine_ | Asset | 1000000 | 1,102.38 ms |  1.88 | 581 |  527.8 | 1102.4 | 1991.05 MB |        7.65 |\n| CsvHelper | Asset | 1000000 | 1,547.16 ms |  2.64 | 581 |  376.1 | 1547.2 |  260.58 MB |        1.00 |\n\n###### Cobalt.100 - PackageAssets Benchmark Results (SERVER GC) (Sep 0.11.0.0, Sylvan  1.4.2.0, CsvHelper 33.1.0.26)\n\n| Method    | Scope | Rows    | Mean        | Ratio | MB  | MB/s   | ns/row | Allocated  | Alloc Ratio |\n|---------- |------ |-------- |------------:|------:|----:|-------:|-------:|-----------:|------------:|\n| Sep______ | Asset | 50000   |    34.83 ms |  1.00 |  29 |  837.8 |  696.6 |   13.48 MB |        1.00 |\n| Sep_MT___ | Asset | 50000   |    11.85 ms |  0.34 |  29 | 2462.6 |  237.0 |   13.53 MB |        1.00 |\n| Sylvan___ | Asset | 50000   |    58.84 ms |  1.69 |  29 |  496.0 | 1176.7 |   13.63 MB |        1.01 |\n| ReadLine_ | Asset | 50000   |    46.17 ms |  1.33 |  29 |  632.0 |  923.5 |   99.74 MB |        7.40 |\n| CsvHelper | Asset | 50000   |   103.20 ms |  2.97 |  29 |  282.8 | 2064.1 |   13.64 MB |        1.01 |\n|           |       |         |             |       |     |        |        |            |             |\n| Sep______ | Asset | 1000000 |   699.14 ms |  1.00 | 583 |  835.0 |  699.1 |  260.41 MB |        1.00 |\n| Sep_MT___ | Asset | 1000000 |   219.50 ms |  0.31 | 583 | 2659.6 |  219.5 |  268.09 MB |        1.03 |\n| Sylvan___ | Asset | 1000000 | 1,181.98 ms |  1.69 | 583 |  493.9 | 1182.0 |  260.57 MB |        1.00 |\n| ReadLine_ | Asset | 1000000 | 1,025.30 ms |  1.47 | 583 |  569.4 | 1025.3 | 1991.04 MB |        7.65 |\n| CsvHelper | Asset | 1000000 | 2,104.55 ms |  3.01 | 583 |  277.4 | 2104.5 |  260.58 MB |        1.00 |\n\n\n##### PackageAssets with Quotes Benchmark Results\n`NCsvPerf` does not examine performance in the face of quotes in the csv. This\nis relevant since some libraries like Sylvan will revert to a slower (not SIMD\nvectorized) parsing code path if it encounters quotes. Sep was designed to\nalways use SIMD vectorization no matter what.\n\nSince there are two extra `char`s to handle per column, it does have a\nsignificant impact on performance, no matter what though. This is expected when\nlooking at the numbers. For each row of 25 columns, there are 24 separators\n(here `,`) and one set of line endings (here `\\r\\n`). That's 26 characters.\nAdding quotes around each of the 25 columns will add 50 characters or almost\ntriple the total to 76.\n\n###### AMD.EPYC.7763 - PackageAssets with Quotes Benchmark Results (Sep 0.11.0.0, Sylvan  1.4.2.0, CsvHelper 33.1.0.26)\n\n| Method       | Scope | Rows    | Mean        | Ratio | MB  | MB/s   | ns/row | Allocated     | Alloc Ratio |\n|------------- |------ |-------- |------------:|------:|----:|-------:|-------:|--------------:|------------:|\n| Sep______    | Row   | 50000   |    10.57 ms |  1.00 |  33 | 3147.7 |  211.5 |       1.06 KB |        1.00 |\n| Sep_Async    | Row   | 50000   |    10.56 ms |  1.00 |  33 | 3152.0 |  211.2 |       1.06 KB |        1.00 |\n| Sep_Unescape | Row   | 50000   |    10.44 ms |  0.99 |  33 | 3188.5 |  208.8 |       1.06 KB |        1.00 |\n| Sylvan___    | Row   | 50000   |    23.18 ms |  2.19 |  33 | 1435.6 |  463.7 |       7.73 KB |        7.29 |\n| ReadLine_    | Row   | 50000   |    26.19 ms |  2.48 |  33 | 1270.8 |  523.8 |   108778.8 KB |  102,568.59 |\n| CsvHelper    | Row   | 50000   |    77.54 ms |  7.33 |  33 |  429.2 | 1550.8 |      20.28 KB |       19.12 |\n|              |       |         |             |       |     |        |        |               |             |\n| Sep______    | Cols  | 50000   |    11.85 ms |  1.00 |  33 | 2808.1 |  237.0 |       1.07 KB |        1.00 |\n| Sep_Unescape | Cols  | 50000   |    13.74 ms |  1.16 |  33 | 2422.9 |  274.7 |       1.08 KB |        1.01 |\n| Sylvan___    | Cols  | 50000   |    27.56 ms |  2.33 |  33 | 1207.5 |  551.2 |       7.75 KB |        7.26 |\n| ReadLine_    | Cols  | 50000   |    28.25 ms |  2.38 |  33 | 1178.1 |  565.0 |  108778.81 KB |  101,818.56 |\n| CsvHelper    | Cols  | 50000   |   106.81 ms |  9.01 |  33 |  311.6 | 2136.1 |     445.94 KB |      417.41 |\n|              |       |         |             |       |     |        |        |               |             |\n| Sep______    | Asset | 50000   |    47.05 ms |  1.00 |  33 |  707.4 |  940.9 |   13802.84 KB |        1.00 |\n| Sep_MT___    | Asset | 50000   |    30.50 ms |  0.65 |  33 | 1091.2 |  610.0 |   13860.99 KB |        1.00 |\n| Sylvan___    | Asset | 50000   |    69.36 ms |  1.47 |  33 |  479.9 | 1387.2 |   13962.38 KB |        1.01 |\n| ReadLine_    | Asset | 50000   |   148.40 ms |  3.16 |  33 |  224.3 | 2968.0 |  122305.51 KB |        8.86 |\n| CsvHelper    | Asset | 50000   |   126.52 ms |  2.69 |  33 |  263.1 | 2530.3 |    13971.3 KB |        1.01 |\n|              |       |         |             |       |     |        |        |               |             |\n| Sep______    | Asset | 1000000 |   990.05 ms |  1.00 | 665 |  672.5 |  990.0 |  266670.43 KB |        1.00 |\n| Sep_MT___    | Asset | 1000000 |   573.36 ms |  0.58 | 665 | 1161.2 |  573.4 |  271926.59 KB |        1.02 |\n| Sylvan___    | Asset | 1000000 | 1,426.57 ms |  1.44 | 665 |  466.7 | 1426.6 |  266828.59 KB |        1.00 |\n| ReadLine_    | Asset | 1000000 | 3,090.02 ms |  3.12 | 665 |  215.5 | 3090.0 | 2442321.23 KB |        9.16 |\n| CsvHelper    | Asset | 1000000 | 2,609.20 ms |  2.64 | 665 |  255.2 | 2609.2 |  266834.35 KB |        1.00 |\n\n###### AMD.Ryzen.7.PRO.7840U.w.Radeon.780M - PackageAssets with Quotes Benchmark Results (Sep 0.10.0.0, Sylvan  1.4.1.0, CsvHelper 33.0.1.24)\n\n| Method       | Scope | Rows    | Mean        | Ratio | MB  | MB/s   | ns/row | Allocated     | Alloc Ratio |\n|------------- |------ |-------- |------------:|------:|----:|-------:|-------:|--------------:|------------:|\n| Sep______    | Row   | 50000   |    11.24 ms |  1.00 |  33 | 2970.2 |  224.7 |       1.06 KB |        1.00 |\n| Sep_Async    | Row   | 50000   |    13.00 ms |  1.16 |  33 | 2567.1 |  260.0 |       1.06 KB |        1.00 |\n| Sep_Unescape | Row   | 50000   |    10.34 ms |  0.92 |  33 | 3229.0 |  206.7 |       1.04 KB |        0.99 |\n| Sylvan___    | Row   | 50000   |    26.59 ms |  2.37 |  33 | 1255.1 |  531.9 |       7.72 KB |        7.31 |\n| ReadLine_    | Row   | 50000   |    24.04 ms |  2.14 |  33 | 1388.3 |  480.8 |  108778.78 KB |  103,042.99 |\n| CsvHelper    | Row   | 50000   |    71.28 ms |  6.34 |  33 |  468.3 | 1425.6 |      20.21 KB |       19.14 |\n|              |       |         |             |       |     |        |        |               |             |\n| Sep______    | Cols  | 50000   |    12.42 ms |  1.00 |  33 | 2686.7 |  248.5 |       1.05 KB |        1.00 |\n| Sep_Unescape | Cols  | 50000   |    13.22 ms |  1.06 |  33 | 2524.0 |  264.5 |       1.07 KB |        1.01 |\n| Sylvan___    | Cols  | 50000   |    30.14 ms |  2.43 |  33 | 1107.3 |  602.8 |       7.73 KB |        7.35 |\n| ReadLine_    | Cols  | 50000   |    26.19 ms |  2.11 |  33 | 1274.3 |  523.8 |  108778.79 KB |  103,425.70 |\n| CsvHelper    | Cols  | 50000   |   101.12 ms |  8.14 |  33 |  330.1 | 2022.4 |     445.86 KB |      423.92 |\n|              |       |         |             |       |     |        |        |               |             |\n| Sep______    | Asset | 50000   |    59.60 ms |  1.00 |  33 |  560.0 | 1192.0 |   13803.13 KB |        1.00 |\n| Sep_MT___    | Asset | 50000   |    42.87 ms |  0.72 |  33 |  778.6 |  857.4 |      13947 KB |        1.01 |\n| Sylvan___    | Asset | 50000   |    79.36 ms |  1.33 |  33 |  420.6 | 1587.2 |    13962.4 KB |        1.01 |\n| ReadLine_    | Asset | 50000   |   197.46 ms |  3.32 |  33 |  169.0 | 3949.2 |  122304.88 KB |        8.86 |\n| CsvHelper    | Asset | 50000   |   126.66 ms |  2.13 |  33 |  263.5 | 2533.2 |   13971.72 KB |        1.01 |\n|              |       |         |             |       |     |        |        |               |             |\n| Sep______    | Asset | 1000000 | 1,114.98 ms |  1.00 | 667 |  598.9 | 1115.0 |  266678.59 KB |        1.00 |\n| Sep_MT___    | Asset | 1000000 |   666.45 ms |  0.60 | 667 | 1001.9 |  666.4 |   268990.3 KB |        1.01 |\n| Sylvan___    | Asset | 1000000 | 1,613.38 ms |  1.45 | 667 |  413.9 | 1613.4 |  266825.61 KB |        1.00 |\n| ReadLine_    | Asset | 1000000 | 4,194.02 ms |  3.76 | 667 |  159.2 | 4194.0 | 2442318.66 KB |        9.16 |\n| CsvHelper    | Asset | 1000000 | 2,549.93 ms |  2.29 | 667 |  261.9 | 2549.9 |  266834.65 KB |        1.00 |\n\n###### AMD.Ryzen.9.5950X - PackageAssets with Quotes Benchmark Results (Sep 0.9.0.0, Sylvan  1.3.9.0, CsvHelper 33.0.1.24)\n\n| Method       | Scope | Rows    | Mean         | Ratio | MB  | MB/s   | ns/row | Allocated     | Alloc Ratio |\n|------------- |------ |-------- |-------------:|------:|----:|-------:|-------:|--------------:|------------:|\n| Sep______    | Row   | 50000   |     7.046 ms |  1.00 |  33 | 4737.2 |  140.9 |       1.04 KB |        1.00 |\n| Sep_Async    | Row   | 50000   |     8.137 ms |  1.15 |  33 | 4101.8 |  162.7 |       1.04 KB |        1.00 |\n| Sep_Unescape | Row   | 50000   |     7.473 ms |  1.06 |  33 | 4466.7 |  149.5 |       1.04 KB |        1.00 |\n| Sylvan___    | Row   | 50000   |    17.571 ms |  2.38 |  33 | 1899.5 |  351.4 |       7.69 KB |        7.41 |\n| ReadLine_    | Row   | 50000   |    14.336 ms |  1.94 |  33 | 2328.2 |  286.7 |  108778.75 KB |  104,689.33 |\n| CsvHelper    | Row   | 50000   |    52.672 ms |  7.12 |  33 |  633.7 | 1053.4 |      20.05 KB |       19.29 |\n|              |       |         |              |       |     |        |        |               |             |\n| Sep______    | Cols  | 50000   |     8.126 ms |  1.00 |  33 | 4107.5 |  162.5 |       1.04 KB |        1.00 |\n| Sep_Unescape | Cols  | 50000   |     9.748 ms |  1.20 |  33 | 3424.0 |  195.0 |       1.05 KB |        1.01 |\n| Sylvan___    | Cols  | 50000   |    20.503 ms |  2.52 |  33 | 1628.0 |  410.1 |        7.7 KB |        7.39 |\n| ReadLine_    | Cols  | 50000   |    16.513 ms |  2.03 |  33 | 2021.3 |  330.3 |  108778.76 KB |  104,394.99 |\n| CsvHelper    | Cols  | 50000   |    74.224 ms |  9.13 |  33 |  449.7 | 1484.5 |     445.85 KB |      427.88 |\n|              |       |         |              |       |     |        |        |               |             |\n| Sep______    | Asset | 50000   |    39.523 ms |  1.00 |  33 |  844.5 |  790.5 |   13802.63 KB |        1.00 |\n| Sep_MT___    | Asset | 50000   |    23.386 ms |  0.59 |  33 | 1427.2 |  467.7 |   13981.76 KB |        1.01 |\n| Sylvan___    | Asset | 50000   |    50.803 ms |  1.29 |  33 |  657.0 | 1016.1 |   13962.08 KB |        1.01 |\n| ReadLine_    | Asset | 50000   |   114.306 ms |  2.89 |  33 |  292.0 | 2286.1 |  122304.45 KB |        8.86 |\n| CsvHelper    | Asset | 50000   |    88.786 ms |  2.25 |  33 |  375.9 | 1775.7 |   13970.43 KB |        1.01 |\n|              |       |         |              |       |     |        |        |               |             |\n| Sep______    | Asset | 1000000 |   752.681 ms |  1.00 | 667 |  887.1 |  752.7 |     266669 KB |        1.00 |\n| Sep_MT___    | Asset | 1000000 |   377.733 ms |  0.50 | 667 | 1767.7 |  377.7 |   267992.5 KB |        1.00 |\n| Sylvan___    | Asset | 1000000 | 1,091.345 ms |  1.45 | 667 |  611.8 | 1091.3 |  266825.09 KB |        1.00 |\n| ReadLine_    | Asset | 1000000 | 2,615.390 ms |  3.47 | 667 |  255.3 | 2615.4 | 2442319.06 KB |        9.16 |\n| CsvHelper    | Asset | 1000000 | 1,756.409 ms |  2.33 | 667 |  380.2 | 1756.4 |  266839.53 KB |        1.00 |\n\n###### AMD.Ryzen.9.9950X - PackageAssets with Quotes Benchmark Results (Sep 0.10.0.0, Sylvan  1.4.1.0, CsvHelper 33.0.1.24)\n\n| Method       | Scope | Rows    | Mean         | Ratio | MB  | MB/s   | ns/row | Allocated     | Alloc Ratio |\n|------------- |------ |-------- |-------------:|------:|----:|-------:|-------:|--------------:|------------:|\n| Sep______    | Row   | 50000   |     4.233 ms |  1.00 |  33 | 7884.4 |   84.7 |       1.03 KB |        1.00 |\n| Sep_Async    | Row   | 50000   |     4.577 ms |  1.08 |  33 | 7291.9 |   91.5 |       1.02 KB |        1.00 |\n| Sep_Unescape | Row   | 50000   |     4.435 ms |  1.05 |  33 | 7526.1 |   88.7 |       1.03 KB |        1.00 |\n| Sylvan___    | Row   | 50000   |    11.399 ms |  2.69 |  33 | 2928.1 |  228.0 |       7.67 KB |        7.48 |\n| ReadLine_    | Row   | 50000   |     9.827 ms |  2.32 |  33 | 3396.6 |  196.5 |  108778.75 KB |  106,085.18 |\n| CsvHelper    | Row   | 50000   |    27.453 ms |  6.48 |  33 | 1215.8 |  549.1 |         20 KB |       19.51 |\n|              |       |         |              |       |     |        |        |               |             |\n| Sep______    | Cols  | 50000   |     4.995 ms |  1.00 |  33 | 6681.9 |   99.9 |       1.03 KB |        1.00 |\n| Sep_Unescape | Cols  | 50000   |     5.515 ms |  1.10 |  33 | 6052.4 |  110.3 |       1.03 KB |        1.00 |\n| Sylvan___    | Cols  | 50000   |    12.760 ms |  2.55 |  33 | 2615.9 |  255.2 |       7.67 KB |        7.46 |\n| ReadLine_    | Cols  | 50000   |    10.853 ms |  2.17 |  33 | 3075.3 |  217.1 |  108778.74 KB |  105,782.94 |\n| CsvHelper    | Cols  | 50000   |    41.586 ms |  8.33 |  33 |  802.6 |  831.7 |      445.7 KB |      433.42 |\n|              |       |         |              |       |     |        |        |               |             |\n| Sep______    | Asset | 50000   |    28.426 ms |  1.00 |  33 | 1174.2 |  568.5 |   13802.71 KB |        1.00 |\n| Sep_MT___    | Asset | 50000   |    20.467 ms |  0.72 |  33 | 1630.8 |  409.3 |   13993.59 KB |        1.01 |\n| Sylvan___    | Asset | 50000   |    38.589 ms |  1.36 |  33 |  864.9 |  771.8 |   13962.21 KB |        1.01 |\n| ReadLine_    | Asset | 50000   |   100.029 ms |  3.52 |  33 |  333.7 | 2000.6 |  122305.28 KB |        8.86 |\n| CsvHelper    | Asset | 50000   |    52.035 ms |  1.83 |  33 |  641.4 | 1040.7 |   13971.41 KB |        1.01 |\n|              |       |         |              |       |     |        |        |               |             |\n| Sep______    | Asset | 1000000 |   521.217 ms |  1.00 | 667 | 1281.1 |  521.2 |  266668.73 KB |        1.00 |\n| Sep_MT___    | Asset | 1000000 |   270.971 ms |  0.52 | 667 | 2464.1 |  271.0 |   268699.4 KB |        1.01 |\n| Sylvan___    | Asset | 1000000 |   776.453 ms |  1.49 | 667 |  859.9 |  776.5 |  266824.44 KB |        1.00 |\n| ReadLine_    | Asset | 1000000 | 1,850.722 ms |  3.55 | 667 |  360.8 | 1850.7 | 2442318.88 KB |        9.16 |\n| CsvHelper    | Asset | 1000000 | 1,117.789 ms |  2.14 | 667 |  597.3 | 1117.8 |  266833.25 KB |        1.00 |\n\n###### Apple.M1.(Virtual) - PackageAssets with Quotes Benchmark Results (Sep 0.11.0.0, Sylvan  1.4.2.0, CsvHelper 33.1.0.26)\n\n| Method       | Scope | Rows    | Mean         | Ratio | MB  | MB/s   | ns/row | Allocated    | Alloc Ratio |\n|------------- |------ |-------- |-------------:|------:|----:|-------:|-------:|-------------:|------------:|\n| Sep______    | Row   | 50000   |     9.290 ms |  1.00 |  33 | 3582.6 |  185.8 |        997 B |        1.00 |\n| Sep_Async    | Row   | 50000   |     9.339 ms |  1.01 |  33 | 3563.8 |  186.8 |       1012 B |        1.02 |\n| Sep_Unescape | Row   | 50000   |     9.897 ms |  1.07 |  33 | 3363.0 |  197.9 |       1201 B |        1.20 |\n| Sylvan___    | Row   | 50000   |    23.249 ms |  2.51 |  33 | 1431.6 |  465.0 |       6958 B |        6.98 |\n| ReadLine_    | Row   | 50000   |    22.531 ms |  2.44 |  33 | 1477.1 |  450.6 |  111389493 B |  111,724.67 |\n| CsvHelper    | Row   | 50000   |    46.522 ms |  5.03 |  33 |  715.4 |  930.4 |      20764 B |       20.83 |\n|              |       |         |              |       |     |        |        |              |             |\n| Sep______    | Cols  | 50000   |     8.664 ms |  1.00 |  33 | 3841.6 |  173.3 |        999 B |        1.00 |\n| Sep_Unescape | Cols  | 50000   |     9.746 ms |  1.12 |  33 | 3415.0 |  194.9 |       1170 B |        1.17 |\n| Sylvan___    | Cols  | 50000   |    22.858 ms |  2.64 |  33 | 1456.0 |  457.2 |       6725 B |        6.73 |\n| ReadLine_    | Cols  | 50000   |    22.199 ms |  2.56 |  33 | 1499.2 |  444.0 |  111389493 B |  111,500.99 |\n| CsvHelper    | Cols  | 50000   |    71.417 ms |  8.24 |  33 |  466.0 | 1428.3 |     456636 B |      457.09 |\n|              |       |         |              |       |     |        |        |              |             |\n| Sep______    | Asset | 50000   |    36.004 ms |  1.00 |  33 |  924.4 |  720.1 |   14134024 B |        1.00 |\n| Sep_MT___    | Asset | 50000   |    22.068 ms |  0.61 |  33 | 1508.1 |  441.4 |   14233705 B |        1.01 |\n| Sylvan___    | Asset | 50000   |    51.940 ms |  1.45 |  33 |  640.8 | 1038.8 |   14296832 B |        1.01 |\n| ReadLine_    | Asset | 50000   |   136.529 ms |  3.80 |  33 |  243.8 | 2730.6 |  125241136 B |        8.86 |\n| CsvHelper    | Asset | 50000   |    88.008 ms |  2.45 |  33 |  378.2 | 1760.2 |   14307374 B |        1.01 |\n|              |       |         |              |       |     |        |        |              |             |\n| Sep______    | Asset | 1000000 |   733.901 ms |  1.00 | 665 |  907.2 |  733.9 |  273075208 B |        1.00 |\n| Sep_MT___    | Asset | 1000000 |   469.473 ms |  0.64 | 665 | 1418.2 |  469.5 |  281562856 B |        1.03 |\n| Sylvan___    | Asset | 1000000 | 1,154.378 ms |  1.57 | 665 |  576.8 | 1154.4 |  273228848 B |        1.00 |\n| ReadLine_    | Asset | 1000000 | 2,877.672 ms |  3.92 | 665 |  231.4 | 2877.7 | 2500938080 B |        9.16 |\n| CsvHelper    | Asset | 1000000 | 1,962.262 ms |  2.68 | 665 |  339.3 | 1962.3 |  273242672 B |        1.00 |\n\n###### Cobalt.100 - PackageAssets with Quotes Benchmark Results (Sep 0.11.0.0, Sylvan  1.4.2.0, CsvHelper 33.1.0.26)\n\n| Method       | Scope | Rows    | Mean         | Ratio | MB  | MB/s   | ns/row | Allocated    | Alloc Ratio |\n|------------- |------ |-------- |-------------:|------:|----:|-------:|-------:|-------------:|------------:|\n| Sep______    | Row   | 50000   |     9.740 ms |  1.00 |  33 | 3426.9 |  194.8 |        995 B |        1.00 |\n| Sep_Async    | Row   | 50000   |    10.119 ms |  1.04 |  33 | 3298.6 |  202.4 |        954 B |        0.96 |\n| Sep_Unescape | Row   | 50000   |    10.247 ms |  1.05 |  33 | 3257.2 |  204.9 |        976 B |        0.98 |\n| Sylvan___    | Row   | 50000   |    23.525 ms |  2.42 |  33 | 1418.8 |  470.5 |       6683 B |        6.72 |\n| ReadLine_    | Row   | 50000   |    30.016 ms |  3.08 |  33 | 1112.0 |  600.3 |  111389426 B |  111,949.17 |\n| CsvHelper    | Row   | 50000   |    63.934 ms |  6.56 |  33 |  522.1 | 1278.7 |      20512 B |       20.62 |\n|              |       |         |              |       |     |        |        |              |             |\n| Sep______   ","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fnietras%2FSep","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fnietras%2FSep","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fnietras%2FSep/lists"}