.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	1000	1000	2000	gold in Correctness, gold in Read, gold in Throughput, gold in Write
2	TinyCsvParser	9/10	560	392	953	silver in Correctness, silver in Read, bronze in Throughput
3	Sylvan.Data.Csv	9/10	620	270	890	silver in Throughput, silver in Write, bronze in Correctness, bronze in Read
4	CsvHelper	10/10	230	212	443	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 — 2000 of 2000

Scenario	Time	Best	Points	Memory	Best	Points
Read Simple Rows	716.67 ns	716.67 ns	100	1.89 KB	1.89 KB	100
Read Typed Records	863.7 ns	863.7 ns	100	1.7 KB	1.7 KB	100
Read Large Dataset	1.01 ms	1.01 ms	100	1016.97 KB	1016.97 KB	100
Quoted Fields	619.22 ns	619.22 ns	100	1.34 KB	1.34 KB	100
Escaped Delimiters	552.06 ns	552.06 ns	100	1.35 KB	1.35 KB	100
Header Mapping	917.9 ns	917.9 ns	100	1.7 KB	1.7 KB	100
Custom Conversion	416.39 ns	416.39 ns	100	1.11 KB	1.11 KB	100
Streaming Read	816.19 μs	816.19 μs	100	1.34 KB	1.34 KB	100
Write Rows	523.48 ns	523.48 ns	100	1.89 KB	1.89 KB	100
Async Read	822.52 μs	822.52 μs	100	1.44 KB	1.44 KB	100

2. TinyCsvParser — 953 of 2000

Scenario	Time	Best	Points	Memory	Best	Points
Read Simple Rows	1.6 μs	716.67 ns	66.9	5.56 KB	1.89 KB	58.5
Read Typed Records	1.84 μs	863.7 ns	68.6	5.3 KB	1.7 KB	56.8
Read Large Dataset	2.91 ms	1.01 ms	59	2.91 MB	1016.97 KB	58.5
Quoted Fields	1.31 μs	619.22 ns	68.7	4.87 KB	1.34 KB	52.9
Escaped Delimiters	1.38 μs	552.06 ns	63.2	4.98 KB	1.35 KB	52.4
Header Mapping	1.85 μs	917.9 ns	70.5	5.3 KB	1.7 KB	56.8
Custom Conversion	950.58 ns	416.39 ns	66.2	4.32 KB	1.11 KB	51.1
Streaming Read	3.14 ms	816.19 μs	51	2.75 MB	1.34 KB	2.196
Write Rows	—	523.48 ns	0	—	1.89 KB	0
Async Read	3.86 ms	822.52 μs	46.1	1.39 MB	1.44 KB	3.209

3. Sylvan.Data.Csv — 890 of 2000

Scenario	Time	Best	Points	Memory	Best	Points
Read Simple Rows	2.25 μs	716.67 ns	56.5	35.38 KB	1.89 KB	23.3
Read Typed Records	2.54 μs	863.7 ns	58.3	35.11 KB	1.7 KB	22.1
Read Large Dataset	1.14 ms	1.01 ms	94.3	1.03 MB	1016.97 KB	98.4
Quoted Fields	1.94 μs	619.22 ns	56.5	34.34 KB	1.34 KB	19.9
Escaped Delimiters	2.06 μs	552.06 ns	51.8	34.3 KB	1.35 KB	20
Header Mapping	2.97 μs	917.9 ns	55.6	35.11 KB	1.7 KB	22.1
Custom Conversion	—	416.39 ns	0	—	1.11 KB	0
Streaming Read	836.81 μs	816.19 μs	98.8	34.75 KB	1.34 KB	19.8
Write Rows	1.42 μs	523.48 ns	60.8	32.78 KB	1.89 KB	24.2
Async Read	1.07 ms	822.52 μs	87.8	36.05 KB	1.44 KB	20.1

4. CsvHelper — 443 of 2000

Scenario	Time	Best	Points	Memory	Best	Points
Read Simple Rows	3.34 μs	716.67 ns	46.4	21.95 KB	1.89 KB	29.5
Read Typed Records	804.37 μs	863.7 ns	3.279	53.6 KB	1.7 KB	17.9
Read Large Dataset	4.76 ms	1.01 ms	46.1	2.65 MB	1016.97 KB	61.3
Quoted Fields	541.78 μs	619.22 ns	3.383	40.84 KB	1.34 KB	18.3
Escaped Delimiters	583.06 μs	552.06 ns	3.08	40.93 KB	1.35 KB	18.3
Header Mapping	936.59 μs	917.9 ns	3.132	54.04 KB	1.7 KB	17.8
Custom Conversion	3.44 μs	416.39 ns	34.8	21.95 KB	1.11 KB	22.7
Streaming Read	4.2 ms	816.19 μs	44.1	2.16 MB	1.34 KB	2.48
Write Rows	800.23 μs	523.48 ns	2.56	40.5 KB	1.89 KB	21.7
Async Read	4.34 ms	822.52 μs	43.5	2.39 MB	1.44 KB	2.442

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.17.0 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	841	1206	2047	gold in Advanced, bronze in Prepare
3	Grace	13/15	800	1042	1842	silver in Basic
4	Stashbox	14/15	747	1092	1840	bronze in Advanced, bronze in Basic
5	Simple Injector	12/15	674	963	1637
6	LightInject	12/15	603	930	1533
7	Lamar	12/15	631	743	1374
8	Singularity	9/15	484	710	1194
9	Microsoft Extensions Dependency Injection	9/15	412	675	1087
10	Faster.Ioc	8/15	406	608	1014
11	Managed Extensibility Framework 2	10/15	317	455	772
12	Unity	13/15	260	444	704
13	Maestro	11/15	250	347	596
14	StructureMap	13/15	205	331	536
15	ZenIoc	7/15	150	284	434
16	Autofac	13/15	160	243	403
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	52	133	185
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.85 ns	14.85 ns	100	72 B	72 B	100
PerResolve	15.32 ns	15.32 ns	100	56 B	56 B	100
Scoped	48.2 ns	48.2 ns	100	184 B	160 B	94.1
Combined	37.93 ns	37.93 ns	100	168 B	168 B	100
Complex	90.1 ns	90.1 ns	100	360 B	360 B	100
Property	77.25 ns	77.25 ns	100	336 B	336 B	100
Generics	33.41 ns	33.41 ns	100	144 B	144 B	100
IEnumerable	18.65 ns	18.65 ns	100	72 B	72 B	100
Array	127.07 ns	127.07 ns	100	624 B	624 B	100
Conditional	33.65 ns	33.65 ns	100	144 B	144 B	100
Child Container	—	790.55 ns	0	—	1.59 KB	0
Interception With Proxy	75.36 ns	75.36 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	8.55 ns	8.55 ns	100	24 B	24 B	100

2. DryIoc — 2047 of 3000

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	33.95 ns	1.48 ns	26.6	0 B	0 B	100
Transient	96.32 ns	14.85 ns	40.4	72 B	72 B	100
PerResolve	371.33 μs	15.32 ns	0.663	1.65 KB	56 B	21.6
Scoped	177.32 ns	48.2 ns	52.5	448 B	160 B	62.4
Combined	71.58 ns	37.93 ns	73.2	168 B	168 B	100
Complex	117.43 ns	90.1 ns	87.7	360 B	360 B	100
Property	107.51 ns	77.25 ns	84.9	336 B	336 B	100
Generics	69.21 ns	33.41 ns	70	144 B	144 B	100
IEnumerable	99.14 ns	18.65 ns	44.3	72 B	72 B	100
Array	175.18 ns	127.07 ns	85.3	624 B	624 B	100
Conditional	66.48 ns	33.65 ns	71.7	144 B	144 B	100
Child Container	790.55 ns	790.55 ns	100	1.59 KB	1.59 KB	100
Interception With Proxy	85.95 ns	75.36 ns	93.7	248 B	248 B	100
Prepare And Register	1.42 μs	0 ns	2.653	2.42 KB	0 B	9.79
Prepare And Register And Simple Resolve	1.83 μs	8.55 ns	7.215	3.04 KB	24 B	12.4

3. Grace — 1842 of 3000

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	75.13 ns	1.48 ns	18	0 B	0 B	100
Transient	75.7 ns	14.85 ns	45.5	72 B	72 B	100
PerResolve	110.78 ns	15.32 ns	38.2	296 B	56 B	50
Scoped	117.79 ns	48.2 ns	64.4	232 B	160 B	84.8
Combined	51.12 ns	37.93 ns	86.4	168 B	168 B	100
Complex	109 ns	90.1 ns	91	360 B	360 B	100
Property	89.25 ns	77.25 ns	93.1	336 B	336 B	100
Generics	47.59 ns	33.41 ns	84.2	144 B	144 B	100
IEnumerable	—	18.65 ns	0	—	72 B	0
Array	148.58 ns	127.07 ns	92.5	624 B	624 B	100
Conditional	45.75 ns	33.65 ns	86.1	144 B	144 B	100
Child Container	—	790.55 ns	0	—	1.59 KB	0
Interception With Proxy	76.96 ns	75.36 ns	99	248 B	248 B	100
Prepare And Register	11.55 μs	0 ns	0.931	21.66 KB	0 B	3.288
Prepare And Register And Simple Resolve	212.66 μs	8.55 ns	0.67	32.77 KB	24 B	3.78

4. Stashbox — 1840 of 3000

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	110.18 ns	1.48 ns	14.9	0 B	0 B	100
Transient	95.23 ns	14.85 ns	40.6	72 B	72 B	100
PerResolve	67.69 ns	15.32 ns	48.7	192 B	56 B	60.9
Scoped	122.8 ns	48.2 ns	63	304 B	160 B	74.9
Combined	77.5 ns	37.93 ns	70.4	168 B	168 B	100
Complex	184.98 ns	90.1 ns	70	360 B	360 B	100
Property	99.92 ns	77.25 ns	88.1	336 B	336 B	100
Generics	54.67 ns	33.41 ns	78.6	144 B	144 B	100
IEnumerable	—	18.65 ns	0	—	72 B	0
Array	155.77 ns	127.07 ns	90.4	624 B	624 B	100
Conditional	57.38 ns	33.65 ns	77	144 B	144 B	100
Child Container	107.8 μs	790.55 ns	8.569	7.59 KB	1.59 KB	46
Interception With Proxy	83.67 ns	75.36 ns	95	248 B	248 B	100
Prepare And Register	5.06 μs	0 ns	1.405	8.77 KB	0 B	5.164
Prepare And Register And Simple Resolve	214.03 μs	8.55 ns	0.668	14.93 KB	24 B	5.599

5. Simple Injector — 1637 of 3000

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	33.61 ns	1.48 ns	26.8	0 B	0 B	100
Transient	48.15 ns	14.85 ns	56.8	72 B	72 B	100
PerResolve	—	15.32 ns	0	—	56 B	0
Scoped	252.16 ns	48.2 ns	44.1	504 B	160 B	59
Combined	66.04 ns	37.93 ns	76.2	168 B	168 B	100
Complex	115.49 ns	90.1 ns	88.4	360 B	360 B	100
Property	117.27 ns	77.25 ns	81.3	336 B	336 B	100
Generics	60 ns	33.41 ns	75.1	144 B	144 B	100
IEnumerable	56.89 ns	18.65 ns	58.3	72 B	72 B	100
Array	—	127.07 ns	0	—	624 B	0
Conditional	67.68 ns	33.65 ns	71	144 B	144 B	100
Child Container	—	790.55 ns	0	—	1.59 KB	0
Interception With Proxy	83.31 ns	75.36 ns	95.2	248 B	248 B	100
Prepare And Register	68.79 μs	0 ns	0.381	63.48 KB	0 B	1.921
Prepare And Register And Simple Resolve	307.2 μs	8.55 ns	0.557	105.42 KB	24 B	2.108

6. LightInject — 1533 of 3000

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	53.72 ns	1.48 ns	21.3	0 B	0 B	100
Transient	92.88 ns	14.85 ns	41.1	72 B	72 B	100
PerResolve	—	15.32 ns	0	—	56 B	0
Scoped	254.93 ns	48.2 ns	43.8	568 B	160 B	55.8
Combined	88.48 ns	37.93 ns	66	168 B	168 B	100
Complex	250.63 ns	90.1 ns	60.2	360 B	360 B	100
Property	95.5 ns	77.25 ns	90	336 B	336 B	100
Generics	51.61 ns	33.41 ns	80.9	144 B	144 B	100
IEnumerable	—	18.65 ns	0	—	72 B	0
Array	149.49 ns	127.07 ns	92.2	624 B	624 B	100
Conditional	211.73 ns	33.65 ns	40.4	144 B	144 B	100
Child Container	—	790.55 ns	0	—	1.59 KB	0
Interception With Proxy	176.99 ns	75.36 ns	65.5	560 B	248 B	68.2
Prepare And Register	12.65 μs	0 ns	0.889	33.07 KB	0 B	2.661
Prepare And Register And Simple Resolve	666.83 μs	8.55 ns	0.378	43.45 KB	24 B	3.284

7. Lamar — 1374 of 3000

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	44.07 ns	1.48 ns	23.5	120 B	0 B	40.8
Transient	64.93 ns	14.85 ns	49	192 B	72 B	66.7
PerResolve	—	15.32 ns	0	—	56 B	0
Scoped	1.5 μs	48.2 ns	18.1	1.08 KB	160 B	40.4
Combined	81.33 ns	37.93 ns	68.8	288 B	168 B	78.4
Complex	134.12 ns	90.1 ns	82.1	480 B	360 B	87.3
Property	120.49 ns	77.25 ns	80.3	456 B	336 B	86.6
Generics	77.91 ns	33.41 ns	66	264 B	144 B	76.4
IEnumerable	—	18.65 ns	0	—	72 B	0
Array	176.53 ns	127.07 ns	84.9	744 B	624 B	91.9
Conditional	78.12 ns	33.65 ns	66.2	264 B	144 B	76.4
Child Container	—	790.55 ns	0	—	1.59 KB	0
Interception With Proxy	91.18 ns	75.36 ns	91	288 B	248 B	93.4
Prepare And Register	156.04 μs	0 ns	0.253	62.91 KB	0 B	1.93
Prepare And Register And Simple Resolve	160.39 μs	8.55 ns	0.772	63.65 KB	24 B	2.713

8. Singularity — 1194 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.7 ns	14.85 ns	43.3	72 B	72 B	100
PerResolve	—	15.32 ns	0	—	56 B	0
Scoped	55.03 ns	48.2 ns	93.7	160 B	160 B	100
Combined	54.46 ns	37.93 ns	83.8	168 B	168 B	100
Complex	106.62 ns	90.1 ns	92	360 B	360 B	100
Property	—	77.25 ns	0	—	336 B	0
Generics	52.88 ns	33.41 ns	79.9	144 B	144 B	100
IEnumerable	—	18.65 ns	0	—	72 B	0
Array	250.65 ns	127.07 ns	71.3	624 B	624 B	100
Conditional	—	33.65 ns	0	—	144 B	0
Child Container	—	790.55 ns	0	—	1.59 KB	0
Interception With Proxy	—	75.36 ns	0	—	248 B	0
Prepare And Register	6.33 μs	0 ns	1.257	12.49 KB	0 B	4.327
Prepare And Register And Simple Resolve	64.52 μs	8.55 ns	1.216	15.67 KB	24 B	5.465

9. Microsoft Extensions Dependency Injection — 1087 of 3000

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	25.21 ns	1.48 ns	30.8	0 B	0 B	100
Transient	93.26 ns	14.85 ns	41	72 B	72 B	100
PerResolve	—	15.32 ns	0	—	56 B	0
Scoped	205.45 ns	48.2 ns	48.8	472 B	160 B	60.9
Combined	56.11 ns	37.93 ns	82.6	168 B	168 B	100
Complex	121.01 ns	90.1 ns	86.4	360 B	360 B	100
Property	—	77.25 ns	0	—	336 B	0
Generics	69.14 ns	33.41 ns	70	144 B	144 B	100
IEnumerable	—	18.65 ns	0	—	72 B	0
Array	—	127.07 ns	0	—	624 B	0
Conditional	181.17 ns	33.65 ns	43.6	144 B	144 B	100
Child Container	—	790.55 ns	0	—	1.59 KB	0
Interception With Proxy	—	75.36 ns	0	—	248 B	0
Prepare And Register	1.92 μs	0 ns	2.281	6.05 KB	0 B	6.21
Prepare And Register And Simple Resolve	2.27 μs	8.55 ns	6.477	6.8 KB	24 B	8.29

10. Faster.Ioc — 1014 of 3000

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	81.86 ns	1.48 ns	17.3	0 B	0 B	100
Transient	85.14 ns	14.85 ns	42.9	72 B	72 B	100
PerResolve	—	15.32 ns	0	—	56 B	0
Scoped	64.57 ns	48.2 ns	86.6	192 B	160 B	92.3
Combined	54.76 ns	37.93 ns	83.6	168 B	168 B	100
Complex	114.07 ns	90.1 ns	89	360 B	360 B	100
Property	—	77.25 ns	0	—	336 B	0
Generics	48.88 ns	33.41 ns	83.1	144 B	144 B	100
IEnumerable	—	18.65 ns	0	—	72 B	0
Array	—	127.07 ns	0	—	624 B	0
Conditional	—	33.65 ns	0	—	144 B	0
Child Container	—	790.55 ns	0	—	1.59 KB	0
Interception With Proxy	—	75.36 ns	0	—	248 B	0
Prepare And Register	1.28 μs	0 ns	2.797	4.36 KB	0 B	7.313
Prepare And Register And Simple Resolve	132.29 μs	8.55 ns	0.85	7.41 KB	24 B	7.939

11. Managed Extensibility Framework 2 — 772 of 3000

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	146.26 ns	1.48 ns	13	360 B	0 B	25
Transient	171.84 ns	14.85 ns	30.3	312 B	72 B	53.5
PerResolve	—	15.32 ns	0	—	56 B	0
Scoped	—	48.2 ns	0	—	160 B	0
Combined	190.77 ns	37.93 ns	45.1	528 B	168 B	59
Complex	380.34 ns	90.1 ns	48.9	1.05 KB	360 B	59
Property	529.84 ns	77.25 ns	38.4	1.15 KB	336 B	54.8
Generics	182.73 ns	33.41 ns	43.3	384 B	144 B	64.2
IEnumerable	—	18.65 ns	0	—	72 B	0
Array	429.62 ns	127.07 ns	54.5	1.27 KB	624 B	70.1
Conditional	189.26 ns	33.65 ns	42.7	384 B	144 B	64.2
Child Container	—	790.55 ns	0	—	1.59 KB	0
Interception With Proxy	—	75.36 ns	0	—	248 B	0
Prepare And Register	104.16 μs	0 ns	0.31	44.44 KB	0 B	2.296
Prepare And Register And Simple Resolve	260.84 μs	8.55 ns	0.605	56.7 KB	24 B	2.875

12. Unity — 704 of 3000

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	168.7 ns	1.48 ns	12.1	336 B	0 B	25.8
Transient	231.19 ns	14.85 ns	26.1	408 B	72 B	47.1
PerResolve	374.02 ns	15.32 ns	20.9	808 B	56 B	31
Scoped	2.13 μs	48.2 ns	15.2	4.57 KB	160 B	19.8
Combined	544.88 ns	37.93 ns	26.7	792 B	168 B	48.5
Complex	1.37 μs	90.1 ns	25.8	1.66 KB	360 B	47.1
Property	723.9 ns	77.25 ns	32.9	1.08 KB	336 B	56.5
Generics	2.33 μs	33.41 ns	12.2	1008 B	144 B	40.3
IEnumerable	—	18.65 ns	0	—	72 B	0
Array	2.42 μs	127.07 ns	23	9.59 KB	624 B	25.7
Conditional	417.99 ns	33.65 ns	28.8	624 B	144 B	50.9
Child Container	7.33 μs	790.55 ns	32.9	8.81 KB	1.59 KB	42.7
Interception With Proxy	—	75.36 ns	0	—	248 B	0
Prepare And Register	8.74 μs	0 ns	1.069	19.28 KB	0 B	3.484
Prepare And Register And Simple Resolve	14.02 μs	8.55 ns	2.609	21.89 KB	24 B	4.625

13. Maestro — 596 of 3000

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	244.96 ns	1.48 ns	10	720 B	0 B	18
Transient	259.7 ns	14.85 ns	24.7	648 B	72 B	37.8
PerResolve	—	15.32 ns	0	—	56 B	0
Scoped	908.46 ns	48.2 ns	23.3	1.63 KB	160 B	32.9
Combined	381.95 ns	37.93 ns	31.9	1.24 KB	168 B	38.5
Complex	1.04 μs	90.1 ns	29.6	2.79 KB	360 B	36.5
Property	785.38 ns	77.25 ns	31.5	1.8 KB	336 B	43.9
Generics	268.75 ns	33.41 ns	35.7	912 B	144 B	42.4
IEnumerable	—	18.65 ns	0	—	72 B	0
Array	—	127.07 ns	0	—	624 B	0
Conditional	431.66 ns	33.65 ns	28.3	1.01 KB	144 B	39.9
Child Container	—	790.55 ns	0	—	1.59 KB	0
Interception With Proxy	767.67 ns	75.36 ns	31.5	1.03 KB	248 B	50.2
Prepare And Register	18.05 μs	0 ns	0.744	27.62 KB	0 B	2.912
Prepare And Register And Simple Resolve	18.81 μs	8.55 ns	2.253	28.62 KB	24 B	4.046

14. StructureMap — 536 of 3000

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	793.01 ns	1.48 ns	5.588	2.58 KB	0 B	9.492
Transient	449.03 ns	14.85 ns	18.8	1.17 KB	72 B	28
PerResolve	—	15.32 ns	0	—	56 B	0
Scoped	6.4 μs	48.2 ns	8.766	9.67 KB	160 B	13.6
Combined	1.51 μs	37.93 ns	16	2.86 KB	168 B	25.5
Complex	3.61 μs	90.1 ns	15.9	4.64 KB	360 B	28.4
Property	1.39 μs	77.25 ns	23.7	1.64 KB	336 B	46
Generics	1.33 μs	33.41 ns	16.1	2.63 KB	144 B	24.9
IEnumerable	—	18.65 ns	0	—	72 B	0
Array	3.69 μs	127.07 ns	18.6	4.99 KB	624 B	35.5
Conditional	864.4 ns	33.65 ns	20	1.38 KB	144 B	34.2
Child Container	1.03 ms	790.55 ns	2.77	59.99 KB	1.59 KB	16.4
Interception With Proxy	226.11 ns	75.36 ns	58	624 B	248 B	64.8
Prepare And Register	79.6 μs	0 ns	0.354	61.88 KB	0 B	1.946
Prepare And Register And Simple Resolve	1.17 ms	8.55 ns	0.286	106.9 KB	24 B	2.094

15. ZenIoc — 434 of 3000

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	122.21 ns	1.48 ns	14.2	168 B	0 B	35.4
Transient	183.86 ns	14.85 ns	29.3	240 B	72 B	60.3
PerResolve	—	15.32 ns	0	—	56 B	0
Scoped	—	48.2 ns	0	—	160 B	0
Combined	308.27 ns	37.93 ns	35.5	504 B	168 B	60.3
Complex	762.38 ns	90.1 ns	34.5	1.17 KB	360 B	56
Property	—	77.25 ns	0	—	336 B	0
Generics	—	33.41 ns	0	—	144 B	0
IEnumerable	—	18.65 ns	0	—	72 B	0
Array	—	127.07 ns	0	—	624 B	0
Conditional	306.11 ns	33.65 ns	33.6	480 B	144 B	57.7
Child Container	—	790.55 ns	0	—	1.59 KB	0
Interception With Proxy	—	75.36 ns	0	—	248 B	0
Prepare And Register	3.67 μs	0 ns	1.651	4.48 KB	0 B	7.211
Prepare And Register And Simple Resolve	69.66 μs	8.55 ns	1.171	8.93 KB	24 B	7.235

16. Autofac — 403 of 3000

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	432.76 ns	1.48 ns	7.56	1.92 KB	0 B	11
Transient	851.78 ns	14.85 ns	13.6	2.44 KB	72 B	19.5
PerResolve	—	15.32 ns	0	—	56 B	0
Scoped	1.82 μs	48.2 ns	16.4	4.5 KB	160 B	19.9
Combined	2.16 μs	37.93 ns	13.4	4.48 KB	168 B	20.4
Complex	5.1 μs	90.1 ns	13.4	9.05 KB	360 B	20.3
Property	14.12 μs	77.25 ns	7.444	20.91 KB	336 B	13
Generics	1.83 μs	33.41 ns	13.7	3.91 KB	144 B	20.4
IEnumerable	—	18.65 ns	0	—	72 B	0
Array	6.63 μs	127.07 ns	13.9	8.6 KB	624 B	27.1
Conditional	1.56 μs	33.65 ns	14.9	3.16 KB	144 B	22.7
Child Container	11.56 μs	790.55 ns	26.2	16.03 KB	1.59 KB	31.7
Interception With Proxy	2.46 μs	75.36 ns	17.6	2.58 KB	248 B	32
Prepare And Register	51.04 μs	0 ns	0.443	48.75 KB	0 B	2.192
Prepare And Register And Simple Resolve	52.02 μs	8.55 ns	1.355	50.46 KB	24 B	3.047

17. Castle Windsor — 346 of 3000

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	347.41 ns	1.48 ns	8.435	984 B	0 B	15.4
Transient	1.03 μs	14.85 ns	12.4	2.34 KB	72 B	19.9
PerResolve	1.96 μs	15.32 ns	9.116	3.03 KB	56 B	16
Scoped	4.19 μs	48.2 ns	10.8	3.79 KB	160 B	21.7
Combined	3.64 μs	37.93 ns	10.3	5.34 KB	168 B	18.7
Complex	10.13 μs	90.1 ns	9.481	12.42 KB	360 B	17.4
Property	7.45 μs	77.25 ns	10.2	9.09 KB	336 B	19.6
Generics	6.93 μs	33.41 ns	7.047	5.84 KB	144 B	16.7
IEnumerable	—	18.65 ns	0	—	72 B	0
Array	8.51 μs	127.07 ns	12.3	12.94 KB	624 B	22.1
Conditional	3.09 μs	33.65 ns	10.6	4.8 KB	144 B	18.4
Child Container	—	790.55 ns	0	—	1.59 KB	0
Interception With Proxy	1.76 μs	75.36 ns	20.8	2.36 KB	248 B	33.4
Prepare And Register	148.31 μs	0 ns	0.26	75.83 KB	0 B	1.758
Prepare And Register And Simple Resolve	164.65 μs	8.55 ns	0.761	77.28 KB	24 B	2.462

18. MvvmCross — 323 of 3000

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	178.9 ns	1.48 ns	11.7	0 B	0 B	100
Transient	367.78 ns	14.85 ns	20.7	360 B	72 B	50
PerResolve	—	15.32 ns	0	—	56 B	0
Scoped	—	48.2 ns	0	—	160 B	0
Combined	1.33 μs	37.93 ns	17.1	1.24 KB	168 B	38.5
Complex	3.5 μs	90.1 ns	16.1	3.47 KB	360 B	32.8
Property	—	77.25 ns	0	—	336 B	0
Generics	—	33.41 ns	0	—	144 B	0
IEnumerable	—	18.65 ns	0	—	72 B	0
Array	—	127.07 ns	0	—	624 B	0
Conditional	—	33.65 ns	0	—	144 B	0
Child Container	—	790.55 ns	0	—	1.59 KB	0
Interception With Proxy	—	75.36 ns	0	—	248 B	0
Prepare And Register	868.71 ns	0 ns	3.391	2.35 KB	0 B	9.934
Prepare And Register And Simple Resolve	1.05 μs	8.55 ns	9.521	2.6 KB	24 B	13.4

19. Spring.NET — 322 of 3000

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	1.03 μs	1.48 ns	4.9	432 B	0 B	22.9
Transient	2.59 μs	14.85 ns	7.82	1.05 KB	72 B	29.5
PerResolve	—	15.32 ns	0	—	56 B	0
Scoped	—	48.2 ns	0	—	160 B	0
Combined	7.78 μs	37.93 ns	7.073	4.59 KB	168 B	20.2
Complex	18.28 μs	90.1 ns	7.059	13.9 KB	360 B	16.4
Property	76.22 μs	77.25 ns	3.204	363.72 KB	336 B	3.109
Generics	—	33.41 ns	0	—	144 B	0
IEnumerable	—	18.65 ns	0	—	72 B	0
Array	21.98 μs	127.07 ns	7.633	11.44 KB	624 B	23.5
Conditional	6.51 μs	33.65 ns	7.293	3.91 KB	144 B	20.4
Child Container	—	790.55 ns	0	—	1.59 KB	0
Interception With Proxy	308.06 ns	75.36 ns	49.7	392 B	248 B	80.9
Prepare And Register	5.49 μs	0 ns	1.35	16.23 KB	0 B	3.797
Prepare And Register And Simple Resolve	17.38 μs	8.55 ns	2.344	39.98 KB	24 B	3.423

20. Ninject — 185 of 3000

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	2.02 μs	1.48 ns	3.505	2.23 KB	0 B	10.2
Transient	6.37 μs	14.85 ns	4.988	4.8 KB	72 B	13.9
PerResolve	—	15.32 ns	0	—	56 B	0
Scoped	1.12 ms	48.2 ns	0.663	2 MB	160 B	0.937
Combined	17.09 μs	37.93 ns	4.773	13.17 KB	168 B	11.9
Complex	42.11 μs	90.1 ns	4.651	40.86 KB	360 B	9.577
Property	27.58 μs	77.25 ns	5.326	19.64 KB	336 B	13.4
Generics	17.79 μs	33.41 ns	4.398	10.59 KB	144 B	12.4
IEnumerable	—	18.65 ns	0	—	72 B	0
Array	47.99 μs	127.07 ns	5.166	28.59 KB	624 B	14.9
Conditional	13.7 μs	33.65 ns	5.029	10.03 KB	144 B	12.8
Child Container	—	790.55 ns	0	—	1.59 KB	0
Interception With Proxy	4.54 μs	75.36 ns	13	3.54 KB	248 B	27.3
Prepare And Register	248.87 μs	0 ns	0.2	33.74 KB	0 B	2.635
Prepare And Register And Simple Resolve	550.65 μs	8.55 ns	0.416	47.29 KB	24 B	3.148

21. Visual Studio MEF — 136 of 3000

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	4.7 μs	1.48 ns	2.296	5.79 KB	0 B	6.35
Transient	8.65 μs	14.85 ns	4.28	7.85 KB	72 B	10.9
PerResolve	—	15.32 ns	0	—	56 B	0
Scoped	—	48.2 ns	0	—	160 B	0
Combined	13.44 μs	37.93 ns	5.381	9.84 KB	168 B	13.8
Complex	22.47 μs	90.1 ns	6.368	13.92 KB	360 B	16.4
Property	20.56 μs	77.25 ns	6.169	12.09 KB	336 B	17
Generics	—	33.41 ns	0	—	144 B	0
IEnumerable	—	18.65 ns	0	—	72 B	0
Array	28.74 μs	127.07 ns	6.676	17.48 KB	624 B	19
Conditional	13.8 μs	33.65 ns	5.011	9.8 KB	144 B	12.9
Child Container	—	790.55 ns	0	—	1.59 KB	0
Interception With Proxy	—	75.36 ns	0	—	248 B	0
Prepare And Register	343.02 μs	0 ns	0.171	180.87 KB	0 B	1.138
Prepare And Register And Simple Resolve	357.5 μs	8.55 ns	0.517	181.29 KB	24 B	1.608

22. Catel — 132 of 3000

Scenario	Time	Best	Points	Memory	Best	Points
Singleton	221.47 ns	1.48 ns	10.6	304 B	0 B	27.1
Transient	3.89 μs	14.85 ns	6.384	5.62 KB	72 B	12.9
PerResolve	—	15.32 ns	0	—	56 B	0
Scoped	—	48.2 ns	0	—	160 B	0
Combined	7.95 μs	37.93 ns	6.996	12.22 KB	168 B	12.4
Complex	17.28 μs	90.1 ns	7.26	26.01 KB	360 B	12
Property	—	77.25 ns	0	—	336 B	0
Generics	—	33.41 ns	0	—	144 B	0
IEnumerable	—	18.65 ns	0	—	72 B	0
Array	—	127.07 ns	0	—	624 B	0
Conditional	5.07 μs	33.65 ns	8.263	7.01 KB	144 B	15.3
Child Container	2.08 ms	790.55 ns	1.953	2.27 MB	1.59 KB	2.629
Interception With Proxy	—	75.36 ns	0	—	248 B	0
Prepare And Register	3.46 μs	0 ns	1.699	6.8 KB	0 B	5.859
Prepare And Register And Simple Resolve	904.01 μs	8.55 ns	0.325	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.11 The lightweight Managed Extensibility Framework composition engine shipped as System.Composition.	Compare →
	Microsoft Extensions Dependency Injection 10.0.11 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.3 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	1261	1249	2510	gold in Advanced, gold in Basic, gold in Collections, gold in Nested, gold in Stream, silver in Prepare
2	ServiceStack.Text	12/14	1107	888	1995	gold in Prepare, silver in Advanced, silver in Basic, silver in Collections, silver in Nested, silver in Stream
3	Newtonsoft.Json	13/14	809	398	1207	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 — 2510 of 2800

Scenario	Time	Best	Points	Memory	Best	Points
Serialize Simple Object	195.96 ns	195.96 ns	100	96 B	96 B	100
Deserialize Simple Object	238.67 ns	185.51 ns	88.2	64 B	64 B	100
Serialize Nested Object	446.53 ns	446.53 ns	100	504 B	504 B	100
Deserialize Nested Object	604.94 ns	538.42 ns	94.4	768 B	320 B	65.9
Serialize Collection	559.45 ns	559.45 ns	100	560 B	560 B	100
Deserialize Collection	922.22 ns	787.08 ns	92.4	800 B	472 B	77.6
Serialize Dictionary	210.02 ns	209.22 ns	99.8	88 B	88 B	100
Deserialize Dictionary	345.76 ns	275.03 ns	89.2	312 B	312 B	100
Enum Round Trip	335.59 ns	326.64 ns	98.7	88 B	88 B	100
Custom Converter Round Trip	345 ns	326.71 ns	97.3	120 B	120 B	100
Polymorphic Round Trip	1.89 μs	1.89 μs	100	1.32 KB	1.32 KB	100
UTF-8 Stream Round Trip	586.46 ns	586.46 ns	100	280 B	280 B	100
Source Generation Round Trip	442.17 ns	442.17 ns	100	160 B	160 B	100
Prepare Serializer	20.14 μs	0 ns	0.705	7.45 KB	0 B	5.6

2. ServiceStack.Text — 1995 of 2800

Scenario	Time	Best	Points	Memory	Best	Points
Serialize Simple Object	284.29 ns	195.96 ns	83.1	336 B	96 B	57.7
Deserialize Simple Object	185.51 ns	185.51 ns	100	112 B	64 B	80.4
Serialize Nested Object	730.98 ns	446.53 ns	78.2	792 B	504 B	80.4
Deserialize Nested Object	538.42 ns	538.42 ns	100	320 B	320 B	100
Serialize Collection	1.01 μs	559.45 ns	74.6	1000 B	560 B	75.5
Deserialize Collection	787.08 ns	787.08 ns	100	472 B	472 B	100
Serialize Dictionary	209.22 ns	209.22 ns	100	288 B	88 B	59.9
Deserialize Dictionary	275.03 ns	275.03 ns	100	424 B	312 B	86.6
Enum Round Trip	326.64 ns	326.64 ns	100	336 B	88 B	55.8
Custom Converter Round Trip	326.71 ns	326.71 ns	100	392 B	120 B	58.8
Polymorphic Round Trip	—	1.89 μs	0	—	1.32 KB	0
UTF-8 Stream Round Trip	1.16 μs	586.46 ns	71.1	2.8 KB	280 B	32.4
Source Generation Round Trip	—	442.17 ns	0	—	160 B	0
Prepare Serializer	0 ns	0 ns	100	0 B	0 B	100

3. Newtonsoft.Json — 1207 of 2800

Scenario	Time	Best	Points	Memory	Best	Points
Serialize Simple Object	384.19 ns	195.96 ns	71.5	1.41 KB	96 B	28.6
Deserialize Simple Object	589.89 ns	185.51 ns	56.2	2.61 KB	64 B	18.1
Serialize Nested Object	673.55 ns	446.53 ns	81.5	1.63 KB	504 B	55.9
Deserialize Nested Object	1.15 μs	538.42 ns	68.5	2.89 KB	320 B	34
Serialize Collection	989.61 ns	559.45 ns	75.2	1.83 KB	560 B	55.5
Deserialize Collection	1.69 μs	787.08 ns	68.3	2.99 KB	472 B	40.1
Serialize Dictionary	387.18 ns	209.22 ns	73.6	1.48 KB	88 B	27
Deserialize Dictionary	679.68 ns	275.03 ns	63.7	2.83 KB	312 B	33.9
Enum Round Trip	997.83 ns	326.64 ns	57.3	4.68 KB	88 B	15.2
Custom Converter Round Trip	954.74 ns	326.71 ns	58.6	4.68 KB	120 B	17.3
Polymorphic Round Trip	3.88 μs	1.89 μs	69.8	7.79 KB	1.32 KB	41.5
UTF-8 Stream Round Trip	1.41 μs	586.46 ns	64.6	4.13 KB	280 B	26.8
Source Generation Round Trip	—	442.17 ns	0	—	160 B	0
Prepare Serializer	56.96 μs	0 ns	0.419	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.1.4 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	1579	1697	3276	gold in Advanced, gold in Core, gold in Partitioning, gold in Sequences, gold in Sources
2	System.Linq	16/18	1433	1373	2806	silver in Advanced, silver in Core, silver in Partitioning, silver in Sequences, bronze in Sources
3	StructLinq	15/18	1013	1329	2343	gold in Allocation-Free, bronze in Sequences
4	LinqAF	16/18	1077	1072	2148	silver in Allocation-Free, bronze in Advanced, bronze in Partitioning
5	NetFabric.Hyperlinq	12/18	924	900	1824	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 — 3276 of 3600

Scenario	Time	Best	Points	Memory	Best	Points
Filter and Count	9.8 μs	9.8 μs	100	0 B	0 B	100
Project To Array	4.5 μs	4.5 μs	100	39.09 KB	39.09 KB	100
Filter, Project, Materialize	8.02 μs	6.32 μs	88.8	9.83 KB	9.83 KB	100
Chained Pipeline	12.5 μs	8.64 μs	83.2	3.93 KB	3.93 KB	100
List Source	17.38 μs	11.87 μs	82.6	13.07 KB	13.07 KB	100
Opaque Source	31.15 μs	26.06 μs	91.5	13.1 KB	13.1 KB	100
Span Source	14.07 μs	14.07 μs	100	13.07 KB	13.07 KB	100
Paged Slice	272.07 ns	271.33 ns	99.9	3.93 KB	3.93 KB	100
Any Match	2.98 μs	2.98 μs	100	0 B	0 B	100
First Match	2.36 μs	2.36 μs	100	0 B	0 B	100
Flatten Nested Sequences	26.29 μs	6.52 μs	49.8	39.09 KB	39.09 KB	100
Distinct Values	39.97 μs	31.31 μs	88.5	3.98 KB	3.98 KB	100
Zip Pairs	13.64 μs	13.64 μs	100	39.09 KB	39.09 KB	100
Aggregate	3.41 μs	3.41 μs	100	0 B	0 B	100
Ordered Top N	43.74 μs	38.9 μs	94.3	264 B	248 B	97.2
Group and Aggregate	102.01 μs	102.01 μs	100	130.59 KB	130.59 KB	100
Join and Project	77.7 μs	77.7 μs	100	129.19 KB	129.19 KB	100
Struct Predicate Filter	—	9.49 μs	0	—	40 B	0

2. System.Linq — 2806 of 3600

Scenario	Time	Best	Points	Memory	Best	Points
Filter and Count	9.95 μs	9.8 μs	99.2	48 B	0 B	57.7
Project To Array	4.79 μs	4.5 μs	96.9	39.13 KB	39.09 KB	99.9
Filter, Project, Materialize	6.32 μs	6.32 μs	100	9.93 KB	9.83 KB	99.5
Chained Pipeline	15.01 μs	8.64 μs	75.9	4.14 KB	3.93 KB	97.4
List Source	11.87 μs	11.87 μs	100	13.22 KB	13.07 KB	99.4
Opaque Source	26.06 μs	26.06 μs	100	13.22 KB	13.1 KB	99.6
Span Source	—	14.07 μs	0	—	13.07 KB	0
Paged Slice	271.33 ns	271.33 ns	100	4.02 KB	3.93 KB	98.8
Any Match	3.01 μs	2.98 μs	99.6	0 B	0 B	100
First Match	2.43 μs	2.36 μs	98.4	0 B	0 B	100
Flatten Nested Sequences	6.52 μs	6.52 μs	100	39.18 KB	39.09 KB	99.9
Distinct Values	82.85 μs	31.31 μs	61.5	179.3 KB	3.98 KB	14.9
Zip Pairs	79.54 μs	13.64 μs	41.4	39.24 KB	39.09 KB	99.8
Aggregate	3.42 μs	3.41 μs	99.8	0 B	0 B	100
Ordered Top N	38.9 μs	38.9 μs	100	78.56 KB	248 B	5.814
Group and Aggregate	145.52 μs	102.01 μs	83.7	131.27 KB	130.59 KB	99.7
Join and Project	132.17 μs	77.7 μs	76.7	129.45 KB	129.19 KB	99.9
Struct Predicate Filter	—	9.49 μs	0	—	40 B	0

3. StructLinq — 2343 of 3600

Scenario	Time	Best	Points	Memory	Best	Points
Filter and Count	12.73 μs	9.8 μs	87.7	64 B	0 B	52.2
Project To Array	10.54 μs	4.5 μs	65.3	39.09 KB	39.09 KB	100
Filter, Project, Materialize	32.34 μs	6.32 μs	44.2	9.9 KB	9.83 KB	99.6
Chained Pipeline	12.13 μs	8.64 μs	84.4	4.06 KB	3.93 KB	98.4
List Source	21.71 μs	11.87 μs	74	13.14 KB	13.07 KB	99.7
Opaque Source	33.92 μs	26.06 μs	87.7	13.16 KB	13.1 KB	99.8
Span Source	—	14.07 μs	0	—	13.07 KB	0
Paged Slice	926.09 ns	271.33 ns	54.2	3.99 KB	3.93 KB	99.2
Any Match	8.45 μs	2.98 μs	59.4	32 B	0 B	65.5
First Match	4.74 μs	2.36 μs	70.5	32 B	0 B	65.5
Flatten Nested Sequences	64.1 μs	6.52 μs	31.9	54.77 KB	39.09 KB	84.5
Distinct Values	31.31 μs	31.31 μs	100	4.01 KB	3.98 KB	99.7
Zip Pairs	47.72 μs	13.64 μs	53.5	39.19 KB	39.09 KB	99.9
Aggregate	6.36 μs	3.41 μs	73.2	32 B	0 B	65.5
Ordered Top N	517.32 μs	38.9 μs	27.4	248 B	248 B	100
Group and Aggregate	—	102.01 μs	0	—	130.59 KB	0
Join and Project	—	77.7 μs	0	—	129.19 KB	0
Struct Predicate Filter	9.49 μs	9.49 μs	100	40 B	40 B	100

4. LinqAF — 2148 of 3600

Scenario	Time	Best	Points	Memory	Best	Points
Filter and Count	10.4 μs	9.8 μs	97	0 B	0 B	100
Project To Array	29.98 μs	4.5 μs	38.7	151.38 KB	39.09 KB	50.8
Filter, Project, Materialize	9.4 μs	6.32 μs	82	32.27 KB	9.83 KB	55.2
Chained Pipeline	8.64 μs	8.64 μs	100	3.93 KB	3.93 KB	100
List Source	26.23 μs	11.87 μs	67.3	45.31 KB	13.07 KB	53.7
Opaque Source	43.86 μs	26.06 μs	77.1	45.34 KB	13.1 KB	53.8
Span Source	—	14.07 μs	0	—	13.07 KB	0
Paged Slice	2.54 μs	271.33 ns	32.8	3.93 KB	3.93 KB	100
Any Match	2.99 μs	2.98 μs	99.9	0 B	0 B	100
First Match	2.47 μs	2.36 μs	97.7	0 B	0 B	100
Flatten Nested Sequences	88.9 μs	6.52 μs	27.1	151.38 KB	39.09 KB	50.8
Distinct Values	253.39 μs	31.31 μs	35.2	246.72 KB	3.98 KB	12.7
Zip Pairs	35.55 μs	13.64 μs	61.9	151.38 KB	39.09 KB	50.8
Aggregate	3.41 μs	3.41 μs	100	0 B	0 B	100
Ordered Top N	291.91 μs	38.9 μs	36.5	257.14 KB	248 B	3.214
Group and Aggregate	228.8 μs	102.01 μs	66.8	194.7 KB	130.59 KB	81.9
Join and Project	243.66 μs	77.7 μs	56.5	374.56 KB	129.19 KB	58.7
Struct Predicate Filter	—	9.49 μs	0	—	40 B	0

5. NetFabric.Hyperlinq — 1824 of 3600

Scenario	Time	Best	Points	Memory	Best	Points
Filter and Count	12.49 μs	9.8 μs	88.6	0 B	0 B	100
Project To Array	10.08 μs	4.5 μs	66.8	39.09 KB	39.09 KB	100
Filter, Project, Materialize	10.9 μs	6.32 μs	76.2	32.27 KB	9.83 KB	55.2
Chained Pipeline	11.1 μs	8.64 μs	88.2	8.3 KB	3.93 KB	68.9
List Source	18.25 μs	11.87 μs	80.7	29.48 KB	13.07 KB	66.6
Opaque Source	27.88 μs	26.06 μs	96.7	29.52 KB	13.1 KB	66.7
Span Source	14.37 μs	14.07 μs	98.9	29.48 KB	13.07 KB	66.6
Paged Slice	881.33 ns	271.33 ns	55.6	3.93 KB	3.93 KB	100
Any Match	5.93 μs	2.98 μs	70.9	0 B	0 B	100
First Match	2.89 μs	2.36 μs	90.4	0 B	0 B	100
Flatten Nested Sequences	37.96 μs	6.52 μs	41.5	103.7 KB	39.09 KB	61.4
Distinct Values	64.74 μs	31.31 μs	69.5	179.21 KB	3.98 KB	15
Zip Pairs	—	13.64 μs	0	—	39.09 KB	0
Aggregate	—	3.41 μs	0	—	0 B	0
Ordered Top N	—	38.9 μs	0	—	248 B	0
Group and Aggregate	—	102.01 μs	0	—	130.59 KB	0
Join and Project	—	77.7 μs	0	—	129.19 KB	0
Struct Predicate Filter	—	9.49 μ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	545	638	1184	gold in Structured
2	NLog	9/9	689	454	1143	gold in Core, silver in Structured, bronze in Prepare
3	Serilog	9/9	525	458	983	gold in Prepare, bronze in Core
4	log4net	9/9	423	410	833	silver in Prepare, bronze in Structured
5	OpenTelemetry	8/9	328	490	818	silver in Core
6	ZLogger	4/9	221	338	559

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 — 1184 of 1800

Scenario	Time	Best	Points	Memory	Best	Points
Disabled Log	10.28 ns	0 ns	29.8	0 B	0 B	100
Simple Message	18.9 ns	18.9 ns	100	0 B	0 B	100
Structured Properties	47.02 ns	47.02 ns	100	88 B	88 B	100
Exception	18.65 ns	18.65 ns	100	0 B	0 B	100
Scope Or Context	71.75 ns	71.75 ns	100	120 B	120 B	100
Template Rendering	35.27 ns	35.27 ns	100	0 B	0 B	100
Buffered Logging	—	93.36 ns	0	—	0 B	0
Create Logger	44.44 μs	1.08 μs	15.6	21.25 KB	3.07 KB	38.1
Formatted Output	—	222.72 ns	0	—	0 B	0

2. NLog — 1143 of 1800

Scenario	Time	Best	Points	Memory	Best	Points
Disabled Log	0 ns	0 ns	100	0 B	0 B	100
Simple Message	47.03 ns	18.9 ns	64.4	120 B	0 B	40.8
Structured Properties	127.99 ns	47.02 ns	61	248 B	88 B	64.2
Exception	46.82 ns	18.65 ns	64.1	120 B	0 B	40.8
Scope Or Context	92.22 ns	71.75 ns	88.3	248 B	120 B	72.8
Template Rendering	84.18 ns	35.27 ns	65.3	232 B	0 B	30.6
Buffered Logging	93.36 ns	93.36 ns	100	120 B	0 B	40.8
Create Logger	5.21 μs	1.08 μs	45.5	24.46 KB	3.07 KB	35.6
Formatted Output	222.72 ns	222.72 ns	100	272 B	0 B	28.5

3. Serilog — 983 of 1800

Scenario	Time	Best	Points	Memory	Best	Points
Disabled Log	1.26 ns	0 ns	66.6	0 B	0 B	100
Simple Message	90.82 ns	18.9 ns	46.6	160 B	0 B	36.1
Structured Properties	202.32 ns	47.02 ns	48.6	448 B	88 B	48.7
Exception	96.53 ns	18.65 ns	44.9	160 B	0 B	36.1
Scope Or Context	238.47 ns	71.75 ns	55.1	544 B	120 B	50.4
Template Rendering	213.07 ns	35.27 ns	41.2	432 B	0 B	22.9
Buffered Logging	395.4 ns	93.36 ns	48.8	160 B	0 B	36.1
Create Logger	1.08 μs	1.08 μs	100	3.07 KB	3.07 KB	100
Formatted Output	417.86 ns	222.72 ns	73.1	296 B	0 B	27.4

4. log4net — 833 of 1800

Scenario	Time	Best	Points	Memory	Best	Points
Disabled Log	8.55 ns	0 ns	32.4	0 B	0 B	100
Simple Message	119.71 ns	18.9 ns	40.6	168 B	0 B	35.4
Structured Properties	213.19 ns	47.02 ns	47.3	344 B	88 B	55.2
Exception	113.52 ns	18.65 ns	41.4	168 B	0 B	35.4
Scope Or Context	343.96 ns	71.75 ns	45.9	848 B	120 B	40.6
Template Rendering	135.52 ns	35.27 ns	51.5	280 B	0 B	28.1
Buffered Logging	516.38 ns	93.36 ns	42.7	848 B	0 B	16.6
Create Logger	14.52 μs	1.08 μs	27.2	6.79 KB	3.07 KB	67.4
Formatted Output	252.91 ns	222.72 ns	93.9	217 B	0 B	31.6

5. OpenTelemetry — 818 of 1800

Scenario	Time	Best	Points	Memory	Best	Points
Disabled Log	9.5 ns	0 ns	30.9	0 B	0 B	100
Simple Message	119.48 ns	18.9 ns	40.6	48 B	0 B	57.7
Structured Properties	260.49 ns	47.02 ns	42.9	216 B	88 B	68.3
Exception	121.6 ns	18.65 ns	40	48 B	0 B	57.7
Scope Or Context	185.52 ns	71.75 ns	62.5	168 B	120 B	86.6
Template Rendering	282 ns	35.27 ns	35.8	112 B	0 B	42
Buffered Logging	198.24 ns	93.36 ns	68.8	48 B	0 B	57.7
Create Logger	256.53 μs	1.08 μs	6.483	81.1 KB	3.07 KB	19.5
Formatted Output	—	222.72 ns	0	—	0 B	0

6. ZLogger — 559 of 1800

Scenario	Time	Best	Points	Memory	Best	Points
Disabled Log	4.02 ns	0 ns	44.7	0 B	0 B	100
Simple Message	—	18.9 ns	0	—	0 B	0
Structured Properties	—	47.02 ns	0	—	88 B	0
Exception	—	18.65 ns	0	—	0 B	0
Scope Or Context	—	71.75 ns	0	—	120 B	0
Template Rendering	—	35.27 ns	0	—	0 B	0
Buffered Logging	124.11 ns	93.36 ns	86.8	0 B	0 B	100
Create Logger	66.86 μs	1.08 μs	12.7	21.36 KB	3.07 KB	38
Formatted Output	381.63 ns	222.72 ns	76.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.11 The standard .NET logging abstraction and logger factory with providers, filtering, structured state, and scopes.	Compare →
	NLog 6.2.0 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	574	792	1366	silver in Advanced, silver in Basic, bronze in Prepare
3	AutoMapper	10/10	396	802	1198	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	9.48 ns	9.48 ns	100	56 B	56 B	100
Nested Object	45.43 ns	45.43 ns	100	248 B	248 B	100
Collection	1.02 μs	1.02 μs	100	6.27 KB	6.27 KB	100
Flattening	10.24 ns	10.24 ns	100	56 B	56 B	100
Map To Existing	3.79 ns	3.79 ns	100	0 B	0 B	100
Null Handling	9.11 ns	9.11 ns	100	40 B	40 B	100
Custom Conversion	75.61 ns	75.61 ns	100	88 B	88 B	100
Polymorphic Mapping	33.2 ns	33.2 ns	100	144 B	144 B	100
Prepare Configuration	0 ns	0 ns	100	0 B	0 B	100
Prepare And Simple Map	9.51 ns	9.51 ns	100	56 B	56 B	100

2. Mapster — 1366 of 2000

Scenario	Time	Best	Points	Memory	Best	Points
Simple Object	23.67 ns	9.48 ns	65.2	56 B	56 B	100
Nested Object	59.63 ns	45.43 ns	87.5	248 B	248 B	100
Collection	1.16 μs	1.02 μs	93.6	6.27 KB	6.27 KB	100
Flattening	19.9 ns	10.24 ns	73.3	56 B	56 B	100
Map To Existing	13.48 ns	3.79 ns	57.5	0 B	0 B	100
Null Handling	28.54 ns	9.11 ns	58.5	40 B	40 B	100
Custom Conversion	106.3 ns	75.61 ns	84.5	112 B	88 B	90.7
Polymorphic Mapping	116.43 ns	33.2 ns	54	144 B	144 B	100
Prepare Configuration	24.13 ms	0 ns	0.02	2.6 MB	0 B	0.297
Prepare And Simple Map	26.05 ms	9.51 ns	0.064	2.75 MB	56 B	0.526

3. AutoMapper — 1198 of 2000

Scenario	Time	Best	Points	Memory	Best	Points
Simple Object	80.35 ns	9.48 ns	35.9	56 B	56 B	100
Nested Object	113.71 ns	45.43 ns	63.6	248 B	248 B	100
Collection	1.18 μs	1.02 μs	92.9	6.27 KB	6.27 KB	100
Flattening	75.44 ns	10.24 ns	38.3	56 B	56 B	100
Map To Existing	65.35 ns	3.79 ns	26.9	0 B	0 B	100
Null Handling	76.66 ns	9.11 ns	36.1	40 B	40 B	100
Custom Conversion	155.95 ns	75.61 ns	69.9	88 B	88 B	100
Polymorphic Mapping	328.58 ns	33.2 ns	32.2	144 B	144 B	100
Prepare Configuration	13.1 ms	0 ns	0.028	624.18 KB	0 B	0.613
Prepare And Simple Map	13.72 ms	9.51 ns	0.088	657.03 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.12 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	750	786	1536	gold in Basic, silver in Object Graph, silver in Prepare, bronze in Rules
2	DataAnnotations	9/10	740	738	1478	gold in Prepare, gold in Rules, bronze in Object Graph
3	MiniValidation	8/10	747	724	1471	gold in Object Graph, silver in Basic, bronze in Prepare
4	FluentValidation	10/10	736	672	1408	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 — 1536 of 2000

Scenario	Time	Best	Points	Memory	Best	Points
Valid Object	594.52 ns	226.72 ns	61.8	712 B	632 B	94.4
Single Failure	738.42 ns	738.42 ns	100	984 B	984 B	100
Multiple Failures	1.1 μs	1.1 μs	100	1.37 KB	1.37 KB	100
Nested Object	897.44 ns	897.44 ns	100	1.55 KB	1.55 KB	100
Collection	2.34 μs	1.94 μs	91.1	3.32 KB	2.77 KB	91.5
Conditional Rule	301.71 ns	285.17 ns	97.2	864 B	864 B	100
Custom Rule	510.88 ns	510.88 ns	100	936 B	936 B	100
Stop On First Failure	—	358.16 ns	0	—	576 B	0
Async Validation	—	3.18 μs	0	—	2.68 KB	0
Prepare Validator	0 ns	0 ns	100	0 B	0 B	100

2. DataAnnotations — 1478 of 2000

Scenario	Time	Best	Points	Memory	Best	Points
Valid Object	1.02 μs	226.72 ns	47.2	1.8 KB	632 B	59.2
Single Failure	1.13 μs	738.42 ns	80.9	1.88 KB	984 B	71.9
Multiple Failures	1.67 μs	1.1 μs	81.1	2.41 KB	1.37 KB	75.5
Nested Object	1.34 μs	897.44 ns	81.7	2.31 KB	1.55 KB	82
Collection	2.97 μs	1.94 μs	81	5.27 KB	2.77 KB	72.7
Conditional Rule	447.33 ns	285.17 ns	79.9	1.2 KB	864 B	84.4
Custom Rule	656.43 ns	510.88 ns	88.2	1.08 KB	936 B	92.3
Stop On First Failure	358.16 ns	358.16 ns	100	576 B	576 B	100
Async Validation	—	3.18 μs	0	—	2.68 KB	0
Prepare Validator	0 ns	0 ns	100	0 B	0 B	100

3. MiniValidation — 1471 of 2000

Scenario	Time	Best	Points	Memory	Best	Points
Valid Object	441.91 ns	226.72 ns	71.7	760 B	632 B	91.5
Single Failure	787.55 ns	738.42 ns	96.8	1.34 KB	984 B	85.1
Multiple Failures	1.31 μs	1.1 μs	91.8	2.16 KB	1.37 KB	79.7
Nested Object	1.03 μs	897.44 ns	93.6	1.86 KB	1.55 KB	91.3
Collection	1.94 μs	1.94 μs	100	2.77 KB	2.77 KB	100
Conditional Rule	285.17 ns	285.17 ns	100	1008 B	864 B	92.8
Custom Rule	589.18 ns	510.88 ns	93.1	1.31 KB	936 B	83.8
Stop On First Failure	—	358.16 ns	0	—	576 B	0
Async Validation	—	3.18 μs	0	—	2.68 KB	0
Prepare Validator	0 ns	0 ns	100	0 B	0 B	100

4. FluentValidation — 1408 of 2000

Scenario	Time	Best	Points	Memory	Best	Points
Valid Object	226.72 ns	226.72 ns	100	632 B	632 B	100
Single Failure	863.53 ns	738.42 ns	92.5	1.76 KB	984 B	74.3
Multiple Failures	2.88 μs	1.1 μs	61.8	6.02 KB	1.37 KB	48
Nested Object	1.09 μs	897.44 ns	90.6	2.38 KB	1.55 KB	80.8
Collection	3.35 μs	1.94 μs	76.2	6.57 KB	2.77 KB	65.1
Conditional Rule	762.06 ns	285.17 ns	61.2	1.77 KB	864 B	69.6
Custom Rule	763.32 ns	510.88 ns	81.8	1.85 KB	936 B	70.7
Stop On First Failure	736.88 ns	358.16 ns	69.8	1.76 KB	576 B	57.4
Async Validation	3.18 μs	3.18 μs	100	2.68 KB	2.68 KB	100
Prepare Validator	2.76 μs	0 ns	1.904	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.11 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	1139	1058	2197	gold in Advanced, gold in Metadata, silver in Read, silver in Write
2	System.IO.Compression	12/13	1166	968	2134	gold in Read, gold in Write, silver in Metadata, bronze in Advanced
3	SharpCompress	13/13	876	886	1762	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 — 2197 of 2600

Scenario	Time	Best	Points	Memory	Best	Points
List Entries	226.54 μs	188.34 μs	91.2	305.15 KB	305.15 KB	100
Find Entry By Name	228.08 μs	188.29 μs	90.9	305.23 KB	305.23 KB	100
Read Stored Entry	13.75 ms	13.75 ms	100	1.02 KB	1.02 KB	100
Decompress Entry	14.3 ms	14.19 ms	99.6	41.05 KB	5.38 KB	36.3
Extract Many Small Entries	16.27 ms	15.09 ms	96.3	35.98 MB	987.53 KB	16.4
Create Stored Archive	348.21 μs	214.13 μs	78.4	957.7 KB	645.86 KB	82.1
Create Deflate Fast Archive	2.17 ms	681.56 μs	56.1	622.91 KB	329.69 KB	72.8
Create Deflate Optimal Archive	2.59 ms	1.22 ms	68.8	621.27 KB	193.67 KB	55.8
Create Many Small Entries	6.58 ms	4.65 ms	84	13.99 MB	12.66 MB	95.1
Append Entry	213.17 μs	201.47 μs	97.2	398.18 KB	394.87 KB	99.6
Sequential Non-Seekable Read	16.21 ms	16.21 ms	100	458.67 KB	458.67 KB	100
Read Zip64 Archive	27.95 ms	27.95 ms	100	19.5 MB	19.5 MB	100
Read AES Encrypted Entry	2.95 ms	1.73 ms	76.5	43.93 KB	43.93 KB	100

2. System.IO.Compression — 2134 of 2600

Scenario	Time	Best	Points	Memory	Best	Points
List Entries	188.34 μs	188.34 μs	100	659.41 KB	305.15 KB	68
Find Entry By Name	188.29 μs	188.29 μs	100	659.37 KB	305.23 KB	68
Read Stored Entry	13.86 ms	13.75 ms	99.6	5.12 KB	1.02 KB	45
Decompress Entry	14.19 ms	14.19 ms	100	5.38 KB	5.38 KB	100
Extract Many Small Entries	15.09 ms	15.09 ms	100	987.53 KB	987.53 KB	100
Create Stored Archive	214.13 μs	214.13 μs	100	645.86 KB	645.86 KB	100
Create Deflate Fast Archive	681.56 μs	681.56 μs	100	329.69 KB	329.69 KB	100
Create Deflate Optimal Archive	1.22 ms	1.22 ms	100	193.67 KB	193.67 KB	100
Create Many Small Entries	4.65 ms	4.65 ms	100	12.66 MB	12.66 MB	100
Append Entry	201.47 μs	201.47 μs	100	394.87 KB	394.87 KB	100
Sequential Non-Seekable Read	18.36 ms	16.21 ms	94	16.84 MB	458.67 KB	16.3
Read Zip64 Archive	53.32 ms	27.95 ms	72.4	39.39 MB	19.5 MB	70.4
Read AES Encrypted Entry	—	1.73 ms	0	—	43.93 KB	0

3. SharpCompress — 1762 of 2600

Scenario	Time	Best	Points	Memory	Best	Points
List Entries	866.55 μs	188.34 μs	46.6	660.69 KB	305.15 KB	68
Find Entry By Name	958.54 μs	188.29 μs	44.3	660.55 KB	305.23 KB	68
Read Stored Entry	13.78 ms	13.75 ms	99.9	67.82 KB	1.02 KB	12.4
Decompress Entry	14.83 ms	14.19 ms	97.8	33.56 KB	5.38 KB	40.1
Extract Many Small Entries	17.69 ms	15.09 ms	92.4	2.27 MB	987.53 KB	65.2
Create Stored Archive	1.04 ms	214.13 μs	45.4	646.26 KB	645.86 KB	100
Create Deflate Fast Archive	2.86 ms	681.56 μs	48.8	345.04 KB	329.69 KB	97.8
Create Deflate Optimal Archive	3.44 ms	1.22 ms	59.6	344.59 KB	193.67 KB	75
Create Many Small Entries	21.25 ms	4.65 ms	46.8	12.68 MB	12.66 MB	99.9
Append Entry	1.07 ms	201.47 μs	43.4	721.46 KB	394.87 KB	74
Sequential Non-Seekable Read	17.68 ms	16.21 ms	95.8	2.28 MB	458.67 KB	44.3
Read Zip64 Archive	91.64 ms	27.95 ms	55.2	38.07 MB	19.5 MB	71.6
Read AES Encrypted Entry	1.73 ms	1.73 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.