.NET Matrix

Evidence, not faith.
Choose .NET libraries with confidence using reproducible feature, execution-time and allocation comparisons.

Open the interactive matrix → · How to read the results · Reproduce the results · Link to the matrix

8 CATEGORIES

51 LIBRARIES

99 SCENARIOS

Explore the matrix

Category	Leader	Libraries	Scenarios
CSV Processing	Sep	4	10
Dependency Injection	Pure.DI	23	15
JSON Serialization	System.Text.Json	3	14
LINQ Queries	ZLinq	6	18
Logging	Microsoft.Extensions.Logging	6	9
Object Mapping	Mapperly	4	10
Validation	Microsoft.Extensions.Validation	4	10
ZIP Archives	SharpZipLib	3	13

How to read the results

• Correctness comes first. Every implementation is checked against the same feature contract before its benchmark results are compared.
• Lower is better. Overview charts show execution time and allocated memory together.
• The rating measures distance, not placings. In every scenario the fastest library scores 100 points and the one allocating least scores 100 more; four times slower is half the points, and an unsupported scenario scores nothing. A library's rating is the sum, so speed, economy and breadth all count and a narrow win cannot outweigh them.
• The Web application is the primary explorer. Use it to select libraries and switch between overview, features, benchmarks and environment details. Chrome and Edge can install it as a desktop application, with a shortcut per category.

The README is a generated snapshot of the reports committed to this repository.

CSV Processing

Sep leads the current rating · 4 libraries · 10 scenarios

Explore interactively →

Rating

In every scenario the fastest library scores 100 points and the one allocating least scores 100 more; four times slower is half the points, and an unsupported scenario is worth nothing. Time and memory reach 1000 each here, so the maximum is 2000. See workflows/rating.md.

#	Library	Scenarios	Time	Memory	Points	Group wins
1	Sep	10/10	994	1000	1994	gold in Correctness, gold in Read, gold in Throughput, gold in Write
2	TinyCsvParser	9/10	561	392	954	silver in Correctness, silver in Read, bronze in Throughput
3	Sylvan.Data.Csv	9/10	613	270	883	silver in Throughput, silver in Write, bronze in Correctness, bronze in Read
4	CsvHelper	10/10	234	213	446	bronze in Write

How the points were earned — every scenario, with the measurements behind it

Each row is one scenario. Best is the lowest result among the rated libraries that completed it, and the points follow from the two figures beside them: 100 × √((best + step) / (result + step)), with a step of 1 ns for time and 24 B for memory. A dash means the library did not complete the scenario, and it scores nothing for it. Add the two Points columns over every scenario and you get the rating above. The same breakdown appears as a hint on any points value in the application.

1. Sep — 1994 of 2000

Scenario	Time	Best	Points	Memory	Best	Points
Read Simple Rows	768.74 ns	768.74 ns	100	1.89 KB	1.89 KB	100
Read Typed Records	875.75 ns	875.75 ns	100	1.7 KB	1.7 KB	100
Read Large Dataset	1.02 ms	1.02 ms	100	1016.97 KB	1016.97 KB	100
Quoted Fields	637.09 ns	637.09 ns	100	1.34 KB	1.34 KB	100
Escaped Delimiters	566.9 ns	566.9 ns	100	1.35 KB	1.35 KB	100
Header Mapping	937.12 ns	937.12 ns	100	1.7 KB	1.7 KB	100
Custom Conversion	455.9 ns	455.9 ns	100	1.11 KB	1.11 KB	100
Streaming Read	958.9 μs	840.41 μs	93.6	1.34 KB	1.34 KB	100
Write Rows	543.69 ns	543.69 ns	100	1.89 KB	1.89 KB	100
Async Read	841.41 μs	841.41 μs	100	1.44 KB	1.44 KB	100

2. TinyCsvParser — 954 of 2000

Scenario	Time	Best	Points	Memory	Best	Points
Read Simple Rows	1.7 μs	768.74 ns	67.3	5.56 KB	1.89 KB	58.5
Read Typed Records	1.86 μs	875.75 ns	68.7	5.3 KB	1.7 KB	56.8
Read Large Dataset	3.09 ms	1.02 ms	57.5	2.91 MB	1016.97 KB	58.5
Quoted Fields	1.35 μs	637.09 ns	68.7	4.87 KB	1.34 KB	52.9
Escaped Delimiters	1.44 μs	566.9 ns	62.8	4.98 KB	1.35 KB	52.4
Header Mapping	1.85 μs	937.12 ns	71.3	5.3 KB	1.7 KB	56.8
Custom Conversion	954.3 ns	455.9 ns	69.2	4.32 KB	1.11 KB	51.1
Streaming Read	3.18 ms	840.41 μs	51.4	2.75 MB	1.34 KB	2.196
Write Rows	—	543.69 ns	0	—	1.89 KB	0
Async Read	4.24 ms	841.41 μs	44.5	1.39 MB	1.44 KB	3.209

3. Sylvan.Data.Csv — 883 of 2000

Scenario	Time	Best	Points	Memory	Best	Points
Read Simple Rows	2.52 μs	768.74 ns	55.3	35.38 KB	1.89 KB	23.3
Read Typed Records	2.79 μs	875.75 ns	56.1	35.11 KB	1.7 KB	22.1
Read Large Dataset	1.14 ms	1.02 ms	94.6	1.03 MB	1016.97 KB	98.4
Quoted Fields	2.1 μs	637.09 ns	55.1	34.34 KB	1.34 KB	19.9
Escaped Delimiters	2.12 μs	566.9 ns	51.8	34.3 KB	1.35 KB	20
Header Mapping	2.78 μs	937.12 ns	58.1	35.11 KB	1.7 KB	22.1
Custom Conversion	—	455.9 ns	0	—	1.11 KB	0
Streaming Read	840.41 μs	840.41 μs	100	34.75 KB	1.34 KB	19.8
Write Rows	1.8 μs	543.69 ns	55.1	32.78 KB	1.89 KB	24.2
Async Read	1.12 ms	841.41 μs	86.8	36.05 KB	1.44 KB	20.1

4. CsvHelper — 446 of 2000

Scenario	Time	Best	Points	Memory	Best	Points
Read Simple Rows	3.68 μs	768.74 ns	45.7	21.95 KB	1.89 KB	29.5
Read Typed Records	782.39 μs	875.75 ns	3.348	53.61 KB	1.7 KB	17.9
Read Large Dataset	4.82 ms	1.02 ms	46.1	2.65 MB	1016.97 KB	61.3
Quoted Fields	603.58 μs	637.09 ns	3.251	41.36 KB	1.34 KB	18.2
Escaped Delimiters	543.73 μs	566.9 ns	3.232	40.85 KB	1.35 KB	18.3
Header Mapping	841.88 μs	937.12 ns	3.338	53.52 KB	1.7 KB	17.9
Custom Conversion	3.36 μs	455.9 ns	36.9	21.95 KB	1.11 KB	22.7
Streaming Read	4 ms	840.41 μs	45.8	2.16 MB	1.34 KB	2.48
Write Rows	768.87 μs	543.69 ns	2.662	40.5 KB	1.89 KB	21.7
Async Read	4.48 ms	841.41 μs	43.3	2.09 MB	1.44 KB	2.615

Benchmark overview

Read

More overview charts (3)

Correctness

Throughput

Write

Compared libraries (4)

	CsvHelper 33.1.0 A widely used CSV library with record mapping, type conversion, and synchronous and asynchronous readers and writers.	Compare →
	Sep 0.15.1 A modern SIMD-accelerated separated-values reader and writer with span-based conversion and async enumeration.	Compare →
	Sylvan.Data.Csv 1.4.4 A high-performance forward-only CSV data reader and writer with strongly typed accessors and asynchronous I/O.	Compare →
	TinyCsvParser 3.0.11 A strongly typed CSV parser with declarative property mapping, custom converters, lazy streaming, and asynchronous readers.	Compare →

Benchmark scenarios (10)

01 · Read Simple Rows

Parses three CSV records and materializes every field as text.

02 · Read Typed Records

Parses three CSV records and materializes typed scalar values.

03 · Read Large Dataset

Parses and materializes 10,000 typed CSV records.

04 · Quoted Fields

Parses doubled quote escapes inside quoted CSV fields.

05 · Escaped Delimiters

Parses quoted fields containing a comma or an LF newline.

06 · Header Mapping

Maps a reordered CSV header to the correct typed record members.

07 · Custom Conversion

Converts sku-NNNN fields to the matrix-owned ProductCode value type.

08 · Streaming Read

Aggregates 10,000 typed rows with forward-only reading and no row materialization.

09 · Write Rows

Writes three records with a header to an exact LF-terminated CSV string.

10 · Async Read

Asynchronously aggregates 10,000 typed CSV rows through the library async API.

Dependency Injection

Pure.DI leads the current rating · 23 libraries · 15 scenarios

Explore interactively →

Rating

In every scenario the fastest library scores 100 points and the one allocating least scores 100 more; four times slower is half the points, and an unsupported scenario is worth nothing. Time and memory reach 1500 each here, so the maximum is 3000. See workflows/rating.md.

#	Library	Scenarios	Time	Memory	Points	Group wins
1	Pure.DI	14/15	1400	1394	2794	gold in Basic, gold in Prepare, silver in Advanced
2	DryIoc	15/15	840	1206	2046	gold in Advanced, bronze in Prepare
3	Grace	13/15	798	1042	1840	silver in Basic
4	Stashbox	14/15	742	1093	1835	bronze in Advanced, bronze in Basic
5	Simple Injector	12/15	667	963	1630
6	LightInject	12/15	598	930	1528
7	Lamar	12/15	625	743	1368
8	Singularity	9/15	481	710	1191
9	Microsoft Extensions Dependency Injection	9/15	409	675	1085
10	Faster.Ioc	8/15	405	608	1012
11	Managed Extensibility Framework 2	10/15	315	455	770
12	Unity	13/15	259	444	703
13	Maestro	11/15	247	347	594
14	StructureMap	13/15	205	331	536
15	ZenIoc	7/15	153	284	438
16	Autofac	13/15	159	243	402
17	Castle Windsor	13/15	123	224	346
18	MvvmCross	6/15	79	245	323	silver in Prepare
19	Spring.NET	10/15	98	224	322
20	Ninject	12/15	51	134	186
21	Visual Studio MEF	9/15	37	99	136
22	Catel	8/15	43	89	132

How the points were earned — every scenario, with the measurements behind it

Each row is one scenario. Best is the lowest result among the rated libraries that completed it, and the points follow from the two figures beside them: 100 × √((best + step) / (result + step)), with a step of 1 ns for time and 24 B for memory. A dash means the library did not complete the scenario, and it scores nothing for it. Add the two Points columns over every scenario and you get the rating above. The same breakdown appears as a hint on any points value in the application.

1. Pure.DI — 2794 of 3000

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	1.48 ns	1.48 ns	100	0 B	0 B	100
Transient	14.35 ns	14.35 ns	100	72 B	72 B	100
PerResolve	14.22 ns	14.22 ns	100	56 B	56 B	100
Scoped	43.04 ns	43.04 ns	100	184 B	160 B	94.1
Combined	37.31 ns	37.31 ns	100	168 B	168 B	100
Complex	88.1 ns	88.1 ns	100	360 B	360 B	100
Property	71.85 ns	71.85 ns	100	336 B	336 B	100
Generics	30.49 ns	30.49 ns	100	144 B	144 B	100
IEnumerable	18.32 ns	18.32 ns	100	72 B	72 B	100
Array	135.94 ns	135.94 ns	100	624 B	624 B	100
Conditional	32.72 ns	32.72 ns	100	144 B	144 B	100
Child Container	—	774.2 ns	0	—	1.59 KB	0
Interception With Proxy	73.95 ns	73.95 ns	100	248 B	248 B	100
Prepare And Register	0 ns	0 ns	100	0 B	0 B	100
Prepare And Register And Simple Resolve	10.12 ns	10.12 ns	100	24 B	24 B	100

2. DryIoc — 2046 of 3000

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	34.02 ns	1.48 ns	26.6	0 B	0 B	100
Transient	96.22 ns	14.35 ns	39.7	72 B	72 B	100
PerResolve	371.17 μs	14.22 ns	0.64	1.65 KB	56 B	21.6
Scoped	158.11 ns	43.04 ns	52.6	448 B	160 B	62.4
Combined	72.73 ns	37.31 ns	72.1	168 B	168 B	100
Complex	118.48 ns	88.1 ns	86.4	360 B	360 B	100
Property	103.29 ns	71.85 ns	83.6	336 B	336 B	100
Generics	66.67 ns	30.49 ns	68.2	144 B	144 B	100
IEnumerable	100.51 ns	18.32 ns	43.6	72 B	72 B	100
Array	168.39 ns	135.94 ns	89.9	624 B	624 B	100
Conditional	67.97 ns	32.72 ns	69.9	144 B	144 B	100
Child Container	774.2 ns	774.2 ns	100	1.59 KB	1.59 KB	100
Interception With Proxy	80.86 ns	73.95 ns	95.7	248 B	248 B	100
Prepare And Register	1.36 μs	0 ns	2.709	2.42 KB	0 B	9.79
Prepare And Register And Simple Resolve	1.71 μs	10.12 ns	8.062	3.04 KB	24 B	12.4

3. Grace — 1840 of 3000

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	75.32 ns	1.48 ns	18	0 B	0 B	100
Transient	75.79 ns	14.35 ns	44.7	72 B	72 B	100
PerResolve	104.01 ns	14.22 ns	38.1	296 B	56 B	50
Scoped	109.71 ns	43.04 ns	63.1	232 B	160 B	84.8
Combined	51.77 ns	37.31 ns	85.2	168 B	168 B	100
Complex	105.87 ns	88.1 ns	91.3	360 B	360 B	100
Property	83.33 ns	71.85 ns	92.9	336 B	336 B	100
Generics	45.17 ns	30.49 ns	82.6	144 B	144 B	100
IEnumerable	—	18.32 ns	0	—	72 B	0
Array	142.62 ns	135.94 ns	97.6	624 B	624 B	100
Conditional	46.22 ns	32.72 ns	84.5	144 B	144 B	100
Child Container	—	774.2 ns	0	—	1.59 KB	0
Interception With Proxy	76.75 ns	73.95 ns	98.2	248 B	248 B	100
Prepare And Register	11.26 μs	0 ns	0.942	21.66 KB	0 B	3.288
Prepare And Register And Simple Resolve	207.3 μs	10.12 ns	0.732	32.77 KB	24 B	3.781

4. Stashbox — 1835 of 3000

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	109.48 ns	1.48 ns	15	0 B	0 B	100
Transient	91.8 ns	14.35 ns	40.7	72 B	72 B	100
PerResolve	69.04 ns	14.22 ns	46.6	192 B	56 B	60.9
Scoped	107.96 ns	43.04 ns	63.6	304 B	160 B	74.9
Combined	71.75 ns	37.31 ns	72.6	168 B	168 B	100
Complex	200.21 ns	88.1 ns	66.5	360 B	360 B	100
Property	99.91 ns	71.85 ns	85	336 B	336 B	100
Generics	56.77 ns	30.49 ns	73.8	144 B	144 B	100
IEnumerable	—	18.32 ns	0	—	72 B	0
Array	153.17 ns	135.94 ns	94.2	624 B	624 B	100
Conditional	55.06 ns	32.72 ns	77.6	144 B	144 B	100
Child Container	106.81 μs	774.2 ns	8.519	7.57 KB	1.59 KB	46
Interception With Proxy	80.25 ns	73.95 ns	96	248 B	248 B	100
Prepare And Register	4.86 μs	0 ns	1.434	8.77 KB	0 B	5.164
Prepare And Register And Simple Resolve	211.29 μs	10.12 ns	0.726	14.93 KB	24 B	5.599

5. Simple Injector — 1630 of 3000

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	33.65 ns	1.48 ns	26.7	0 B	0 B	100
Transient	46.85 ns	14.35 ns	56.6	72 B	72 B	100
PerResolve	—	14.22 ns	0	—	56 B	0
Scoped	235.78 ns	43.04 ns	43.1	504 B	160 B	59
Combined	65.33 ns	37.31 ns	76	168 B	168 B	100
Complex	120.66 ns	88.1 ns	85.6	360 B	360 B	100
Property	108.39 ns	71.85 ns	81.6	336 B	336 B	100
Generics	60.96 ns	30.49 ns	71.3	144 B	144 B	100
IEnumerable	56.57 ns	18.32 ns	57.9	72 B	72 B	100
Array	—	135.94 ns	0	—	624 B	0
Conditional	65.76 ns	32.72 ns	71.1	144 B	144 B	100
Child Container	—	774.2 ns	0	—	1.59 KB	0
Interception With Proxy	79.65 ns	73.95 ns	96.4	248 B	248 B	100
Prepare And Register	68.57 μs	0 ns	0.382	63.48 KB	0 B	1.921
Prepare And Register And Simple Resolve	295.25 μs	10.12 ns	0.614	105.43 KB	24 B	2.108

6. LightInject — 1528 of 3000

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	53.87 ns	1.48 ns	21.2	0 B	0 B	100
Transient	82.31 ns	14.35 ns	42.9	72 B	72 B	100
PerResolve	—	14.22 ns	0	—	56 B	0
Scoped	247.1 ns	43.04 ns	42.1	568 B	160 B	55.8
Combined	88.47 ns	37.31 ns	65.4	168 B	168 B	100
Complex	245.12 ns	88.1 ns	60.2	360 B	360 B	100
Property	91.33 ns	71.85 ns	88.8	336 B	336 B	100
Generics	50.75 ns	30.49 ns	78	144 B	144 B	100
IEnumerable	—	18.32 ns	0	—	72 B	0
Array	156.12 ns	135.94 ns	93.4	624 B	624 B	100
Conditional	209.3 ns	32.72 ns	40	144 B	144 B	100
Child Container	—	774.2 ns	0	—	1.59 KB	0
Interception With Proxy	177.56 ns	73.95 ns	64.8	560 B	248 B	68.2
Prepare And Register	11.26 μs	0 ns	0.942	33.07 KB	0 B	2.661
Prepare And Register And Simple Resolve	673.2 μs	10.12 ns	0.406	43.45 KB	24 B	3.284

7. Lamar — 1368 of 3000

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	41.14 ns	1.48 ns	24.2	120 B	0 B	40.8
Transient	63.89 ns	14.35 ns	48.6	192 B	72 B	66.7
PerResolve	—	14.22 ns	0	—	56 B	0
Scoped	1.2 μs	43.04 ns	19.2	1.08 KB	160 B	40.4
Combined	80.41 ns	37.31 ns	68.6	288 B	168 B	78.4
Complex	132.04 ns	88.1 ns	81.8	480 B	360 B	87.3
Property	119.55 ns	71.85 ns	77.7	456 B	336 B	86.6
Generics	78.75 ns	30.49 ns	62.8	264 B	144 B	76.4
IEnumerable	—	18.32 ns	0	—	72 B	0
Array	177.52 ns	135.94 ns	87.6	744 B	624 B	91.9
Conditional	76.99 ns	32.72 ns	65.8	264 B	144 B	76.4
Child Container	—	774.2 ns	0	—	1.59 KB	0
Interception With Proxy	95.92 ns	73.95 ns	87.9	288 B	248 B	93.4
Prepare And Register	155.11 μs	0 ns	0.254	62.91 KB	0 B	1.93
Prepare And Register And Simple Resolve	156.87 μs	10.12 ns	0.842	63.65 KB	24 B	2.713

8. Singularity — 1191 of 3000

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	76.02 ns	1.48 ns	17.9	0 B	0 B	100
Transient	83.45 ns	14.35 ns	42.6	72 B	72 B	100
PerResolve	—	14.22 ns	0	—	56 B	0
Scoped	51.24 ns	43.04 ns	91.8	160 B	160 B	100
Combined	52.88 ns	37.31 ns	84.3	168 B	168 B	100
Complex	107.44 ns	88.1 ns	90.6	360 B	360 B	100
Property	—	71.85 ns	0	—	336 B	0
Generics	50.32 ns	30.49 ns	78.3	144 B	144 B	100
IEnumerable	—	18.32 ns	0	—	72 B	0
Array	256.16 ns	135.94 ns	73	624 B	624 B	100
Conditional	—	32.72 ns	0	—	144 B	0
Child Container	—	774.2 ns	0	—	1.59 KB	0
Interception With Proxy	—	73.95 ns	0	—	248 B	0
Prepare And Register	6.05 μs	0 ns	1.285	12.49 KB	0 B	4.327
Prepare And Register And Simple Resolve	63.23 μs	10.12 ns	1.326	15.67 KB	24 B	5.465

9. Microsoft Extensions Dependency Injection — 1085 of 3000

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	25.67 ns	1.48 ns	30.5	0 B	0 B	100
Transient	92.72 ns	14.35 ns	40.5	72 B	72 B	100
PerResolve	—	14.22 ns	0	—	56 B	0
Scoped	182.85 ns	43.04 ns	48.9	472 B	160 B	60.9
Combined	55.26 ns	37.31 ns	82.5	168 B	168 B	100
Complex	119.25 ns	88.1 ns	86.1	360 B	360 B	100
Property	—	71.85 ns	0	—	336 B	0
Generics	65.59 ns	30.49 ns	68.8	144 B	144 B	100
IEnumerable	—	18.32 ns	0	—	72 B	0
Array	—	135.94 ns	0	—	624 B	0
Conditional	183.13 ns	32.72 ns	42.8	144 B	144 B	100
Child Container	—	774.2 ns	0	—	1.59 KB	0
Interception With Proxy	—	73.95 ns	0	—	248 B	0
Prepare And Register	1.81 μs	0 ns	2.348	6.05 KB	0 B	6.21
Prepare And Register And Simple Resolve	2.24 μs	10.12 ns	7.042	6.8 KB	24 B	8.29

10. Faster.Ioc — 1012 of 3000

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	83.85 ns	1.48 ns	17.1	0 B	0 B	100
Transient	82.86 ns	14.35 ns	42.8	72 B	72 B	100
PerResolve	—	14.22 ns	0	—	56 B	0
Scoped	60.39 ns	43.04 ns	84.7	192 B	160 B	92.3
Combined	53.8 ns	37.31 ns	83.6	168 B	168 B	100
Complex	106.09 ns	88.1 ns	91.2	360 B	360 B	100
Property	—	71.85 ns	0	—	336 B	0
Generics	46.73 ns	30.49 ns	81.2	144 B	144 B	100
IEnumerable	—	18.32 ns	0	—	72 B	0
Array	—	135.94 ns	0	—	624 B	0
Conditional	—	32.72 ns	0	—	144 B	0
Child Container	—	774.2 ns	0	—	1.59 KB	0
Interception With Proxy	—	73.95 ns	0	—	248 B	0
Prepare And Register	1.08 μs	0 ns	3.04	4.36 KB	0 B	7.313
Prepare And Register And Simple Resolve	130.26 μs	10.12 ns	0.924	7.41 KB	24 B	7.939

11. Managed Extensibility Framework 2 — 770 of 3000

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	134.45 ns	1.48 ns	13.5	360 B	0 B	25
Transient	162.77 ns	14.35 ns	30.6	312 B	72 B	53.5
PerResolve	—	14.22 ns	0	—	56 B	0
Scoped	—	43.04 ns	0	—	160 B	0
Combined	186.39 ns	37.31 ns	45.2	528 B	168 B	59
Complex	427.86 ns	88.1 ns	45.6	1.05 KB	360 B	59
Property	469.73 ns	71.85 ns	39.3	1.15 KB	336 B	54.8
Generics	186.98 ns	30.49 ns	40.9	384 B	144 B	64.2
IEnumerable	—	18.32 ns	0	—	72 B	0
Array	429.66 ns	135.94 ns	56.4	1.27 KB	624 B	70.1
Conditional	185.98 ns	32.72 ns	42.5	384 B	144 B	64.2
Child Container	—	774.2 ns	0	—	1.59 KB	0
Interception With Proxy	—	73.95 ns	0	—	248 B	0
Prepare And Register	104.87 μs	0 ns	0.309	44.45 KB	0 B	2.296
Prepare And Register And Simple Resolve	248.52 μs	10.12 ns	0.669	56.67 KB	24 B	2.875

12. Unity — 703 of 3000

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	162.22 ns	1.48 ns	12.3	336 B	0 B	25.8
Transient	218.73 ns	14.35 ns	26.4	408 B	72 B	47.1
PerResolve	343.71 ns	14.22 ns	21	808 B	56 B	31
Scoped	2.03 μs	43.04 ns	14.7	4.57 KB	160 B	19.8
Combined	535.76 ns	37.31 ns	26.7	792 B	168 B	48.5
Complex	1.36 μs	88.1 ns	25.6	1.66 KB	360 B	47.1
Property	728.6 ns	71.85 ns	31.6	1.08 KB	336 B	56.5
Generics	2.29 μs	30.49 ns	11.7	1008 B	144 B	40.3
IEnumerable	—	18.32 ns	0	—	72 B	0
Array	2.28 μs	135.94 ns	24.5	9.59 KB	624 B	25.7
Conditional	412.25 ns	32.72 ns	28.6	624 B	144 B	50.9
Child Container	7.42 μs	774.2 ns	32.3	8.81 KB	1.59 KB	42.7
Interception With Proxy	—	73.95 ns	0	—	248 B	0
Prepare And Register	8.18 μs	0 ns	1.105	19.28 KB	0 B	3.484
Prepare And Register And Simple Resolve	13.57 μs	10.12 ns	2.863	21.89 KB	24 B	4.625

13. Maestro — 594 of 3000

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	227.57 ns	1.48 ns	10.4	720 B	0 B	18
Transient	258.21 ns	14.35 ns	24.3	648 B	72 B	37.8
PerResolve	—	14.22 ns	0	—	56 B	0
Scoped	812.45 ns	43.04 ns	23.3	1.63 KB	160 B	32.9
Combined	431.39 ns	37.31 ns	29.8	1.24 KB	168 B	38.5
Complex	972.16 ns	88.1 ns	30.3	2.79 KB	360 B	36.5
Property	765.52 ns	71.85 ns	30.8	1.8 KB	336 B	43.9
Generics	271.82 ns	30.49 ns	34	912 B	144 B	42.4
IEnumerable	—	18.32 ns	0	—	72 B	0
Array	—	135.94 ns	0	—	624 B	0
Conditional	404.23 ns	32.72 ns	28.8	1.01 KB	144 B	39.9
Child Container	—	774.2 ns	0	—	1.59 KB	0
Interception With Proxy	735 ns	73.95 ns	31.9	1.03 KB	248 B	50.2
Prepare And Register	17.79 μs	0 ns	0.75	27.62 KB	0 B	2.912
Prepare And Register And Simple Resolve	18.88 μs	10.12 ns	2.427	28.62 KB	24 B	4.046

14. StructureMap — 536 of 3000

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	716.26 ns	1.48 ns	5.875	2.58 KB	0 B	9.492
Transient	421.2 ns	14.35 ns	19.1	1.17 KB	72 B	28
PerResolve	—	14.22 ns	0	—	56 B	0
Scoped	6.14 μs	43.04 ns	8.467	9.67 KB	160 B	13.6
Combined	1.53 μs	37.31 ns	15.8	2.86 KB	168 B	25.5
Complex	3.43 μs	88.1 ns	16.1	4.64 KB	360 B	28.4
Property	1.48 μs	71.85 ns	22.2	1.64 KB	336 B	46
Generics	1.4 μs	30.49 ns	15	2.63 KB	144 B	24.9
IEnumerable	—	18.32 ns	0	—	72 B	0
Array	3.66 μs	135.94 ns	19.4	4.99 KB	624 B	35.5
Conditional	832.76 ns	32.72 ns	20.1	1.38 KB	144 B	34.2
Child Container	889.67 μs	774.2 ns	2.952	57.88 KB	1.59 KB	16.7
Interception With Proxy	210.16 ns	73.95 ns	59.6	624 B	248 B	64.8
Prepare And Register	78.08 μs	0 ns	0.358	60.82 KB	0 B	1.963
Prepare And Register And Simple Resolve	1.14 ms	10.12 ns	0.312	105.78 KB	24 B	2.105

15. ZenIoc — 438 of 3000

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	116.45 ns	1.48 ns	14.5	168 B	0 B	35.4
Transient	134.57 ns	14.35 ns	33.6	240 B	72 B	60.3
PerResolve	—	14.22 ns	0	—	56 B	0
Scoped	—	43.04 ns	0	—	160 B	0
Combined	322.26 ns	37.31 ns	34.4	504 B	168 B	60.3
Complex	753.65 ns	88.1 ns	34.4	1.17 KB	360 B	56
Property	—	71.85 ns	0	—	336 B	0
Generics	—	30.49 ns	0	—	144 B	0
IEnumerable	—	18.32 ns	0	—	72 B	0
Array	—	135.94 ns	0	—	624 B	0
Conditional	299.34 ns	32.72 ns	33.5	480 B	144 B	57.7
Child Container	—	774.2 ns	0	—	1.59 KB	0
Interception With Proxy	—	73.95 ns	0	—	248 B	0
Prepare And Register	3.71 μs	0 ns	1.641	4.48 KB	0 B	7.211
Prepare And Register And Simple Resolve	66.81 μs	10.12 ns	1.29	8.93 KB	24 B	7.235

16. Autofac — 402 of 3000

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	398.25 ns	1.48 ns	7.874	1.92 KB	0 B	11
Transient	809.19 ns	14.35 ns	13.8	2.44 KB	72 B	19.5
PerResolve	—	14.22 ns	0	—	56 B	0
Scoped	1.71 μs	43.04 ns	16	4.5 KB	160 B	19.9
Combined	2.07 μs	37.31 ns	13.6	4.48 KB	168 B	20.4
Complex	5.11 μs	88.1 ns	13.2	9.05 KB	360 B	20.3
Property	14.37 μs	71.85 ns	7.119	20.91 KB	336 B	13
Generics	1.81 μs	30.49 ns	13.2	3.91 KB	144 B	20.4
IEnumerable	—	18.32 ns	0	—	72 B	0
Array	6.56 μs	135.94 ns	14.4	8.6 KB	624 B	27.1
Conditional	1.61 μs	32.72 ns	14.5	3.16 KB	144 B	22.7
Child Container	11.37 μs	774.2 ns	26.1	16.03 KB	1.59 KB	31.7
Interception With Proxy	2.51 μs	73.95 ns	17.3	2.58 KB	248 B	32
Prepare And Register	50.55 μs	0 ns	0.445	48.75 KB	0 B	2.192
Prepare And Register And Simple Resolve	53.27 μs	10.12 ns	1.445	50.46 KB	24 B	3.047

17. Castle Windsor — 346 of 3000

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	256.35 ns	1.48 ns	9.807	984 B	0 B	15.4
Transient	1.01 μs	14.35 ns	12.3	2.34 KB	72 B	19.9
PerResolve	1.84 μs	14.22 ns	9.102	3.03 KB	56 B	16
Scoped	4.12 μs	43.04 ns	10.3	3.79 KB	160 B	21.7
Combined	3.71 μs	37.31 ns	10.2	5.34 KB	168 B	18.7
Complex	9.89 μs	88.1 ns	9.493	12.42 KB	360 B	17.4
Property	7.08 μs	71.85 ns	10.1	9.09 KB	336 B	19.6
Generics	7.13 μs	30.49 ns	6.645	5.84 KB	144 B	16.7
IEnumerable	—	18.32 ns	0	—	72 B	0
Array	8.6 μs	135.94 ns	12.6	12.94 KB	624 B	22.1
Conditional	2.95 μs	32.72 ns	10.7	4.8 KB	144 B	18.4
Child Container	—	774.2 ns	0	—	1.59 KB	0
Interception With Proxy	1.8 μs	73.95 ns	20.4	2.36 KB	248 B	33.4
Prepare And Register	156.68 μs	0 ns	0.253	76.2 KB	0 B	1.754
Prepare And Register And Simple Resolve	158.2 μs	10.12 ns	0.838	77.12 KB	24 B	2.465

18. MvvmCross — 323 of 3000

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	179.49 ns	1.48 ns	11.7	0 B	0 B	100
Transient	373.97 ns	14.35 ns	20.2	360 B	72 B	50
PerResolve	—	14.22 ns	0	—	56 B	0
Scoped	—	43.04 ns	0	—	160 B	0
Combined	1.33 μs	37.31 ns	16.9	1.24 KB	168 B	38.5
Complex	3.38 μs	88.1 ns	16.2	3.47 KB	360 B	32.8
Property	—	71.85 ns	0	—	336 B	0
Generics	—	30.49 ns	0	—	144 B	0
IEnumerable	—	18.32 ns	0	—	72 B	0
Array	—	135.94 ns	0	—	624 B	0
Conditional	—	32.72 ns	0	—	144 B	0
Child Container	—	774.2 ns	0	—	1.59 KB	0
Interception With Proxy	—	73.95 ns	0	—	248 B	0
Prepare And Register	847.97 ns	0 ns	3.432	2.35 KB	0 B	9.934
Prepare And Register And Simple Resolve	1.09 μs	10.12 ns	10.1	2.6 KB	24 B	13.4

19. Spring.NET — 322 of 3000

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	1.12 μs	1.48 ns	4.701	432 B	0 B	22.9
Transient	2.58 μs	14.35 ns	7.71	1.05 KB	72 B	29.5
PerResolve	—	14.22 ns	0	—	56 B	0
Scoped	—	43.04 ns	0	—	160 B	0
Combined	8.15 μs	37.31 ns	6.857	4.59 KB	168 B	20.2
Complex	17.92 μs	88.1 ns	7.052	13.9 KB	360 B	16.4
Property	72.97 μs	71.85 ns	3.16	363.72 KB	336 B	3.109
Generics	—	30.49 ns	0	—	144 B	0
IEnumerable	—	18.32 ns	0	—	72 B	0
Array	21.39 μs	135.94 ns	8	11.44 KB	624 B	23.5
Conditional	6.54 μs	32.72 ns	7.179	3.91 KB	144 B	20.4
Child Container	—	774.2 ns	0	—	1.59 KB	0
Interception With Proxy	302.11 ns	73.95 ns	49.7	392 B	248 B	80.9
Prepare And Register	5.23 μs	0 ns	1.383	16.23 KB	0 B	3.797
Prepare And Register And Simple Resolve	16.67 μs	10.12 ns	2.583	39.98 KB	24 B	3.423

20. Ninject — 186 of 3000

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	1.92 μs	1.48 ns	3.59	2.23 KB	0 B	10.2
Transient	6.66 μs	14.35 ns	4.798	4.8 KB	72 B	13.9
PerResolve	—	14.22 ns	0	—	56 B	0
Scoped	1.05 ms	43.04 ns	0.646	2.09 MB	160 B	0.916
Combined	17.33 μs	37.31 ns	4.702	13.17 KB	168 B	11.9
Complex	44.46 μs	88.1 ns	4.477	33.07 KB	360 B	10.6
Property	28.86 μs	71.85 ns	5.024	20.11 KB	336 B	13.2
Generics	18.29 μs	30.49 ns	4.149	10.83 KB	144 B	12.3
IEnumerable	—	18.32 ns	0	—	72 B	0
Array	46.45 μs	135.94 ns	5.43	26.77 KB	624 B	15.4
Conditional	14.41 μs	32.72 ns	4.837	10.27 KB	144 B	12.6
Child Container	—	774.2 ns	0	—	1.59 KB	0
Interception With Proxy	4.32 μs	73.95 ns	13.2	3.48 KB	248 B	27.5
Prepare And Register	257.87 μs	0 ns	0.197	33.74 KB	0 B	2.635
Prepare And Register And Simple Resolve	612.04 μs	10.12 ns	0.426	48.36 KB	24 B	3.113

21. Visual Studio MEF — 136 of 3000

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	4.72 μs	1.48 ns	2.289	5.79 KB	0 B	6.35
Transient	8.49 μs	14.35 ns	4.252	7.85 KB	72 B	10.9
PerResolve	—	14.22 ns	0	—	56 B	0
Scoped	—	43.04 ns	0	—	160 B	0
Combined	13.05 μs	37.31 ns	5.418	9.84 KB	168 B	13.8
Complex	22.65 μs	88.1 ns	6.272	13.92 KB	360 B	16.4
Property	20.46 μs	71.85 ns	5.967	12.09 KB	336 B	17
Generics	—	30.49 ns	0	—	144 B	0
IEnumerable	—	18.32 ns	0	—	72 B	0
Array	28.92 μs	135.94 ns	6.882	17.48 KB	624 B	19
Conditional	12.96 μs	32.72 ns	5.102	9.8 KB	144 B	12.9
Child Container	—	774.2 ns	0	—	1.59 KB	0
Interception With Proxy	—	73.95 ns	0	—	248 B	0
Prepare And Register	347.16 μs	0 ns	0.17	178.76 KB	0 B	1.145
Prepare And Register And Simple Resolve	755.32 μs	10.12 ns	0.384	184.65 KB	24 B	1.593

22. Catel — 132 of 3000

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	218.58 ns	1.48 ns	10.6	304 B	0 B	27.1
Transient	3.58 μs	14.35 ns	6.551	5.59 KB	72 B	12.9
PerResolve	—	14.22 ns	0	—	56 B	0
Scoped	—	43.04 ns	0	—	160 B	0
Combined	8.15 μs	37.31 ns	6.855	12.19 KB	168 B	12.4
Complex	17.75 μs	88.1 ns	7.086	25.99 KB	360 B	12
Property	—	71.85 ns	0	—	336 B	0
Generics	—	30.49 ns	0	—	144 B	0
IEnumerable	—	18.32 ns	0	—	72 B	0
Array	—	135.94 ns	0	—	624 B	0
Conditional	4.96 μs	32.72 ns	8.242	7.01 KB	144 B	15.3
Child Container	1.98 ms	774.2 ns	1.979	2.27 MB	1.59 KB	2.628
Interception With Proxy	—	73.95 ns	0	—	248 B	0
Prepare And Register	3.29 μs	0 ns	1.743	6.8 KB	0 B	5.859
Prepare And Register And Simple Resolve	906.77 μs	10.12 ns	0.35	1.14 MB	24 B	0.634

Benchmark overview

Basic

More overview charts (2)

Advanced

Prepare

Compared libraries (23)

	Autofac 9.3.2 A flexible inversion of control container for building extensible .NET applications.	Compare →
	Castle Windsor 6.0.0 The Castle Project container, with bound lifestyles and Castle DynamicProxy interception.	Compare →
	Catel 6.2.0 An MVVM application framework whose service locator and type factory perform constructor injection.	Compare →
	DryIoc 5.4.3 A fast, small and feature-rich container with expression-compiled resolution and rich reuse options.	Compare →
	Faster.Ioc 5.0.0 A minimalistic container focused on the shortest possible resolve path.	Compare →
	Grace 7.2.1 A container with a fluent registration model, per-object-graph lifestyles and decorator support.	Compare →
	Hand-coded Direct dependency injection written in C# without a container.	Compare →
	Lamar 16.0.0 The successor to StructureMap, built around runtime code generation.	Compare →
	LightInject 7.1.0 A lightweight container with an ultra-small API surface and its own interception package.	Compare →
	Maestro 3.6.6 A small container with a fluent configuration API and pluggable activation interceptors.	Compare →
	Managed Extensibility Framework 2 10.0.10 The lightweight Managed Extensibility Framework composition engine shipped as System.Composition.	Compare →
	Microsoft Extensions Dependency Injection 10.0.10 The built-in .NET dependency injection container and its service collection abstractions.	Compare →
	MvvmCross 10.1.2 A cross-platform MVVM framework with its own inversion of control provider.	Compare →
	Ninject 3.3.6 A container built around fluent bindings, contextual conditions and pluggable extensions.	Compare →
	Pure.DI 2.5.2 A compile-time dependency injection framework that generates strongly typed compositions.	Compare →
	Simple Injector 5.6.0 A fast, opinionated dependency injection library that promotes explicit configuration and maintainable application design.	Compare →
	Singularity 0.18.0 An expression-tree based container that validates the whole object graph when the container is built.	Compare →
	Spring.NET 3.1.0 The Spring.NET application framework and its XML or code configured object factory.	Compare →
	Stashbox 5.21.0 A fast container with per-request lifetimes, conditional registrations and child containers.	Compare →
	StructureMap 4.7.1 A mature container with a fluent registry DSL, nested containers and decorators.	Compare →
	Unity 5.11.10 The Unity container, offering per-resolve lifetimes and hierarchical child containers.	Compare →
	Visual Studio MEF 17.13.41 The Visual Studio composition engine, a fast attribute-driven MEF implementation.	Compare →
	ZenIoc 1.0.1 A tiny container with compiled registrations, named resolution and nested containers.	Compare →

Benchmark scenarios (15)

01 · Singleton

Registers three singleton services and resolves each of them repeatedly. Every resolve of the same service must return the same instance.

02 · Transient

Registers three transient services and resolves each of them repeatedly. Every resolve must create a new instance, never reusing an earlier one.

03 · PerResolve

Resolves an object graph that asks for the same dependency twice. Both requests inside one resolution share an instance, while the next resolution gets a new one.

04 · Scoped

Resolves scoped services inside explicit scopes. One instance per scope, different instances across scopes, and scope-owned disposables are disposed when the scope ends.

05 · Combined

Resolves three roots that mix singleton and transient dependencies. The singleton is shared across every root while each transient dependency is distinct.

06 · Complex

Registers and resolves three multi-level object graphs, checking that every nested dependency has the expected implementation type and lifetime.

07 · Property

Resolves three roots that carry writable service properties. The container, or its intended property-injection extension, must assign them during activation.

08 · Generics

Registers one open generic service mapping and resolves roots closed over int, float and object. Registering every closed type separately does not count.

09 · IEnumerable

Injects a sequence of five plugin implementations and requires it to be genuinely lazy: nothing is created until enumeration, and every enumeration yields new transients.

10 · Array

Resolves three roots that materialise their injected sequence of five plugins into an array while the root is being activated.

11 · Conditional

Gives each of three consumers a different implementation of one contract, chosen through the metadata, key, predicate or consumer-context mechanism of the library.

12 · Child Container

Creates a real nested child container that inherits the registrations of its parent and can add or override them without changing the parent.

13 · Interception With Proxy

Resolves a service through the interception or activation extension point of the library. The result must be a proxy whose interceptor proceeds to the real target.

14 · Prepare And Register

Measures creating the container and registering the whole prescribed graph, without resolving anything from it.

15 · Prepare And Register And Simple Resolve

Measures the same setup as Prepare And Register, followed by a single resolve of one singleton root.

JSON Serialization

System.Text.Json leads the current rating · 3 libraries · 14 scenarios

Explore interactively →

Rating

In every scenario the fastest library scores 100 points and the one allocating least scores 100 more; four times slower is half the points, and an unsupported scenario is worth nothing. Time and memory reach 1400 each here, so the maximum is 2800. See workflows/rating.md.

#	Library	Scenarios	Time	Memory	Points	Group wins
1	System.Text.Json	14/14	1267	1249	2516	gold in Advanced, gold in Basic, gold in Collections, gold in Stream, silver in Nested, silver in Prepare
2	ServiceStack.Text	12/14	1116	888	2003	gold in Nested, gold in Prepare, silver in Advanced, silver in Basic, silver in Collections, silver in Stream
3	Newtonsoft.Json	13/14	816	398	1215	bronze in Advanced, bronze in Basic, bronze in Collections, bronze in Nested, bronze in Prepare, bronze in Stream

How the points were earned — every scenario, with the measurements behind it

Each row is one scenario. Best is the lowest result among the rated libraries that completed it, and the points follow from the two figures beside them: 100 × √((best + step) / (result + step)), with a step of 1 ns for time and 24 B for memory. A dash means the library did not complete the scenario, and it scores nothing for it. Add the two Points columns over every scenario and you get the rating above. The same breakdown appears as a hint on any points value in the application.

1. System.Text.Json — 2516 of 2800

Scenario	Time	Best	Points	Memory	Best	Points
Serialize Simple Object	194.88 ns	194.88 ns	100	96 B	96 B	100
Deserialize Simple Object	237.92 ns	191.59 ns	89.8	64 B	64 B	100
Serialize Nested Object	458.38 ns	458.38 ns	100	504 B	504 B	100
Deserialize Nested Object	630.1 ns	536.76 ns	92.3	768 B	320 B	65.9
Serialize Collection	576.1 ns	576.1 ns	100	560 B	560 B	100
Deserialize Collection	907.13 ns	792.08 ns	93.5	800 B	472 B	77.6
Serialize Dictionary	194.88 ns	194.88 ns	100	88 B	88 B	100
Deserialize Dictionary	332.23 ns	274.05 ns	90.9	312 B	312 B	100
Enum Round Trip	331.81 ns	331.81 ns	100	88 B	88 B	100
Custom Converter Round Trip	324.68 ns	324.68 ns	100	120 B	120 B	100
Polymorphic Round Trip	1.96 μs	1.96 μs	100	1.32 KB	1.32 KB	100
UTF-8 Stream Round Trip	591.28 ns	591.28 ns	100	280 B	280 B	100
Source Generation Round Trip	422.54 ns	422.54 ns	100	160 B	160 B	100
Prepare Serializer	19.69 μs	0 ns	0.713	7.45 KB	0 B	5.6

2. ServiceStack.Text — 2003 of 2800

Scenario	Time	Best	Points	Memory	Best	Points
Serialize Simple Object	318.22 ns	194.88 ns	78.3	336 B	96 B	57.7
Deserialize Simple Object	191.59 ns	191.59 ns	100	112 B	64 B	80.4
Serialize Nested Object	607.29 ns	458.38 ns	86.9	792 B	504 B	80.4
Deserialize Nested Object	536.76 ns	536.76 ns	100	320 B	320 B	100
Serialize Collection	910.16 ns	576.1 ns	79.6	1000 B	560 B	75.5
Deserialize Collection	792.08 ns	792.08 ns	100	472 B	472 B	100
Serialize Dictionary	202.92 ns	194.88 ns	98	288 B	88 B	59.9
Deserialize Dictionary	274.05 ns	274.05 ns	100	424 B	312 B	86.6
Enum Round Trip	338.33 ns	331.81 ns	99	336 B	88 B	55.8
Custom Converter Round Trip	330.09 ns	324.68 ns	99.2	392 B	120 B	58.8
Polymorphic Round Trip	—	1.96 μs	0	—	1.32 KB	0
UTF-8 Stream Round Trip	1.06 μs	591.28 ns	74.7	2.8 KB	280 B	32.4
Source Generation Round Trip	—	422.54 ns	0	—	160 B	0
Prepare Serializer	0 ns	0 ns	100	0 B	0 B	100

3. Newtonsoft.Json — 1215 of 2800

Scenario	Time	Best	Points	Memory	Best	Points
Serialize Simple Object	378.28 ns	194.88 ns	71.9	1.41 KB	96 B	28.6
Deserialize Simple Object	604.7 ns	191.59 ns	56.4	2.61 KB	64 B	18.1
Serialize Nested Object	662.52 ns	458.38 ns	83.2	1.63 KB	504 B	55.9
Deserialize Nested Object	1.13 μs	536.76 ns	68.8	2.89 KB	320 B	34
Serialize Collection	969.57 ns	576.1 ns	77.1	1.83 KB	560 B	55.5
Deserialize Collection	1.67 μs	792.08 ns	69	2.99 KB	472 B	40.1
Serialize Dictionary	405.9 ns	194.88 ns	69.4	1.48 KB	88 B	27
Deserialize Dictionary	639.01 ns	274.05 ns	65.6	2.83 KB	312 B	33.9
Enum Round Trip	1.08 μs	331.81 ns	55.5	4.68 KB	88 B	15.2
Custom Converter Round Trip	958.67 ns	324.68 ns	58.3	4.68 KB	120 B	17.3
Polymorphic Round Trip	3.83 μs	1.96 μs	71.5	7.79 KB	1.32 KB	41.5
UTF-8 Stream Round Trip	1.23 μs	591.28 ns	69.5	4.13 KB	280 B	26.8
Source Generation Round Trip	—	422.54 ns	0	—	160 B	0
Prepare Serializer	65.98 μs	0 ns	0.389	11.64 KB	0 B	4.482

Benchmark overview

Basic

More overview charts (5)

Nested

Collections

Advanced

Stream

Prepare

Compared libraries (3)

	Newtonsoft.Json 13.0.4 A mature JSON framework for .NET with configurable contracts, converters, and streaming readers and writers.	Compare →
	ServiceStack.Text 10.0.8 A high-performance text library with typed JSON, stream, collection, and type-specific serialization APIs.	Compare →
	System.Text.Json The reflection-based and source-generated JSON serializer included with .NET.	Compare →

Benchmark scenarios (14)

01 · Serialize Simple Object

Serializes one scalar object to a compact JSON string.

02 · Deserialize Simple Object

Deserializes one compact JSON object and validates every scalar member.

03 · Serialize Nested Object

Serializes an order, customer, and address object graph.

04 · Deserialize Nested Object

Deserializes and materializes an order, customer, and address object graph.

05 · Serialize Collection

Serializes three ordered objects to a compact JSON array.

06 · Deserialize Collection

Deserializes a compact JSON array to three ordered objects.

07 · Serialize Dictionary

Serializes three ordered string and integer entries to a JSON object.

08 · Deserialize Dictionary

Deserializes a JSON object to three ordinal string and integer entries.

09 · Enum Round Trip

Serializes an enum as its string name and deserializes it back.

10 · Custom Converter Round Trip

Serializes a strongly typed identifier as a JSON string and deserializes it back.

11 · Polymorphic Round Trip

Round-trips a base-type collection through safe cat and dog discriminators.

12 · UTF-8 Stream Round Trip

Serializes a simple object to a new UTF-8 memory stream and deserializes it back.

13 · Source Generation Round Trip

Round-trips a simple object with compile-time generated JSON metadata.

14 · Prepare Serializer

Creates fresh serializer settings and explicit type metadata without serializing data.

LINQ Queries

ZLinq leads the current rating · 6 libraries · 18 scenarios

Explore interactively →

Rating

In every scenario the fastest library scores 100 points and the one allocating least scores 100 more; four times slower is half the points, and an unsupported scenario is worth nothing. Time and memory reach 1800 each here, so the maximum is 3600. See workflows/rating.md.

#	Library	Scenarios	Time	Memory	Points	Group wins
1	ZLinq	17/18	1569	1697	3266	gold in Advanced, gold in Core, gold in Sequences, gold in Sources, silver in Partitioning
2	System.Linq	16/18	1467	1373	2840	gold in Partitioning, silver in Advanced, silver in Core, bronze in Sequences, bronze in Sources
3	StructLinq	15/18	1072	1329	2401	gold in Allocation-Free, silver in Sequences
4	LinqAF	16/18	1095	1072	2167	silver in Allocation-Free, bronze in Advanced, bronze in Partitioning
5	NetFabric.Hyperlinq	12/18	932	900	1833	silver in Sources, bronze in Allocation-Free, bronze in Core

How the points were earned — every scenario, with the measurements behind it

Each row is one scenario. Best is the lowest result among the rated libraries that completed it, and the points follow from the two figures beside them: 100 × √((best + step) / (result + step)), with a step of 1 ns for time and 24 B for memory. A dash means the library did not complete the scenario, and it scores nothing for it. Add the two Points columns over every scenario and you get the rating above. The same breakdown appears as a hint on any points value in the application.

1. ZLinq — 3266 of 3600

Scenario	Time	Best	Points	Memory	Best	Points
Filter and Count	10.98 μs	10.18 μs	96.3	0 B	0 B	100
Project To Array	5.12 μs	4.82 μs	97.1	39.09 KB	39.09 KB	100
Filter, Project, Materialize	7.8 μs	5.88 μs	86.8	9.83 KB	9.83 KB	100
Chained Pipeline	12.23 μs	9.39 μs	87.6	3.93 KB	3.93 KB	100
List Source	18.12 μs	13.73 μs	87.1	13.07 KB	13.07 KB	100
Opaque Source	33.47 μs	29.01 μs	93.1	13.1 KB	13.1 KB	100
Span Source	14.34 μs	14.34 μs	100	13.07 KB	13.07 KB	100
Paged Slice	260.72 ns	228.74 ns	93.7	3.93 KB	3.93 KB	100
Any Match	3.39 μs	3.38 μs	99.8	0 B	0 B	100
First Match	2.79 μs	2.77 μs	99.6	0 B	0 B	100
Flatten Nested Sequences	28.04 μs	6.39 μs	47.7	39.09 KB	39.09 KB	100
Distinct Values	42.49 μs	33.67 μs	89	3.98 KB	3.98 KB	100
Zip Pairs	14.97 μs	14.97 μs	100	39.09 KB	39.09 KB	100
Aggregate	3.7 μs	3.56 μs	98	0 B	0 B	100
Ordered Top N	41.96 μs	36.56 μs	93.3	264 B	248 B	97.2
Group and Aggregate	108.22 μs	108.09 μs	99.9	130.59 KB	130.59 KB	100
Join and Project	84.57 μs	84.57 μs	100	129.19 KB	129.19 KB	100
Struct Predicate Filter	—	11.09 μs	0	—	40 B	0

2. System.Linq — 2840 of 3600

Scenario	Time	Best	Points	Memory	Best	Points
Filter and Count	10.18 μs	10.18 μs	100	48 B	0 B	57.7
Project To Array	4.82 μs	4.82 μs	100	39.13 KB	39.09 KB	99.9
Filter, Project, Materialize	5.88 μs	5.88 μs	100	9.93 KB	9.83 KB	99.5
Chained Pipeline	15.2 μs	9.39 μs	78.6	4.14 KB	3.93 KB	97.4
List Source	13.73 μs	13.73 μs	100	13.22 KB	13.07 KB	99.4
Opaque Source	29.01 μs	29.01 μs	100	13.22 KB	13.1 KB	99.6
Span Source	—	14.34 μs	0	—	13.07 KB	0
Paged Slice	228.74 ns	228.74 ns	100	4.02 KB	3.93 KB	98.8
Any Match	3.38 μs	3.38 μs	100	0 B	0 B	100
First Match	2.77 μs	2.77 μs	100	0 B	0 B	100
Flatten Nested Sequences	6.39 μs	6.39 μs	100	39.18 KB	39.09 KB	99.9
Distinct Values	88.75 μs	33.67 μs	61.6	179.3 KB	3.98 KB	14.9
Zip Pairs	82.99 μs	14.97 μs	42.5	39.24 KB	39.09 KB	99.8
Aggregate	3.59 μs	3.56 μs	99.5	0 B	0 B	100
Ordered Top N	36.56 μs	36.56 μs	100	78.56 KB	248 B	5.814
Group and Aggregate	108.09 μs	108.09 μs	100	131.27 KB	130.59 KB	99.7
Join and Project	116.84 μs	84.57 μs	85.1	129.45 KB	129.19 KB	99.9
Struct Predicate Filter	—	11.09 μs	0	—	40 B	0

3. StructLinq — 2401 of 3600

Scenario	Time	Best	Points	Memory	Best	Points
Filter and Count	12.65 μs	10.18 μs	89.7	64 B	0 B	52.2
Project To Array	11.03 μs	4.82 μs	66.1	39.09 KB	39.09 KB	100
Filter, Project, Materialize	25.43 μs	5.88 μs	48.1	9.9 KB	9.83 KB	99.6
Chained Pipeline	12.43 μs	9.39 μs	86.9	4.06 KB	3.93 KB	98.4
List Source	18.67 μs	13.73 μs	85.8	13.14 KB	13.07 KB	99.7
Opaque Source	31.05 μs	29.01 μs	96.7	13.16 KB	13.1 KB	99.8
Span Source	—	14.34 μs	0	—	13.07 KB	0
Paged Slice	916.58 ns	228.74 ns	50	3.99 KB	3.93 KB	99.2
Any Match	8.61 μs	3.38 μs	62.6	32 B	0 B	65.5
First Match	5.13 μs	2.77 μs	73.4	32 B	0 B	65.5
Flatten Nested Sequences	47.5 μs	6.39 μs	36.7	54.77 KB	39.09 KB	84.5
Distinct Values	33.67 μs	33.67 μs	100	4.01 KB	3.98 KB	99.7
Zip Pairs	29.34 μs	14.97 μs	71.4	39.19 KB	39.09 KB	99.9
Aggregate	7.11 μs	3.56 μs	70.7	32 B	0 B	65.5
Ordered Top N	317.03 μs	36.56 μs	34	248 B	248 B	100
Group and Aggregate	—	108.09 μs	0	—	130.59 KB	0
Join and Project	—	84.57 μs	0	—	129.19 KB	0
Struct Predicate Filter	11.09 μs	11.09 μs	100	40 B	40 B	100

4. LinqAF — 2167 of 3600

Scenario	Time	Best	Points	Memory	Best	Points
Filter and Count	11.27 μs	10.18 μs	95.1	0 B	0 B	100
Project To Array	27.25 μs	4.82 μs	42.1	151.38 KB	39.09 KB	50.8
Filter, Project, Materialize	8.79 μs	5.88 μs	81.8	32.27 KB	9.83 KB	55.2
Chained Pipeline	9.39 μs	9.39 μs	100	3.93 KB	3.93 KB	100
List Source	24.63 μs	13.73 μs	74.7	45.31 KB	13.07 KB	53.7
Opaque Source	40.96 μs	29.01 μs	84.2	45.34 KB	13.1 KB	53.8
Span Source	—	14.34 μs	0	—	13.07 KB	0
Paged Slice	2.65 μs	228.74 ns	29.4	3.93 KB	3.93 KB	100
Any Match	3.39 μs	3.38 μs	99.9	0 B	0 B	100
First Match	2.82 μs	2.77 μs	99	0 B	0 B	100
Flatten Nested Sequences	82.63 μs	6.39 μs	27.8	151.38 KB	39.09 KB	50.8
Distinct Values	247 μs	33.67 μs	36.9	246.72 KB	3.98 KB	12.7
Zip Pairs	33.76 μs	14.97 μs	66.6	151.38 KB	39.09 KB	50.8
Aggregate	3.56 μs	3.56 μs	100	0 B	0 B	100
Ordered Top N	306.38 μs	36.56 μs	34.5	257.14 KB	248 B	3.214
Group and Aggregate	249.23 μs	108.09 μs	65.9	194.7 KB	130.59 KB	81.9
Join and Project	258.31 μs	84.57 μs	57.2	374.56 KB	129.19 KB	58.7
Struct Predicate Filter	—	11.09 μs	0	—	40 B	0

5. NetFabric.Hyperlinq — 1833 of 3600

Scenario	Time	Best	Points	Memory	Best	Points
Filter and Count	14.74 μs	10.18 μs	83.1	0 B	0 B	100
Project To Array	10.08 μs	4.82 μs	69.2	39.09 KB	39.09 KB	100
Filter, Project, Materialize	8.87 μs	5.88 μs	81.4	32.27 KB	9.83 KB	55.2
Chained Pipeline	11.64 μs	9.39 μs	89.8	8.3 KB	3.93 KB	68.9
List Source	19.46 μs	13.73 μs	84	29.48 KB	13.07 KB	66.6
Opaque Source	29.74 μs	29.01 μs	98.8	29.52 KB	13.1 KB	66.7
Span Source	14.49 μs	14.34 μs	99.5	29.48 KB	13.07 KB	66.6
Paged Slice	923.27 ns	228.74 ns	49.9	3.93 KB	3.93 KB	100
Any Match	6.71 μs	3.38 μs	71	0 B	0 B	100
First Match	3.19 μs	2.77 μs	93.1	0 B	0 B	100
Flatten Nested Sequences	35.31 μs	6.39 μs	42.5	103.7 KB	39.09 KB	61.4
Distinct Values	68.33 μs	33.67 μs	70.2	179.21 KB	3.98 KB	15
Zip Pairs	—	14.97 μs	0	—	39.09 KB	0
Aggregate	—	3.56 μs	0	—	0 B	0
Ordered Top N	—	36.56 μs	0	—	248 B	0
Group and Aggregate	—	108.09 μs	0	—	130.59 KB	0
Join and Project	—	84.57 μs	0	—	129.19 KB	0
Struct Predicate Filter	—	11.09 μs	0	—	40 B	0

Benchmark overview

Core

More overview charts (5)

Sources

Partitioning

Sequences

Advanced

Allocation-Free

Compared libraries (6)

	Hand-coded Direct loops written in C# without any query library.	Compare →
	LinqAF 3.0.0 A low-allocation re-implementation of LINQ-to-Objects that shadows the System.Linq operators and returns struct enumerables. Last released in 2019.	Compare →
	NetFabric.Hyperlinq 3.0.0-beta9 A value-enumerable LINQ implementation with span sources and low-allocation pipelines. The compared version is a prerelease.	Compare →
	StructLinq 0.28.2 A struct-based LINQ implementation with optional struct predicates that avoid delegate indirection. Last released in 2022.	Compare →
	System.Linq The LINQ-to-Objects implementation included with .NET, exposing the Enumerable operators over IEnumerable sequences.	Compare →
	ZLinq 1.5.6 A zero-allocation LINQ implementation built on struct enumerators, with span and SIMD support and a complete operator surface.	Compare →

Benchmark scenarios (18)

01 · Filter and Count

Filters 10,000 integers with a predicate and counts the survivors.

02 · Project To Array

Projects 10,000 integers through a selector and materializes a new array.

03 · Filter, Project, Materialize

Filters 5,000 orders by amount, projects one property, and materializes a list.

04 · Chained Pipeline

Composes a filter, a projection, a second filter, and a limit into one four-stage query.

05 · List Source

Runs the canonical filter and projection over a List<int>.

06 · Opaque Source

Runs the same query over an IEnumerable<int> exposing no count, indexer, or array.

07 · Span Source

Runs the same query over a ReadOnlySpan<int>.

08 · Paged Slice

Skips 4,000 integers, takes the next 1,000, and materializes them.

09 · Any Match

Reports whether any of 10,000 integers satisfies a predicate first met at index 9,500.

10 · First Match

Returns the first of 5,000 orders satisfying a predicate first met at index 4,500.

11 · Flatten Nested Sequences

Flattens 500 inner arrays of 20 integers and materializes the result.

12 · Distinct Values

Reduces 10,000 integers containing 1,000 distinct values to the distinct set.

13 · Zip Pairs

Pairs two sequences of 10,000 integers and materializes the products.

14 · Aggregate

Folds 10,000 integers with a caller-supplied accumulator and a seed.

15 · Ordered Top N

Orders 5,000 orders by descending amount and materializes the identifiers of the top 20.

16 · Group and Aggregate

Groups 5,000 orders by region and produces one summed total per region.

17 · Join and Project

Joins 5,000 orders to 500 customers on the customer key and projects the pairs.

18 · Struct Predicate Filter

Filters and counts 10,000 integers with a struct-typed predicate instead of a delegate.

Logging

Microsoft.Extensions.Logging leads the current rating · 6 libraries · 9 scenarios

Explore interactively →

Rating

In every scenario the fastest library scores 100 points and the one allocating least scores 100 more; four times slower is half the points, and an unsupported scenario is worth nothing. Time and memory reach 900 each here, so the maximum is 1800. See workflows/rating.md.

#	Library	Scenarios	Time	Memory	Points	Group wins
1	Microsoft.Extensions.Logging	7/9	552	638	1190	gold in Structured
2	NLog	9/9	703	454	1157	gold in Core, silver in Structured, bronze in Prepare
3	Serilog	9/9	535	458	993	gold in Prepare
4	log4net	9/9	420	411	831	silver in Prepare, bronze in Structured
5	OpenTelemetry	8/9	336	490	825	silver in Core
6	ZLogger	4/9	226	338	564	bronze in Core

How the points were earned — every scenario, with the measurements behind it

Each row is one scenario. Best is the lowest result among the rated libraries that completed it, and the points follow from the two figures beside them: 100 × √((best + step) / (result + step)), with a step of 1 ns for time and 24 B for memory. A dash means the library did not complete the scenario, and it scores nothing for it. Add the two Points columns over every scenario and you get the rating above. The same breakdown appears as a hint on any points value in the application.

1. Microsoft.Extensions.Logging — 1190 of 1800

Scenario	Time	Best	Points	Memory	Best	Points
Disabled Log	9.81 ns	0 ns	30.4	0 B	0 B	100
Simple Message	19.66 ns	19.66 ns	100	0 B	0 B	100
Structured Properties	48.78 ns	48.78 ns	100	88 B	88 B	100
Exception	19.33 ns	19.33 ns	100	0 B	0 B	100
Scope Or Context	72.75 ns	72.75 ns	100	120 B	120 B	100
Template Rendering	36.41 ns	36.41 ns	100	0 B	0 B	100
Buffered Logging	—	98.14 ns	0	—	0 B	0
Create Logger	24 μs	1.08 μs	21.2	21.18 KB	3.07 KB	38.2
Formatted Output	—	197.7 ns	0	—	0 B	0

2. NLog — 1157 of 1800

Scenario	Time	Best	Points	Memory	Best	Points
Disabled Log	0 ns	0 ns	100	0 B	0 B	100
Simple Message	44.03 ns	19.66 ns	67.7	120 B	0 B	40.8
Structured Properties	89.82 ns	48.78 ns	74	248 B	88 B	64.2
Exception	43.99 ns	19.33 ns	67.2	120 B	0 B	40.8
Scope Or Context	106.32 ns	72.75 ns	82.9	248 B	120 B	72.8
Template Rendering	86.23 ns	36.41 ns	65.5	232 B	0 B	30.6
Buffered Logging	98.14 ns	98.14 ns	100	120 B	0 B	40.8
Create Logger	5.23 μs	1.08 μs	45.4	24.46 KB	3.07 KB	35.6
Formatted Output	197.7 ns	197.7 ns	100	272 B	0 B	28.5

3. Serilog — 993 of 1800

Scenario	Time	Best	Points	Memory	Best	Points
Disabled Log	1.32 ns	0 ns	65.7	0 B	0 B	100
Simple Message	88.5 ns	19.66 ns	48	160 B	0 B	36.1
Structured Properties	194.76 ns	48.78 ns	50.4	448 B	88 B	48.7
Exception	92.67 ns	19.33 ns	46.6	160 B	0 B	36.1
Scope Or Context	200.67 ns	72.75 ns	60.5	544 B	120 B	50.4
Template Rendering	194.96 ns	36.41 ns	43.7	432 B	0 B	22.9
Buffered Logging	457.55 ns	98.14 ns	46.5	160 B	0 B	36.1
Create Logger	1.08 μs	1.08 μs	100	3.07 KB	3.07 KB	100
Formatted Output	362.71 ns	197.7 ns	73.9	296 B	0 B	27.4

4. log4net — 831 of 1800

Scenario	Time	Best	Points	Memory	Best	Points
Disabled Log	8.56 ns	0 ns	32.4	0 B	0 B	100
Simple Message	121.57 ns	19.66 ns	41.1	168 B	0 B	35.4
Structured Properties	205.48 ns	48.78 ns	49.1	344 B	88 B	55.2
Exception	124.81 ns	19.33 ns	40.2	168 B	0 B	35.4
Scope Or Context	322.5 ns	72.75 ns	47.7	848 B	120 B	40.6
Template Rendering	156.57 ns	36.41 ns	48.7	280 B	0 B	28.1
Buffered Logging	489.49 ns	98.14 ns	45	848 B	0 B	16.6
Create Logger	15.27 μs	1.08 μs	26.6	6.79 KB	3.07 KB	67.4
Formatted Output	246.62 ns	197.7 ns	89.6	211 B	0 B	32

5. OpenTelemetry — 825 of 1800

Scenario	Time	Best	Points	Memory	Best	Points
Disabled Log	9.62 ns	0 ns	30.7	0 B	0 B	100
Simple Message	114.01 ns	19.66 ns	42.4	48 B	0 B	57.7
Structured Properties	247.16 ns	48.78 ns	44.8	216 B	88 B	68.3
Exception	116.08 ns	19.33 ns	41.7	48 B	0 B	57.7
Scope Or Context	212.45 ns	72.75 ns	58.8	168 B	120 B	86.6
Template Rendering	268.49 ns	36.41 ns	37.3	112 B	0 B	42
Buffered Logging	183.56 ns	98.14 ns	73.3	48 B	0 B	57.7
Create Logger	239.4 μs	1.08 μs	6.708	81.25 KB	3.07 KB	19.5
Formatted Output	—	197.7 ns	0	—	0 B	0

6. ZLogger — 564 of 1800

Scenario	Time	Best	Points	Memory	Best	Points
Disabled Log	3.96 ns	0 ns	44.9	0 B	0 B	100
Simple Message	—	19.66 ns	0	—	0 B	0
Structured Properties	—	48.78 ns	0	—	88 B	0
Exception	—	19.33 ns	0	—	0 B	0
Scope Or Context	—	72.75 ns	0	—	120 B	0
Template Rendering	—	36.41 ns	0	—	0 B	0
Buffered Logging	115.82 ns	98.14 ns	92.1	0 B	0 B	100
Create Logger	48.21 μs	1.08 μs	14.9	21.36 KB	3.07 KB	38
Formatted Output	357.31 ns	197.7 ns	74.5	0 B	0 B	100

Benchmark overview

Core

More overview charts (2)

Structured

Prepare

Compared libraries (6)

	log4net 3.3.2 A mature Apache logging framework with hierarchical repositories, contextual properties, layouts, and appenders.	Compare →
	Microsoft.Extensions.Logging 10.0.10 The standard .NET logging abstraction and logger factory with providers, filtering, structured state, and scopes.	Compare →
	NLog 6.1.4 A configurable logging platform with structured events, scope context, targets, layouts, and asynchronous wrappers.	Compare →
	OpenTelemetry 1.17.0 The OpenTelemetry .NET logging provider and processing pipeline for collecting, enriching, batching, and exporting MEL log records.	Compare →
	Serilog 4.4.0 A structured event logger with message templates, contextual enrichment, and a broad sink ecosystem.	Compare →
	ZLogger 2.5.10 A source-generated and interpolated-string logger built on Microsoft.Extensions.Logging with UTF-8 and processor APIs.	Compare →

Benchmark scenarios (9)

01 · Disabled Log

Submits an Information event to a logger whose minimum level is Warning.

02 · Simple Message

Delivers one literal Information message to an in-memory sink.

03 · Structured Properties

Delivers one event with independently queryable OrderId and ElapsedMs properties.

04 · Exception

Delivers one Error event retaining the original exception metadata.

05 · Scope Or Context

Creates a temporary RequestId context and captures it on one event.

06 · Template Rendering

Formats amount 12.5 and customer Ada through the logger template API.

07 · Buffered Logging

Enqueues one event to a library-provided async or buffering wrapper and validates delivery after flush.

08 · Create Logger

Creates, verifies, and releases one Information-enabled logger with an in-memory sink.

09 · Formatted Output

Formats one event synchronously into a bounded in-memory sink.

Object Mapping

Mapperly leads the current rating · 4 libraries · 10 scenarios

Explore interactively →

Rating

In every scenario the fastest library scores 100 points and the one allocating least scores 100 more; four times slower is half the points, and an unsupported scenario is worth nothing. Time and memory reach 1000 each here, so the maximum is 2000. See workflows/rating.md.

#	Library	Scenarios	Time	Memory	Points	Group wins
1	Mapperly	10/10	1000	1000	2000	gold in Advanced, gold in Basic, gold in Prepare
2	Mapster	10/10	576	792	1367	silver in Advanced, silver in Basic, bronze in Prepare
3	AutoMapper	10/10	395	802	1197	silver in Prepare, bronze in Advanced, bronze in Basic

How the points were earned — every scenario, with the measurements behind it

Each row is one scenario. Best is the lowest result among the rated libraries that completed it, and the points follow from the two figures beside them: 100 × √((best + step) / (result + step)), with a step of 1 ns for time and 24 B for memory. A dash means the library did not complete the scenario, and it scores nothing for it. Add the two Points columns over every scenario and you get the rating above. The same breakdown appears as a hint on any points value in the application.

1. Mapperly — 2000 of 2000

Scenario	Time	Best	Points	Memory	Best	Points
Simple Object	8.87 ns	8.87 ns	100	56 B	56 B	100
Nested Object	46.89 ns	46.89 ns	100	248 B	248 B	100
Collection	1 μs	1 μs	100	6.27 KB	6.27 KB	100
Flattening	9.78 ns	9.78 ns	100	56 B	56 B	100
Map To Existing	3.8 ns	3.8 ns	100	0 B	0 B	100
Null Handling	8.65 ns	8.65 ns	100	40 B	40 B	100
Custom Conversion	77.08 ns	77.08 ns	100	88 B	88 B	100
Polymorphic Mapping	33.77 ns	33.77 ns	100	144 B	144 B	100
Prepare Configuration	0 ns	0 ns	100	0 B	0 B	100
Prepare And Simple Map	9.22 ns	9.22 ns	100	56 B	56 B	100

2. Mapster — 1367 of 2000

Scenario	Time	Best	Points	Memory	Best	Points
Simple Object	22.61 ns	8.87 ns	64.7	56 B	56 B	100
Nested Object	59.97 ns	46.89 ns	88.6	248 B	248 B	100
Collection	1.14 μs	1 μs	93.5	6.27 KB	6.27 KB	100
Flattening	19.55 ns	9.78 ns	72.4	56 B	56 B	100
Map To Existing	12.5 ns	3.8 ns	59.6	0 B	0 B	100
Null Handling	28.77 ns	8.65 ns	56.9	40 B	40 B	100
Custom Conversion	105.78 ns	77.08 ns	85.5	112 B	88 B	90.7
Polymorphic Mapping	116.32 ns	33.77 ns	54.4	144 B	144 B	100
Prepare Configuration	24.26 ms	0 ns	0.02	2.6 MB	0 B	0.297
Prepare And Simple Map	25.5 ms	9.22 ns	0.063	2.75 MB	56 B	0.526

3. AutoMapper — 1197 of 2000

Scenario	Time	Best	Points	Memory	Best	Points
Simple Object	77.41 ns	8.87 ns	35.5	56 B	56 B	100
Nested Object	115.28 ns	46.89 ns	64.2	248 B	248 B	100
Collection	1.21 μs	1 μs	91.1	6.27 KB	6.27 KB	100
Flattening	77.69 ns	9.78 ns	37	56 B	56 B	100
Map To Existing	66.23 ns	3.8 ns	26.7	0 B	0 B	100
Null Handling	76.48 ns	8.65 ns	35.3	40 B	40 B	100
Custom Conversion	142.1 ns	77.08 ns	73.9	88 B	88 B	100
Polymorphic Mapping	349.9 ns	33.77 ns	31.5	144 B	144 B	100
Prepare Configuration	13.05 ms	0 ns	0.028	624.69 KB	0 B	0.613
Prepare And Simple Map	13.62 ms	9.22 ns	0.087	657.5 KB	56 B	1.09

Benchmark overview

Basic

More overview charts (2)

Advanced

Prepare

Compared libraries (4)

	AutoMapper 16.2.0 A convention-based object-object mapper with runtime configuration and compiled mapping plans.	Compare →
	Hand-coded Direct object mapping written in C# without a mapping library.	Compare →
	Mapperly 4.3.1 A source generator that creates readable object mapping code at compile time.	Compare →
	Mapster 10.0.11 An object mapper with runtime configuration, expression compilation, and projection support.	Compare →

Benchmark scenarios (10)

01 · Simple Object

Maps one object with scalar values to a newly allocated destination object.

02 · Nested Object

Maps an order with nested customer and address objects to a new destination graph.

03 · Collection

Maps an array of 100 objects while preserving count, order and member values.

04 · Flattening

Maps nested customer values into a flat order summary through member-path configuration.

05 · Map To Existing

Overwrites a supplied destination object and returns that same instance.

06 · Null Handling

Preserves null text, nested object and collection members in the destination.

07 · Custom Conversion

Maps string values through registered code and invariant decimal conversions.

08 · Polymorphic Mapping

Maps a base array containing cats and dogs to matching destination runtime types.

09 · Prepare Configuration

Creates the complete mapper configuration and eagerly prepares its runtime mapping plans.

10 · Prepare And Simple Map

Creates the complete mapper configuration and maps one simple object.

Validation

Microsoft.Extensions.Validation leads the current rating · 4 libraries · 10 scenarios

Explore interactively →

Rating

In every scenario the fastest library scores 100 points and the one allocating least scores 100 more; four times slower is half the points, and an unsupported scenario is worth nothing. Time and memory reach 1000 each here, so the maximum is 2000. See workflows/rating.md.

#	Library	Scenarios	Time	Memory	Points	Group wins
1	Microsoft.Extensions.Validation	8/10	754	786	1540	gold in Basic, gold in Object Graph, silver in Prepare, bronze in Rules
2	DataAnnotations	9/10	741	736	1476	gold in Prepare, gold in Rules, bronze in Object Graph
3	MiniValidation	8/10	722	722	1444	silver in Basic, silver in Object Graph, bronze in Prepare
4	FluentValidation	10/10	724	671	1394	silver in Rules, bronze in Basic

How the points were earned — every scenario, with the measurements behind it

Each row is one scenario. Best is the lowest result among the rated libraries that completed it, and the points follow from the two figures beside them: 100 × √((best + step) / (result + step)), with a step of 1 ns for time and 24 B for memory. A dash means the library did not complete the scenario, and it scores nothing for it. Add the two Points columns over every scenario and you get the rating above. The same breakdown appears as a hint on any points value in the application.

1. Microsoft.Extensions.Validation — 1540 of 2000

Scenario	Time	Best	Points	Memory	Best	Points
Valid Object	578.38 ns	210.18 ns	60.4	712 B	632 B	94.4
Single Failure	757.63 ns	757.63 ns	100	984 B	984 B	100
Multiple Failures	1.15 μs	1.15 μs	100	1.37 KB	1.37 KB	100
Nested Object	940.81 ns	940.81 ns	100	1.55 KB	1.55 KB	100
Collection	2.39 μs	2.08 μs	93.4	3.32 KB	2.77 KB	91.5
Conditional Rule	317.71 ns	317.71 ns	100	864 B	864 B	100
Custom Rule	501.08 ns	501.08 ns	100	896 B	896 B	100
Stop On First Failure	—	369.84 ns	0	—	576 B	0
Async Validation	—	3.45 μs	0	—	2.68 KB	0
Prepare Validator	0 ns	0 ns	100	0 B	0 B	100

2. DataAnnotations — 1476 of 2000

Scenario	Time	Best	Points	Memory	Best	Points
Valid Object	1.02 μs	210.18 ns	45.6	1.8 KB	632 B	59.2
Single Failure	1.2 μs	757.63 ns	79.6	1.88 KB	984 B	71.9
Multiple Failures	1.7 μs	1.15 μs	82	2.41 KB	1.37 KB	75.5
Nested Object	1.32 μs	940.81 ns	84.4	2.31 KB	1.55 KB	82
Collection	3 μs	2.08 μs	83.3	5.27 KB	2.77 KB	72.7
Conditional Rule	495.77 ns	317.71 ns	80.1	1.2 KB	864 B	84.4
Custom Rule	685.62 ns	501.08 ns	85.5	1.08 KB	896 B	90.3
Stop On First Failure	369.84 ns	369.84 ns	100	576 B	576 B	100
Async Validation	—	3.45 μs	0	—	2.68 KB	0
Prepare Validator	0 ns	0 ns	100	0 B	0 B	100

3. MiniValidation — 1444 of 2000

Scenario	Time	Best	Points	Memory	Best	Points
Valid Object	507.54 ns	210.18 ns	64.4	760 B	632 B	91.5
Single Failure	861.99 ns	757.63 ns	93.8	1.34 KB	984 B	85.1
Multiple Failures	1.46 μs	1.15 μs	88.7	2.16 KB	1.37 KB	79.7
Nested Object	1.13 μs	940.81 ns	91.2	1.86 KB	1.55 KB	91.3
Collection	2.08 μs	2.08 μs	100	2.77 KB	2.77 KB	100
Conditional Rule	337.48 ns	317.71 ns	97	1008 B	864 B	92.8
Custom Rule	667.54 ns	501.08 ns	86.7	1.31 KB	896 B	82
Stop On First Failure	—	369.84 ns	0	—	576 B	0
Async Validation	—	3.45 μs	0	—	2.68 KB	0
Prepare Validator	0 ns	0 ns	100	0 B	0 B	100

4. FluentValidation — 1394 of 2000

Scenario	Time	Best	Points	Memory	Best	Points
Valid Object	210.18 ns	210.18 ns	100	632 B	632 B	100
Single Failure	919.27 ns	757.63 ns	90.8	1.76 KB	984 B	74.3
Multiple Failures	3.09 μs	1.15 μs	60.9	6.02 KB	1.37 KB	48
Nested Object	1.24 μs	940.81 ns	87	2.38 KB	1.55 KB	80.8
Collection	3.65 μs	2.08 μs	75.6	6.57 KB	2.77 KB	65.1
Conditional Rule	831.83 ns	317.71 ns	61.9	1.77 KB	864 B	69.6
Custom Rule	832.8 ns	501.08 ns	77.6	1.85 KB	896 B	69.2
Stop On First Failure	798.45 ns	369.84 ns	68.1	1.76 KB	576 B	57.4
Async Validation	3.45 μs	3.45 μs	100	2.68 KB	2.68 KB	100
Prepare Validator	2.98 μs	0 ns	1.833	6.33 KB	0 B	6.075

Benchmark overview

Basic

More overview charts (3)

Object Graph

Rules

Prepare

Compared libraries (4)

	DataAnnotations The validation attributes and validation APIs included with the .NET framework.	Compare →
	FluentValidation 12.1.1 A strongly typed validation library with fluent rules, nested validators, cascade modes, and asynchronous validation.	Compare →
	Microsoft.Extensions.Validation 10.0.10 The official source-generated validation infrastructure for DataAnnotations-based object graph validation outside ASP.NET Core.	Compare →
	MiniValidation 0.10.0 A minimal DataAnnotations-based validator with recursive object graph traversal and cycle detection.	Compare →

Benchmark scenarios (10)

01 · Valid Object

Validates one object whose scalar properties satisfy every rule.

02 · Single Failure

Validates one object and returns its single property failure.

03 · Multiple Failures

Validates one object and materializes three independent property failures.

04 · Nested Object

Traverses a nested object and reports the complete failing property path.

05 · Collection

Traverses three collection elements and reports an indexed failure path.

06 · Conditional Rule

Applies a tax ID rule only when the input represents a business.

07 · Custom Rule

Applies a custom predicate that accepts only even integer codes.

08 · Stop On First Failure

Stops validation after the first failing rule in the declared order.

09 · Async Validation

Runs a deterministic asynchronous availability rule through the library async API.

10 · Prepare Validator

Creates the complete scalar validator or rule graph without validating an input.

ZIP Archives

SharpZipLib leads the current rating · 3 libraries · 13 scenarios

Explore interactively →

Rating

In every scenario the fastest library scores 100 points and the one allocating least scores 100 more; four times slower is half the points, and an unsupported scenario is worth nothing. Time and memory reach 1300 each here, so the maximum is 2600. See workflows/rating.md.

#	Library	Scenarios	Time	Memory	Points	Group wins
1	SharpZipLib	13/13	1123	1058	2182	gold in Advanced, gold in Metadata, silver in Read, silver in Write
2	System.IO.Compression	12/13	1169	968	2136	gold in Read, gold in Write, silver in Metadata, bronze in Advanced
3	SharpCompress	13/13	875	886	1761	silver in Advanced, bronze in Metadata, bronze in Read, bronze in Write

How the points were earned — every scenario, with the measurements behind it

Each row is one scenario. Best is the lowest result among the rated libraries that completed it, and the points follow from the two figures beside them: 100 × √((best + step) / (result + step)), with a step of 1 ns for time and 24 B for memory. A dash means the library did not complete the scenario, and it scores nothing for it. Add the two Points columns over every scenario and you get the rating above. The same breakdown appears as a hint on any points value in the application.

1. SharpZipLib — 2182 of 2600

Scenario	Time	Best	Points	Memory	Best	Points
List Entries	222.31 μs	192.6 μs	93.1	305.15 KB	305.15 KB	100
Find Entry By Name	232.44 μs	193.4 μs	91.2	305.23 KB	305.23 KB	100
Read Stored Entry	13.88 ms	13.88 ms	100	1.02 KB	1.02 KB	100
Decompress Entry	14.31 ms	14.05 ms	99.1	41.05 KB	5.38 KB	36.3
Extract Many Small Entries	16.71 ms	14.91 ms	94.5	35.98 MB	987.53 KB	16.4
Create Stored Archive	341.17 μs	215.54 μs	79.5	957.7 KB	645.86 KB	82.1
Create Deflate Fast Archive	2.16 ms	680.43 μs	56.1	622.91 KB	329.69 KB	72.8
Create Deflate Optimal Archive	2.57 ms	1.18 ms	67.8	621.27 KB	193.67 KB	55.8
Create Many Small Entries	6.81 ms	3.46 ms	71.3	13.99 MB	12.66 MB	95.1
Append Entry	211.8 μs	202.17 μs	97.7	398.18 KB	394.87 KB	99.6
Sequential Non-Seekable Read	16.06 ms	16.06 ms	100	458.67 KB	458.67 KB	100
Read Zip64 Archive	29.21 ms	29.21 ms	100	19.5 MB	19.5 MB	100
Read AES Encrypted Entry	2.95 ms	1.59 ms	73.3	43.93 KB	43.93 KB	100

2. System.IO.Compression — 2136 of 2600

Scenario	Time	Best	Points	Memory	Best	Points
List Entries	192.6 μs	192.6 μs	100	659.41 KB	305.15 KB	68
Find Entry By Name	193.4 μs	193.4 μs	100	659.37 KB	305.23 KB	68
Read Stored Entry	13.91 ms	13.88 ms	99.9	5.12 KB	1.02 KB	45
Decompress Entry	14.05 ms	14.05 ms	100	5.38 KB	5.38 KB	100
Extract Many Small Entries	14.91 ms	14.91 ms	100	987.53 KB	987.53 KB	100
Create Stored Archive	215.54 μs	215.54 μs	100	645.86 KB	645.86 KB	100
Create Deflate Fast Archive	680.43 μs	680.43 μs	100	329.69 KB	329.69 KB	100
Create Deflate Optimal Archive	1.18 ms	1.18 ms	100	193.67 KB	193.67 KB	100
Create Many Small Entries	3.46 ms	3.46 ms	100	12.66 MB	12.66 MB	100
Append Entry	202.17 μs	202.17 μs	100	394.87 KB	394.87 KB	100
Sequential Non-Seekable Read	18.15 ms	16.06 ms	94.1	16.84 MB	458.67 KB	16.3
Read Zip64 Archive	52.28 ms	29.21 ms	74.7	39.39 MB	19.5 MB	70.4
Read AES Encrypted Entry	—	1.59 ms	0	—	43.93 KB	0

3. SharpCompress — 1761 of 2600

Scenario	Time	Best	Points	Memory	Best	Points
List Entries	968.74 μs	192.6 μs	44.6	660.69 KB	305.15 KB	68
Find Entry By Name	845.95 μs	193.4 μs	47.8	660.55 KB	305.23 KB	68
Read Stored Entry	13.89 ms	13.88 ms	99.9	67.82 KB	1.02 KB	12.4
Decompress Entry	14.57 ms	14.05 ms	98.2	33.53 KB	5.38 KB	40.1
Extract Many Small Entries	17.12 ms	14.91 ms	93.3	2.27 MB	987.53 KB	65.2
Create Stored Archive	1.02 ms	215.54 μs	45.9	646.26 KB	645.86 KB	100
Create Deflate Fast Archive	2.89 ms	680.43 μs	48.6	345.04 KB	329.69 KB	97.8
Create Deflate Optimal Archive	3.4 ms	1.18 ms	58.9	344.59 KB	193.67 KB	75
Create Many Small Entries	20.79 ms	3.46 ms	40.8	12.69 MB	12.66 MB	99.9
Append Entry	1.06 ms	202.17 μs	43.8	721.42 KB	394.87 KB	74
Sequential Non-Seekable Read	17.52 ms	16.06 ms	95.8	2.28 MB	458.67 KB	44.3
Read Zip64 Archive	89.61 ms	29.21 ms	57.1	38.07 MB	19.5 MB	71.6
Read AES Encrypted Entry	1.59 ms	1.59 ms	100	89.79 KB	43.93 KB	70

Benchmark overview

Metadata

More overview charts (3)

Read

Write

Advanced

Compared libraries (3)

	SharpCompress 0.50.4 A fully managed archive library with random-access, forward-only, non-seekable, encrypted, and asynchronous ZIP APIs.	Compare →
	SharpZipLib 1.4.2 A mature managed compression library supporting ZIP, Zip64, stored and deflate entries, streaming, and AES encryption.	Compare →
	System.IO.Compression The ZIP implementation included with .NET, exposing ZipArchive, ZipArchiveEntry, and ZipFile APIs.	Compare →

Benchmark scenarios (13)

01 · List Entries

Opens a ZIP archive and enumerates 1,000 entry names and sizes.

02 · Find Entry By Name

Opens a 1,000-entry ZIP archive and locates its final entry by exact name.

03 · Read Stored Entry

Opens and reads one uncompressed 4 MiB ZIP entry.

04 · Decompress Entry

Opens and inflates one 4 MiB deflated ZIP entry.

05 · Extract Many Small Entries

Opens and reads all 1,000 small entries from a ZIP archive.

06 · Create Stored Archive

Creates a stored ZIP archive containing a deterministic mixed corpus.

07 · Create Deflate Fast Archive

Creates a Deflate level 1 ZIP archive containing the deterministic mixed corpus.

08 · Create Deflate Optimal Archive

Creates a Deflate level 6 ZIP archive containing the deterministic mixed corpus.

09 · Create Many Small Entries

Creates a stored ZIP archive containing 1,000 small files.

10 · Append Entry

Opens an existing ZIP archive for update and appends one stored entry.

11 · Sequential Non-Seekable Read

Reads all entries through a forward-only ZIP API from a non-seekable stream.

12 · Read Zip64 Archive

Opens and enumerates a Zip64 archive containing 65,536 entries.

13 · Read AES Encrypted Entry

Opens and decrypts one AES-256 encrypted ZIP entry.

Reproduce the results

Environment requirements

The complete workflow requires:

• a 64-bit operating system supported by the .NET 10 SDK;
• the .NET 10 SDK available as dotnet on PATH;
• access to the configured NuGet sources on the first run, or a populated local package cache;
• a writable repository checkout and several GB of free space for build, BenchmarkDotNet, report, and Web artifacts;
• at least 8 GB of RAM as a practical minimum.

For meaningful performance comparisons, run on an otherwise idle machine, connected to power, without a debugger, with a fixed performance-oriented power profile. Do not combine results produced by different frameworks, runtimes, operating systems, architectures, or processors without reviewing the recorded benchmark environment.

Run the complete reproducible workflow:

dotnet run --project .\build -- reproduce

The target validates and benchmarks every library, regenerates reports, charts, metadata, README, and Rider configurations, and starts the local Web application on an automatically selected available port. Use --no-browser to suppress automatic browser opening. Press Ctrl+C to stop the local application.

To use the reports already on disk and go directly to artifact generation and the local application:

dotnet run --project .\build -- reproduce --skip-benchmarks

Child-process output is saved under artifacts/logs; the console shows concise progress and prints the relevant log tail if an operation fails.

The Run .NET Matrix Reports GitHub Actions workflow produces one matrix-reports archive containing every category report, the raw BenchmarkDotNet evidence, summaries, a manifest, and SHA-256 checksums. Download that archive and import the complete verified snapshot manually with:

dotnet run --project .\build -- import-reports --archive .\matrix-reports.zip

Repository report JSON files and their evidence are updated under reports from the same archive. Evidence is committed with the report, so a Git tag preserves the measurements and their provenance together.

To regenerate source-controlled artifacts without starting the local application:

dotnet run --project .\build -- finalize-commit

Running the complete benchmark matrix can take a long time. Use dotnet run --project .\build -- --help to find commands for a single category or library.

Link to a category or a library

The application reads five optional query parameters, so a page about a library can link straight to the relevant comparison instead of the front page:

Link	Opens
https://matrix.dev-team.org/	the default category, newest reports
https://matrix.dev-team.org/?category=csv-processing	that category
https://matrix.dev-team.org/?library=CsvHelper	the library overview, in its own category
https://matrix.dev-team.org/?version=latest&library=CsvHelper	the same overview, newest release named explicitly
https://matrix.dev-team.org/?category=csv-processing&libraries=CsvHelper	that category, narrowed to one library
https://matrix.dev-team.org/?category=csv-processing&features=ReadSimpleRows	that category, narrowed to one scenario

The five are independent and combine freely; the links in the tables above are the same thing with the values filled in.

category

Accepts the category id or its displayed name, for example ?category=csv-processing. Matching ignores case, spaces and punctuation.

library

Accepts the library id, its displayed name or its NuGet package id, and finds the category on its own, so ?library=CsvHelper needs no category beside it. Add category only to break a tie between two categories that use the same library id. The library overview opens as a dialog over the matrix.

libraries

Narrows the comparison to the libraries you name, for example ?libraries=CsvHelper. Ids, displayed names and NuGet package ids all work, separated by commas and matched the same forgiving way as category. Start the list with - to name what to leave out instead, as in ?libraries=-CsvHelper, and use none for an empty comparison.

This one changes the numbers, which is why it is in the address at all: points are measured against the best result among the compared libraries, so a link that dropped the selection would show a different rating under the same names. Leave it out for the whole category — that is the default view, and the reason it carries no parameter. Ticking boxes in the application writes it for you, taking whichever list is shorter.

features

Narrows the comparison to the scenarios you name, for example ?features=ReadSimpleRows. Scenario ids and displayed names both work, separated by commas and matched the same forgiving way as category. Start the list with - to name what to leave out instead, and use none for an empty comparison — the same spelling as libraries.

It changes the numbers for the same reason libraries does: a score is the sum over the scenarios compared, so dropping the ones a project does not need reranks the libraries around the ones it does. The feature matrix, the benchmark charts, the overview groups and the rating all read the one selection, and a group left without scenarios disappears rather than being drawn empty. Leave the parameter out for every scenario of the category — that is the default view.

version

Pins the reports to one release. It takes a release name exactly as the picker shows it, for example ?version=1.2.0, or the word latest. Unlike the other two, the value is matched exactly: dropping punctuation would make 1.2.3 and 12.3 indistinguishable.

Leave it out to follow every new release — a link without it always shows the newest reports, which is what a page about a library normally wants. Use it when the link has to keep showing the numbers it was written against, for example next to a quoted result in an article.

The release picker in the application writes the parameter into the address, and the copy buttons follow the same rule: the release appears in the copied link only while an older one is being viewed.

An unknown value of any of them falls back to the default view rather than to an error, so a typo in a link published elsewhere still lands the reader in the matrix.