/ Benchmarking

Revisited: Is WCF faster than ASP.NET Core? Of course not! Or is it?

Previously, I wrote an article about how I got triggered after somebody on Reddit exclaimed that WCF was faster had lower response times than ASP.NET Web API and ASP.NET Core MVC.

The outcome was that, yes, with the default configuration, WCF does have lower response times. When you start tweaking with the serializers, both ASP.NET Web API and ASP.NET Core MVC come out on top.

The article kicked up a bit of a storm on Reddit, though, with people complaining that the comparison wasn’t fair, that I should have done this or that. Somebody even wrote an entire blog post about how it should be done. I wanted to address some of those comments.

Expectations

In my original article, I did not explain my intentions very well. It was not meant as a be-all-end-all determination of whether to use WCF or not. There are very valid reasons for using or not using WCF, besides the performance. I was simply trying to figure out whether WCF could have better per-request latency than the existing ASP.NET offerings.

Latency doesn’t mean better performance

Several people pointed out that performance isn’t just about latency. Specifically ASP.NET Core and Kestrel have been designed to be able to handle many requests concurrently, probably at the cost of some latency. I definitely agree with the statement, but my post was only about latency, because it is still an important metric in the performance of your service. It also happens to be one of the easier ones to measure.

You’re doing unnecessary in-place computations

Josh Bartley wrote an entire article in reply to mine. Thanks for taking the time to do that, Josh.

In the article, he mentions that I’m doing reflection in every call to construct the URI for the Web API/ASP.NET Core requests. He makes a fair point, along with some other ones, like how I was using delegates to switch between implementations. I’m not sure how much that specifically affects the numbers, but it sure is ugly. I rewrote all of the benchmarks to use a type hierarchy instead of big ugly switch statements, and I made sure to only use reflection once, during the initialization. Let’s see what has changed.

Method ItemCount Mean
LargeAspNetCoreMessagePackFuncs 100 9 017,7 μs
LargeAspNetCoreMessagePackHttpClientAsync 100 8 882,4 μs

There’s a very small improvement, but it’s not very impressive. I think it’s safe to say that reflecion and using delegates was not really an issue.

Asynchronous is killing the numbers

Redditor Langebein remarked the following:

You’re doing PostAsync in the WebApi tests, while doing synchronous calls with WCF. I'd wager a lot of the difference is made up from starting tasks and spinning up threads with the fancy HttpClient.

That’s an interesting point. With my new code structure in place, I could easily add other types of clients. First, let’s see what happens if we don’t await everything.

Method ItemCount Mean
LargeAspNetCoreMessagePackHttpClient 100 8 699,5 μs
LargeAspNetCoreMessagePackHttpClientAsync 100 8 882,4 μs

That’s a significant difference already. But Langebein was talking about HttpClient as a whole. So let’s see what happens when we use good ol’ HttpWebRequest.

Method ItemCount Mean
LargeWebApiMessagePackHttpClient 100 9 292,9 μs
LargeWebApiMessagePackHttpClientAsync 100 9 372,5 μs
LargeWebApiMessagePackHttpWebRequest 100 7 023,7 μs
LargeAspNetCoreMessagePackHttpClient 100 8 699,5 μs
LargeAspNetCoreMessagePackHttpClientAsync 100 8 882,4 μs
LargeAspNetCoreMessagePackHttpWebRequest 100 6 347,1 μs
LargeWcfText 100 10 306,5 μs

That’s a pretty big win. For all its fanciness, HttpClient is adding a lot of overhead, possibly related to its asynchronicity. For reference, I’ve added the fastest WCF result from the earlier post, and there is an undeniable advantage to ASP.NET Core and MessagePack. ASP.NET Web API does pretty well, too.

Since we’ve established that using HttpWebRequest offers the lowest latency, let’s establish a new baseline.

Method ItemCount Mean
LargeWcfText 100 10 306,5 μs
LargeWcfWebXml 100 10 125,9 μs
LargeWcfWebJson 100 12 535,9 μs
LargeWebApiJsonNetHttpWebRequest 100 14 204,2 μs
LargeWebApiMessagePackHttpWebRequest 100 7 023,7 μs
LargeWebApiXmlHttpWebRequest 100 12 461,1 μs
LargeWebApiUtf8JsonHttpWebRequest 100 11 023,6 μs
LargeAspNetCoreJsonNetHttpWebRequest 100 18 784,1 μs
LargeAspNetCoreMessagePackHttpWebRequest 100 6 347,1 μs
LargeAspNetCoreXmlHttpWebRequest 100 20 484,6 μs
LargeAspNetCoreUtf8JsonHttpWebRequest 100 9 944,2 μs

Now we can see MessagePack and Utf8Json (on ASP.NET Core MVC) easily overtaking WCF, and even XML on ASP.NET Core MVC is getting close.

What about binary serialization for WCF? And raw TCP?

Several people commented that I should have included more WCF options, such as binary serialization and the revered NetTcpBinding. Binary serialization was simply something I forgot about after a couple of years of not doing WCF.

NetTcpBinding is not something I think is fair to compare with. There is just an overhead to using HTTP that the ASP.NET Core and Web API tests cannot avoid. I decided to include it for argument’s sake.

Interestingly enough, the way I was invoking the WCF client meant I was creating a new client for each call. For the HTTP bindings, this was not an issue, because they’re handing off connection management to the HTTP library. NetTcpBinding has to do it by itself. The way I was doing it, I was never actually releasing clients, which meant sockets would stay open forever. I tried benchmarking it, but it never even got past the ‘pilot’ phase, where BenchmarkDotNet tries to determine the optimum number of invocations per run.

After I’d modified the code to create a client and immediately release it afterwards, things were a little better. A little better. Now I would actually reach the ‘main’ phase, but eventually, the process would either halt or throw an exception, because it was occupying sockets so quickly that they weren’t getting released in time.

Eventually I had to settle for using a single client instance for the lifetime of the benchmark. Unsurprisingly, the results are very good.

Method ItemCount Mean
LargeWcfText 100 10 306,5 μs
LargeWcfWebXml 100 10 125,9 μs
LargeWcfWebJson 100 12 535,9 μs
LargeWcfNetTcp 100 5 469,9 μs
LargeAspNetCoreMessagePackHttpWebRequest 100 6 347,1 μs

Binary serialization was a fair option, that I’d just forgotten to include. It was quickly included, and it is definitely the fastest out-of-box serialization option for WCF. Still, MessagePack on ASP.NET Core MVC has an ever so slightly lower response time.

Method ItemCount Mean
LargeWcfText 100 10 306,5 μs
LargeWcfWebXml 100 10 125,9 μs
LargeWcfWebJson 100 12 535,9 μs
LargeWcfBinary 100 6 889,3 μs
LargeWcfNetTcp 100 5 469,9 μs
LargeAspNetCoreMessagePackHttpWebRequest 100 6 347,1 μs

How about a comparison between Full Framework and .NET Core?

I very much wanted to include this, but I kept running into issues with BenchmarkDotNet, which either failed half-way, or didn’t report all of the metrics.

There’s no fair comparison between WCF and the others!

Redditor IAmVerySmarter (who, incidentally, also suggested using NetTcpBinding) complained that, because there was no benchmark between WCF and ASP.NET Core MVC or Web API using the MessagePack, it wasn’t fair to compare.

Unfortunately, the only package I could find to use MessagePack with WCF is MsgPack.Wcf, which uses MsgPack.Cli instead of MessagePack. According to the benchmarks, MsgPack.Cli takes a lot more time to serialize and deserialize than MessagePack. It’s still a fair comparison, so let’s see.

Method ItemCount Mean
LargeWcfText 100 10 306,5 μs
LargeWcfBinary 100 6 889,3 μs
LargeWcfMsgPackCli 100 22 791,3 μs
LargeAspNetCoreMessagePackHttpWebRequest 100 6 347,1 μs
LargeWebApiMsgPackCliHttpWebRequest 100 28 510,5 μs
LargeAspNetCoreMsgPackCliHttpWebRequest 100 26 311,1 μs

As you can see, MsgPack.Cli on either ASP.NET Core MVC or ASP.NET Web API takes several times longer than MessagePack. In fact, it takes longer than any other serializer tested. However, MsgPack.Cli on WCF takes a bit less time than on ASP.NET Core or ASP.NET Web API. This might indicate that the underlying infrastructure for WCF is the faster one.

Can you add [framework/serializer] to the comparison?

I could, yes. On the other hand, the source code is right there, so you could also fiddle around with it yourself.

ZeroFormatter

One serializer that I’ve seen mentioned several times is ZeroFormatter. This serializer claims to provide ‘infinitely fast deserialization’. That’s a bold claim, even from its creator, neuecc, who’s also responsible for the excellently performing MessagePack and Utf8Json libraries.

Method ItemCount Mean
LargeWebApiMessagePackHttpWebRequest 100 7 023,7 μs
LargeAspNetCoreMessagePackHttpWebRequest 100 6 347,1 μs
LargeWebApiZeroFormatterHttpWebRequest 100 7 998,7 μs
LargeAspNetCoreZeroFormatterHttpWebRequest 100 6 888,7 μs

It does pretty well, but it’s not quite as quick as MessagePack. Note that this test consists of serializing, then deserializing, followed by serializing some other stuff, and then finally deserializing that again. Deserializing might be ‘infinitely fast’, but serializing apparently is not.

Benchmark code

In response to the previous article, I got a lot of questions from people who wanted to see the code I used to benchmark. There was a link hidden somewhere in the article, so let me now make it clear:

Here is the benchmark code: GitHub

New results

The new results table is simply huge, because I’ve added a few serializers, and mostly because now every serializer/host combination based on ASP.NET is tested with HttpClient and HttpWebRequest. Making the sort of interactive graph from the previous post was a lot of work, and there’s too much uninteresting data, so I’ve decided to include a single graph of the following:

  • Mean round-trip times for a single call, sending 100 ‘large’ objects to the server, in response to which the server sends 100 objects back to the client.
  • For ASP.NET Web API and ASP.NET Core MVC, all of the benchmarks use HttpWebRequest.

The entire table of results is included here, but since it is so large, a CSV of the results is also available, for easier viewing.

Method ItemCount Mean P95 Gen 0 Gen 1 Gen 2 Allocated
SmallWcfText 0 336,5 μs 345,6 μs 8,7891 - - 28,17 KB
SmallWcfWebXml 0 371,0 μs 377,6 μs 10,2539 - - 31,66 KB
SmallWcfWebJson 0 380,2 μs 401,3 μs 10,2539 - - 33,07 KB
SmallWcfBinary 0 344,4 μs 351,6 μs 8,7891 - - 27,65 KB
SmallWcfNetTcp 0 108,7 μs 110,5 μs 1,4648 - - 4,62 KB
SmallWcfMsgPackCli 0 368,4 μs 375,4 μs 10,2539 - - 32,02 KB
SmallWebApiJsonNetHttpClient 0 864,3 μs 934,3 μs 26,3672 11,7188 - 85,28 KB
SmallWebApiJsonNetHttpClientAsync 0 906,8 μs 941,0 μs 25,3906 9,7656 - 85,1 KB
SmallWebApiJsonNetHttpWebRequest 0 361,6 μs 368,2 μs 19,0430 6,8359 - 69,87 KB
SmallWebApiMessagePackHttpClient 0 775,5 μs 884,3 μs 17,5781 5,8594 - 61,4 KB
SmallWebApiMessagePackHttpClientAsync 0 855,8 μs 900,9 μs 16,6016 5,8594 - 64,05 KB
SmallWebApiMessagePackHttpWebRequest 0 450,4 μs 476,3 μs 14,6484 5,3711 - 52,47 KB
SmallWebApiMsgPackCliHttpClient 0 1 079,8 μs 1 105,8 μs 83,9844 11,7188 - 264,17 KB
SmallWebApiMsgPackCliHttpClientAsync 0 1 119,8 μs 1 144,6 μs 85,9375 9,7656 - 267,14 KB
SmallWebApiMsgPackCliHttpWebRequest 0 543,8 μs 555,6 μs 60,0586 11,2305 - 186,32 KB
SmallWebApiXmlHttpClient 0 942,7 μs 957,5 μs 29,2969 11,7188 - 104,33 KB
SmallWebApiXmlHttpClientAsync 0 951,0 μs 958,3 μs 29,2969 11,7188 - 103,51 KB
SmallWebApiXmlHttpWebRequest 0 518,6 μs 525,3 μs 29,2969 13,1836 - 93,74 KB
SmallWebApiUtf8JsonHttpClient 0 831,9 μs 883,6 μs 16,6016 6,8359 - 60,96 KB
SmallWebApiUtf8JsonHttpClientAsync 0 815,5 μs 902,7 μs 18,5547 6,8359 - 64,02 KB
SmallWebApiUtf8JsonHttpWebRequest 0 463,1 μs 480,3 μs 14,1602 5,3711 - 52,3 KB
SmallWebApiZeroFormatterHttpClient 0 975,3 μs 1 033,9 μs 68,3594 7,8125 - 225,09 KB
SmallWebApiZeroFormatterHttpClientAsync 0 1 035,9 μs 1 070,8 μs 72,2656 7,8125 - 226,42 KB
SmallWebApiZeroFormatterHttpWebRequest 0 505,1 μs 523,0 μs 38,5742 10,2539 - 128,45 KB
SmallAspNetCoreJsonNetHttpClient 0 547,4 μs 618,6 μs 17,5781 - - 55,33 KB
SmallAspNetCoreJsonNetHttpClientAsync 0 779,5 μs 862,0 μs 17,5781 - - 55,4 KB
SmallAspNetCoreJsonNetHttpWebRequest 0 421,9 μs 443,5 μs 14,1602 - - 43,97 KB
SmallAspNetCoreMessagePackHttpClient 0 508,3 μs 547,3 μs 11,7188 - - 38,97 KB
SmallAspNetCoreMessagePackHttpClientAsync 0 520,3 μs 562,6 μs 13,6719 - - 42,88 KB
SmallAspNetCoreMessagePackHttpWebRequest 0 344,0 μs 358,0 μs 8,7891 - - 28,42 KB
SmallAspNetCoreMsgPackCliHttpClient 0 797,8 μs 887,2 μs 76,1719 1,9531 - 239,6 KB
SmallAspNetCoreMsgPackCliHttpClientAsync 0 863,8 μs 1 022,6 μs 78,1250 0,9766 - 244,78 KB
SmallAspNetCoreMsgPackCliHttpWebRequest 0 474,4 μs 484,4 μs 52,2461 0,4883 - 163,6 KB
SmallAspNetCoreXmlHttpClient 0 742,2 μs 853,3 μs 29,2969 - - 90,66 KB
SmallAspNetCoreXmlHttpClientAsync 0 813,4 μs 927,5 μs 29,2969 - - 90,54 KB
SmallAspNetCoreXmlHttpWebRequest 0 460,9 μs 465,6 μs 26,3672 - - 82,56 KB
SmallAspNetCoreUtf8JsonHttpClient 0 552,5 μs 638,9 μs 11,7188 - - 36,19 KB
SmallAspNetCoreUtf8JsonHttpClientAsync 0 606,8 μs 719,9 μs 12,6953 - - 39,32 KB
SmallAspNetCoreUtf8JsonHttpWebRequest 0 431,3 μs 443,7 μs 7,3242 - - 23,53 KB
SmallAspNetCoreZeroFormatterHttpClient 0 552,2 μs 579,3 μs 38,0859 - - 121,4 KB
SmallAspNetCoreZeroFormatterHttpClientAsync 0 550,5 μs 592,1 μs 38,0859 - - 121,29 KB
SmallAspNetCoreZeroFormatterHttpWebRequest 0 397,5 μs 408,5 μs 8,7891 - - 27,08 KB
LargeWcfText 0 337,7 μs 345,0 μs 8,7891 - - 28,08 KB
LargeWcfWebXml 0 365,2 μs 374,5 μs 10,2539 - - 31,65 KB
LargeWcfWebJson 0 376,6 μs 384,3 μs 10,7422 - - 33,03 KB
LargeWcfBinary 0 352,9 μs 360,6 μs 8,7891 - - 27,68 KB
LargeWcfNetTcp 0 109,9 μs 111,9 μs 1,4648 - - 4,63 KB
LargeWcfMsgPackCli 0 374,4 μs 384,5 μs 10,2539 - - 32,02 KB
LargeWebApiJsonNetHttpClient 0 880,4 μs 919,6 μs 25,3906 11,7188 - 85,29 KB
LargeWebApiJsonNetHttpClientAsync 0 915,1 μs 939,4 μs 25,3906 9,7656 - 85,33 KB
LargeWebApiJsonNetHttpWebRequest 0 469,3 μs 492,4 μs 19,0430 6,3477 - 70,05 KB
LargeWebApiMessagePackHttpClient 0 815,6 μs 902,9 μs 16,6016 5,8594 - 61,22 KB
LargeWebApiMessagePackHttpClientAsync 0 855,1 μs 907,5 μs 18,5547 6,8359 - 64,4 KB
LargeWebApiMessagePackHttpWebRequest 0 446,9 μs 464,0 μs 14,1602 5,3711 - 52,24 KB
LargeWebApiMsgPackCliHttpClient 0 1 121,9 μs 1 156,2 μs 83,9844 9,7656 - 264,61 KB
LargeWebApiMsgPackCliHttpClientAsync 0 1 128,2 μs 1 163,0 μs 85,9375 9,7656 - 267,55 KB
LargeWebApiMsgPackCliHttpWebRequest 0 589,9 μs 604,7 μs 60,0586 11,2305 - 186,38 KB
LargeWebApiXmlHttpClient 0 1 007,8 μs 1 041,8 μs 29,2969 9,7656 - 109,99 KB
LargeWebApiXmlHttpClientAsync 0 992,7 μs 1 032,8 μs 29,2969 9,7656 - 109,03 KB
LargeWebApiXmlHttpWebRequest 0 445,5 μs 455,5 μs 30,2734 13,6719 - 97,01 KB
LargeWebApiUtf8JsonHttpClientAsync 0 862,8 μs 909,7 μs 18,5547 6,8359 - 63,89 KB
LargeWebApiUtf8JsonHttpWebRequest 0 345,4 μs 372,6 μs 12,2070 3,4180 - 46,63 KB
LargeWebApiZeroFormatterHttpClient 0 1 035,9 μs 1 074,2 μs 72,2656 7,8125 - 225,52 KB
LargeWebApiZeroFormatterHttpClientAsync 0 1 061,0 μs 1 093,3 μs 72,2656 7,8125 - 226,44 KB
LargeWebApiZeroFormatterHttpWebRequest 0 471,1 μs 498,4 μs 38,0859 10,7422 - 128,25 KB
LargeAspNetCoreJsonNetHttpClient 0 635,3 μs 728,3 μs 17,5781 - - 54,47 KB
LargeAspNetCoreJsonNetHttpClientAsync 0 729,3 μs 861,8 μs 17,5781 - - 55,96 KB
LargeAspNetCoreJsonNetHttpWebRequest 0 429,4 μs 445,8 μs 14,1602 - - 43,87 KB
LargeAspNetCoreMessagePackHttpClient 0 515,0 μs 560,5 μs 12,6953 - - 39,26 KB
LargeAspNetCoreMessagePackHttpClientAsync 0 521,9 μs 556,4 μs 13,6719 - - 42,85 KB
LargeAspNetCoreMessagePackHttpWebRequest 0 388,0 μs 400,9 μs 8,7891 - - 28,29 KB
LargeAspNetCoreMsgPackCliHttpClient 0 831,8 μs 934,1 μs 77,1484 4,8828 - 241,45 KB
LargeAspNetCoreMsgPackCliHttpClientAsync 0 956,7 μs 1 032,6 μs 78,1250 1,9531 - 245,13 KB
LargeAspNetCoreMsgPackCliHttpWebRequest 0 501,2 μs 541,4 μs 51,7578 - - 163,45 KB
LargeAspNetCoreXmlHttpClient 0 749,9 μs 865,8 μs 30,2734 - - 95,37 KB
LargeAspNetCoreXmlHttpClientAsync 0 935,4 μs 970,6 μs 30,2734 - - 94,09 KB
LargeAspNetCoreXmlHttpWebRequest 0 509,8 μs 527,5 μs 27,3438 - - 86,38 KB
LargeAspNetCoreUtf8JsonHttpClient 0 562,7 μs 650,9 μs 11,7188 - - 36,19 KB
LargeAspNetCoreUtf8JsonHttpClientAsync 0 684,5 μs 770,1 μs 12,6953 - - 39,13 KB
LargeAspNetCoreUtf8JsonHttpWebRequest 0 412,5 μs 419,6 μs 7,3242 - - 23,54 KB
LargeAspNetCoreZeroFormatterHttpClient 0 571,5 μs 615,6 μs 38,0859 - - 121,21 KB
LargeAspNetCoreZeroFormatterHttpClientAsync 0 584,2 μs 637,0 μs 38,0859 - - 120,87 KB
LargeAspNetCoreZeroFormatterHttpWebRequest 0 359,7 μs 389,0 μs 8,7891 - - 27,12 KB
SmallWcfText 10 405,3 μs 413,9 μs 10,7422 - - 33,33 KB
SmallWcfWebXml 10 415,1 μs 423,3 μs 11,7188 - - 36,86 KB
SmallWcfWebJson 10 557,9 μs 609,4 μs 11,7188 - - 38,75 KB
SmallWcfBinary 10 400,8 μs 408,5 μs 10,2539 - - 32,46 KB
SmallWcfNetTcp 10 157,5 μs 161,4 μs 3,1738 - - 9,92 KB
SmallWcfMsgPackCli 10 952,3 μs 1 043,0 μs 150,3906 7,8125 - 472,75 KB
SmallWebApiJsonNetHttpClient 10 1 020,6 μs 1 074,3 μs 27,3438 7,8125 - 98,38 KB
SmallWebApiJsonNetHttpClientAsync 10 1 000,9 μs 1 045,6 μs 27,3438 9,7656 - 98,99 KB
SmallWebApiJsonNetHttpWebRequest 10 427,8 μs 435,6 μs 25,8789 11,2305 - 82,71 KB
SmallWebApiMessagePackHttpClient 10 908,3 μs 940,8 μs 19,5313 6,8359 - 67,41 KB
SmallWebApiMessagePackHttpClientAsync 10 917,1 μs 941,3 μs 21,4844 7,8125 - 70,4 KB
SmallWebApiMessagePackHttpWebRequest 10 499,2 μs 513,9 μs 16,1133 5,8594 - 58,45 KB
SmallWebApiMsgPackCliHttpClient 10 1 235,5 μs 1 265,0 μs 93,7500 11,7188 - 294,39 KB
SmallWebApiMsgPackCliHttpClientAsync 10 1 216,5 μs 1 234,6 μs 93,7500 11,7188 - 294,71 KB
SmallWebApiMsgPackCliHttpWebRequest 10 573,8 μs 603,8 μs 57,6172 10,7422 - 199,3 KB
SmallWebApiXmlHttpClient 10 1 065,3 μs 1 107,6 μs 35,1563 5,8594 - 123,97 KB
SmallWebApiXmlHttpClientAsync 10 1 048,5 μs 1 087,9 μs 37,1094 9,7656 - 125,52 KB
SmallWebApiXmlHttpWebRequest 10 526,8 μs 559,1 μs 30,2734 10,7422 - 107,18 KB
SmallWebApiUtf8JsonHttpClient 10 956,0 μs 1 007,4 μs 17,5781 3,9063 - 67,12 KB
SmallWebApiUtf8JsonHttpClientAsync 10 990,9 μs 1 026,6 μs 17,5781 5,8594 - 70,05 KB
SmallWebApiUtf8JsonHttpWebRequest 10 493,1 μs 513,4 μs 16,1133 6,8359 - 58,25 KB
SmallWebApiZeroFormatterHttpClient 10 1 078,4 μs 1 126,8 μs 72,2656 5,8594 - 240,91 KB
SmallWebApiZeroFormatterHttpClientAsync 10 1 090,9 μs 1 134,9 μs 74,2188 9,7656 - 236,5 KB
SmallWebApiZeroFormatterHttpWebRequest 10 582,3 μs 601,0 μs 43,9453 12,6953 - 140,3 KB
SmallAspNetCoreJsonNetHttpClient 10 880,8 μs 945,4 μs 21,4844 - - 68 KB
SmallAspNetCoreJsonNetHttpClientAsync 10 911,8 μs 952,9 μs 22,4609 - - 69,49 KB
SmallAspNetCoreJsonNetHttpWebRequest 10 475,1 μs 490,0 μs 18,0664 - - 55,92 KB
SmallAspNetCoreMessagePackHttpClient 10 630,9 μs 709,1 μs 13,6719 - - 44,07 KB
SmallAspNetCoreMessagePackHttpClientAsync 10 637,5 μs 758,3 μs 14,6484 - - 46,57 KB
SmallAspNetCoreMessagePackHttpWebRequest 10 390,9 μs 417,5 μs 10,2539 - - 32,97 KB
SmallAspNetCoreMsgPackCliHttpClient 10 1 151,0 μs 1 183,6 μs 85,9375 - - 266,94 KB
SmallAspNetCoreMsgPackCliHttpClientAsync 10 1 151,1 μs 1 189,9 μs 85,9375 1,9531 - 268,67 KB
SmallAspNetCoreMsgPackCliHttpWebRequest 10 563,8 μs 581,4 μs 58,1055 0,4883 - 182,12 KB
SmallAspNetCoreXmlHttpClient 10 1 034,2 μs 1 073,7 μs 35,1563 - - 110,05 KB
SmallAspNetCoreXmlHttpClientAsync 10 1 057,3 μs 1 085,7 μs 33,2031 - - 107,46 KB
SmallAspNetCoreXmlHttpWebRequest 10 581,2 μs 609,5 μs 31,2500 - - 97,05 KB
SmallAspNetCoreUtf8JsonHttpClient 10 770,1 μs 850,2 μs 12,6953 - - 41,85 KB
SmallAspNetCoreUtf8JsonHttpClientAsync 10 813,2 μs 898,3 μs 13,6719 - - 43,68 KB
SmallAspNetCoreUtf8JsonHttpWebRequest 10 496,5 μs 512,9 μs 8,7891 - - 28,22 KB
SmallAspNetCoreZeroFormatterHttpClient 10 681,4 μs 769,1 μs 43,9453 - - 136,96 KB
SmallAspNetCoreZeroFormatterHttpClientAsync 10 738,7 μs 897,4 μs 41,9922 - - 132,09 KB
SmallAspNetCoreZeroFormatterHttpWebRequest 10 375,9 μs 394,6 μs 11,7188 - - 37,27 KB
LargeWcfText 10 1 416,8 μs 1 485,2 μs 35,1563 7,8125 - 123,75 KB
LargeWcfWebXml 10 1 465,3 μs 1 532,9 μs 35,1563 7,8125 - 127,42 KB
LargeWcfWebJson 10 1 704,8 μs 1 789,9 μs 42,9688 9,7656 - 143,51 KB
LargeWcfBinary 10 948,7 μs 1 024,2 μs 35,1563 7,8125 - 112,34 KB
LargeWcfNetTcp 10 745,7 μs 775,9 μs 29,2969 - - 90,79 KB
LargeWcfMsgPackCli 10 2 952,6 μs 3 020,3 μs 316,4063 78,1250 - 1 047,96 KB
LargeWebApiJsonNetHttpClient 10 2 357,2 μs 2 422,9 μs 105,4688 15,6250 - 352,19 KB
LargeWebApiJsonNetHttpClientAsync 10 2 250,2 μs 2 350,5 μs 105,4688 19,5313 - 352,43 KB
LargeWebApiJsonNetHttpWebRequest 10 1 906,3 μs 1 922,9 μs 87,8906 11,7188 - 300,53 KB
LargeWebApiMessagePackHttpClient 10 1 900,1 μs 1 928,1 μs 74,2188 11,7188 - 256,83 KB
LargeWebApiMessagePackHttpClientAsync 10 1 899,3 μs 1 918,7 μs 76,1719 13,6719 - 257,94 KB
LargeWebApiMessagePackHttpWebRequest 10 1 033,2 μs 1 156,7 μs 64,4531 11,7188 - 228,96 KB
LargeWebApiMsgPackCliHttpClient 10 3 950,6 μs 4 195,4 μs 343,7500 101,5625 - 1 107,1 KB
LargeWebApiMsgPackCliHttpClientAsync 10 4 116,9 μs 4 250,3 μs 351,5625 101,5625 - 1 109,45 KB
LargeWebApiMsgPackCliHttpWebRequest 10 3 015,2 μs 3 107,9 μs 261,7188 42,9688 - 850,72 KB
LargeWebApiXmlHttpClient 10 2 493,4 μs 2 552,4 μs 132,8125 19,5313 - 421,41 KB
LargeWebApiXmlHttpClientAsync 10 2 480,1 μs 2 564,5 μs 117,1875 23,4375 - 419,88 KB
LargeWebApiXmlHttpWebRequest 10 1 800,1 μs 1 889,4 μs 101,5625 15,6250 - 352,29 KB
LargeWebApiUtf8JsonHttpClientAsync 10 2 038,8 μs 2 092,5 μs 78,1250 15,6250 - 274,06 KB
LargeWebApiUtf8JsonHttpWebRequest 10 1 255,3 μs 1 291,0 μs 68,3594 11,7188 - 235,99 KB
LargeWebApiZeroFormatterHttpClient 10 2 240,9 μs 2 296,1 μs 179,6875 23,4375 - 556,4 KB
LargeWebApiZeroFormatterHttpClientAsync 10 2 231,9 μs 2 296,6 μs 167,9688 31,2500 - 551,97 KB
LargeWebApiZeroFormatterHttpWebRequest 10 1 086,4 μs 1 153,7 μs 140,6250 19,5313 - 453,42 KB
LargeAspNetCoreJsonNetHttpClient 10 2 379,7 μs 2 444,7 μs 101,5625 - - 319,88 KB
LargeAspNetCoreJsonNetHttpClientAsync 10 2 276,5 μs 2 367,5 μs 97,6563 7,8125 - 314,11 KB
LargeAspNetCoreJsonNetHttpWebRequest 10 1 850,3 μs 1 906,1 μs 80,0781 1,9531 - 248,12 KB
LargeAspNetCoreMessagePackHttpClient 10 1 918,2 μs 1 968,2 μs 72,2656 - - 226,34 KB
LargeAspNetCoreMessagePackHttpClientAsync 10 1 887,3 μs 1 928,9 μs 72,2656 3,9063 - 225,47 KB
LargeAspNetCoreMessagePackHttpWebRequest 10 1 004,9 μs 1 092,8 μs 54,6875 - - 170,9 KB
LargeAspNetCoreMsgPackCliHttpClient 10 3 863,2 μs 4 074,2 μs 328,1250 39,0625 - 1 079,12 KB
LargeAspNetCoreMsgPackCliHttpClientAsync 10 3 884,9 μs 4 069,2 μs 320,3125 62,5000 - 1 076,46 KB
LargeAspNetCoreMsgPackCliHttpWebRequest 10 2 934,6 μs 3 032,9 μs 261,7188 - - 810,53 KB
LargeAspNetCoreXmlHttpClient 10 2 441,5 μs 2 564,4 μs 121,0938 15,6250 - 390,76 KB
LargeAspNetCoreXmlHttpClientAsync 10 2 309,3 μs 2 418,6 μs 117,1875 15,6250 - 387,58 KB
LargeAspNetCoreXmlHttpWebRequest 10 1 832,4 μs 1 883,3 μs 87,8906 1,9531 - 275,59 KB
LargeAspNetCoreUtf8JsonHttpClient 10 2 094,2 μs 2 132,6 μs 74,2188 - - 232,16 KB
LargeAspNetCoreUtf8JsonHttpClientAsync 10 2 001,8 μs 2 040,2 μs 74,2188 - - 228,23 KB
LargeAspNetCoreUtf8JsonHttpWebRequest 10 1 395,6 μs 1 437,7 μs 54,6875 - - 172,95 KB
LargeAspNetCoreZeroFormatterHttpClient 10 2 051,5 μs 2 088,9 μs 136,7188 3,9063 - 422,55 KB
LargeAspNetCoreZeroFormatterHttpClientAsync 10 2 042,6 μs 2 085,0 μs 132,8125 3,9063 - 419,67 KB
LargeAspNetCoreZeroFormatterHttpWebRequest 10 1 037,5 μs 1 129,9 μs 103,5156 3,9063 - 325,47 KB
SmallWcfText 100 942,8 μs 1 056,0 μs 27,3438 - - 89,15 KB
SmallWcfWebXml 100 912,8 μs 1 011,6 μs 30,2734 - - 93,31 KB
SmallWcfWebJson 100 1 159,4 μs 1 255,2 μs 29,2969 - - 92,44 KB
SmallWcfBinary 100 815,3 μs 893,2 μs 27,3438 - - 86,43 KB
SmallWcfNetTcp 100 540,2 μs 592,0 μs 18,5547 - - 59,29 KB
SmallWcfMsgPackCli 100 1 335,9 μs 1 456,1 μs 183,5938 27,3438 - 608,38 KB
SmallWebApiJsonNetHttpClient 100 2 083,6 μs 2 130,4 μs 70,3125 7,8125 - 242,81 KB
SmallWebApiJsonNetHttpClientAsync 100 1 984,6 μs 2 042,8 μs 70,3125 7,8125 - 243,21 KB
SmallWebApiJsonNetHttpWebRequest 100 1 171,0 μs 1 260,1 μs 58,5938 9,7656 - 208,64 KB
SmallWebApiMessagePackHttpClient 100 1 212,0 μs 1 231,5 μs 37,1094 9,7656 - 133,02 KB
SmallWebApiMessagePackHttpClientAsync 100 1 271,2 μs 1 424,3 μs 37,1094 5,8594 - 132,95 KB
SmallWebApiMessagePackHttpWebRequest 100 832,0 μs 880,6 μs 36,1328 10,7422 - 117,93 KB
SmallWebApiMsgPackCliHttpClient 100 2 451,0 μs 2 518,3 μs 179,6875 15,6250 - 575,5 KB
SmallWebApiMsgPackCliHttpClientAsync 100 2 306,5 μs 2 411,4 μs 175,7813 19,5313 - 575,75 KB
SmallWebApiMsgPackCliHttpWebRequest 100 1 305,6 μs 1 341,5 μs 113,2813 13,6719 - 386,04 KB
SmallWebApiXmlHttpClient 100 2 150,5 μs 2 200,4 μs 74,2188 7,8125 - 269,46 KB
SmallWebApiXmlHttpClientAsync 100 1 998,5 μs 2 096,1 μs 74,2188 7,8125 - 268,94 KB
SmallWebApiXmlHttpWebRequest 100 1 279,7 μs 1 325,1 μs 68,3594 9,7656 - 242,99 KB
SmallWebApiUtf8JsonHttpClient 100 1 582,7 μs 1 631,7 μs 39,0625 5,8594 - 140,72 KB
SmallWebApiUtf8JsonHttpClientAsync 100 1 652,5 μs 1 770,8 μs 39,0625 7,8125 - 141,04 KB
SmallWebApiUtf8JsonHttpWebRequest 100 755,1 μs 792,2 μs 36,1328 10,7422 - 117,63 KB
SmallWebApiZeroFormatterHttpClient 100 1 350,9 μs 1 422,6 μs 103,5156 11,7188 - 342,53 KB
SmallWebApiZeroFormatterHttpClientAsync 100 1 342,6 μs 1 396,2 μs 99,6094 11,7188 - 340,31 KB
SmallWebApiZeroFormatterHttpWebRequest 100 683,0 μs 706,2 μs 72,2656 10,7422 - 245,19 KB
SmallAspNetCoreJsonNetHttpClient 100 2 069,1 μs 2 128,2 μs 62,5000 - - 200,16 KB
SmallAspNetCoreJsonNetHttpClientAsync 100 1 951,7 μs 2 002,4 μs 66,4063 - - 204,71 KB
SmallAspNetCoreJsonNetHttpWebRequest 100 1 217,3 μs 1 367,3 μs 50,7813 - - 161,44 KB
SmallAspNetCoreMessagePackHttpClient 100 1 065,4 μs 1 133,9 μs 29,2969 - - 93,2 KB
SmallAspNetCoreMessagePackHttpClientAsync 100 1 065,1 μs 1 169,8 μs 29,2969 - - 93,98 KB
SmallAspNetCoreMessagePackHttpWebRequest 100 629,9 μs 668,2 μs 24,4141 - - 76,94 KB
SmallAspNetCoreMsgPackCliHttpClient 100 2 346,8 μs 2 440,4 μs 171,8750 - - 542,28 KB
SmallAspNetCoreMsgPackCliHttpClientAsync 100 2 178,9 μs 2 268,5 μs 171,8750 - - 534,97 KB
SmallAspNetCoreMsgPackCliHttpWebRequest 100 1 499,3 μs 1 571,4 μs 117,1875 1,9531 - 363,42 KB
SmallAspNetCoreXmlHttpClient 100 2 121,8 μs 2 172,4 μs 74,2188 - - 230,88 KB
SmallAspNetCoreXmlHttpClientAsync 100 2 002,2 μs 2 041,1 μs 74,2188 - - 232,82 KB
SmallAspNetCoreXmlHttpWebRequest 100 1 406,0 μs 1 485,5 μs 64,4531 - - 202,55 KB
SmallAspNetCoreUtf8JsonHttpClient 100 1 402,6 μs 1 536,1 μs 35,1563 - - 110,85 KB
SmallAspNetCoreUtf8JsonHttpClientAsync 100 1 596,1 μs 1 766,4 μs 35,1563 - - 112,05 KB
SmallAspNetCoreUtf8JsonHttpWebRequest 100 799,6 μs 828,7 μs 24,4141 - - 76,38 KB
SmallAspNetCoreZeroFormatterHttpClient 100 1 116,5 μs 1 164,2 μs 72,2656 - - 225,11 KB
SmallAspNetCoreZeroFormatterHttpClientAsync 100 1 158,2 μs 1 217,4 μs 70,3125 - - 223,29 KB
SmallAspNetCoreZeroFormatterHttpWebRequest 100 579,0 μs 612,3 μs 41,9922 - - 131,31 KB
LargeWcfText 100 10 306,5 μs 10 611,5 μs 234,3750 125,0000 15,6250 1 260,97 KB
LargeWcfWebXml 100 10 125,9 μs 10 441,0 μs 250,0000 125,0000 15,6250 1 265,46 KB
LargeWcfWebJson 100 12 535,9 μs 12 877,7 μs 328,1250 171,8750 15,6250 1 415,91 KB
LargeWcfBinary 100 6 889,3 μs 7 074,8 μs 242,1875 132,8125 15,6250 1 142,53 KB
LargeWcfNetTcp 100 5 469,9 μs 5 734,8 μs 117,1875 54,6875 - 707,86 KB
LargeWcfMsgPackCli 100 22 791,3 μs 23 427,8 μs 1 718,7500 562,5000 - 6 327,24 KB
LargeWebApiJsonNetHttpClient 100 17 566,7 μs 18 302,4 μs 718,7500 375,0000 31,2500 3 107,27 KB
LargeWebApiJsonNetHttpClientAsync 100 17 516,1 μs 18 712,4 μs 718,7500 375,0000 31,2500 3 104,68 KB
LargeWebApiJsonNetHttpWebRequest 100 14 204,2 μs 14 858,3 μs 687,5000 359,3750 15,6250 2 649,91 KB
LargeWebApiMessagePackHttpClient 100 9 292,9 μs 9 652,5 μs 562,5000 296,8750 31,2500 2 471,18 KB
LargeWebApiMessagePackHttpClientAsync 100 9 372,5 μs 9 955,7 μs 546,8750 281,2500 31,2500 2 468,98 KB
LargeWebApiMessagePackHttpWebRequest 100 7 023,7 μs 7 238,6 μs 539,0625 281,2500 31,2500 2 334,58 KB
LargeWebApiMsgPackCliHttpClient 100 26 691,1 μs 27 635,9 μs 2 781,2500 437,5000 - 8 971,83 KB
LargeWebApiMsgPackCliHttpClientAsync 100 27 301,6 μs 28 104,1 μs 2 718,7500 312,5000 - 8 964,38 KB
LargeWebApiMsgPackCliHttpWebRequest 100 28 510,5 μs 29 251,2 μs 2 156,2500 312,5000 - 7 012,67 KB
LargeWebApiXmlHttpClient 100 16 932,3 μs 17 843,6 μs 687,5000 343,7500 31,2500 2 923,73 KB
LargeWebApiXmlHttpClientAsync 100 17 027,4 μs 17 928,7 μs 718,7500 375,0000 31,2500 2 929,49 KB
LargeWebApiXmlHttpWebRequest 100 12 461,1 μs 12 776,3 μs 703,1250 359,3750 15,6250 2 508,79 KB
LargeWebApiUtf8JsonHttpClientAsync 100 13 971,3 μs 14 304,9 μs 609,3750 343,7500 78,1250 3 675,47 KB
LargeWebApiUtf8JsonHttpWebRequest 100 11 023,6 μs 11 288,5 μs 609,3750 359,3750 78,1250 3 482,26 KB
LargeWebApiZeroFormatterHttpClient 100 10 964,6 μs 11 333,5 μs 765,6250 343,7500 46,8750 3 371,39 KB
LargeWebApiZeroFormatterHttpClientAsync 100 11 121,3 μs 11 440,2 μs 765,6250 406,2500 46,8750 3 371,05 KB
LargeWebApiZeroFormatterHttpWebRequest 100 7 998,7 μs 8 812,0 μs 734,3750 328,1250 46,8750 3 255,86 KB
LargeAspNetCoreJsonNetHttpClient 100 21 906,3 μs 22 576,2 μs 468,7500 250,0000 31,2500 3 203,19 KB
LargeAspNetCoreJsonNetHttpClientAsync 100 21 717,5 μs 22 127,0 μs 531,2500 281,2500 31,2500 3 202,07 KB
LargeAspNetCoreJsonNetHttpWebRequest 100 18 784,1 μs 19 337,5 μs 406,2500 187,5000 - 2 361,35 KB
LargeAspNetCoreMessagePackHttpClient 100 8 699,5 μs 9 226,8 μs 281,2500 156,2500 31,2500 2 289,8 KB
LargeAspNetCoreMessagePackHttpClientAsync 100 8 882,4 μs 9 442,3 μs 421,8750 234,3750 31,2500 2 292,26 KB
LargeAspNetCoreMessagePackHttpWebRequest 100 6 347,1 μs 6 514,6 μs 273,4375 148,4375 23,4375 1 986,16 KB
LargeAspNetCoreMsgPackCliHttpClient 100 25 200,5 μs 26 195,3 μs 1 625,0000 406,2500 - 8 704,53 KB
LargeAspNetCoreMsgPackCliHttpClientAsync 100 24 995,5 μs 25 570,6 μs 1 593,7500 312,5000 - 8 693,94 KB
LargeAspNetCoreMsgPackCliHttpWebRequest 100 26 311,1 μs 27 043,4 μs 1 218,7500 468,7500 - 6 775,73 KB
LargeAspNetCoreXmlHttpClient 100 25 697,8 μs 26 587,6 μs 437,5000 218,7500 31,2500 2 893,75 KB
LargeAspNetCoreXmlHttpClientAsync 100 25 770,5 μs 26 730,3 μs 406,2500 218,7500 31,2500 2 892,88 KB
LargeAspNetCoreXmlHttpWebRequest 100 20 484,6 μs 22 693,2 μs 312,5000 156,2500 - 2 105,34 KB
LargeAspNetCoreUtf8JsonHttpClient 100 13 273,5 μs 13 686,2 μs 375,0000 234,3750 78,1250 3 663,91 KB
LargeAspNetCoreUtf8JsonHttpClientAsync 100 13 432,0 μs 13 901,2 μs 359,3750 234,3750 78,1250 3 663,88 KB
LargeAspNetCoreUtf8JsonHttpWebRequest 100 9 944,2 μs 10 382,7 μs 312,5000 203,1250 62,5000 3 088,47 KB
LargeAspNetCoreZeroFormatterHttpClient 100 9 847,4 μs 10 512,3 μs 406,2500 218,7500 46,8750 2 909,31 KB
LargeAspNetCoreZeroFormatterHttpClientAsync 100 9 890,6 μs 10 254,3 μs 421,8750 250,0000 46,8750 2 911,12 KB
LargeAspNetCoreZeroFormatterHttpWebRequest 100 6 888,7 μs 7 243,7 μs 390,6250 210,9375 46,8750 2 802,42 KB
SmallWcfText 1000 5 091,3 μs 5 333,0 μs 203,1250 54,6875 - 646,88 KB
SmallWcfWebXml 1000 5 170,4 μs 5 273,4 μs 195,3125 54,6875 - 648,61 KB
SmallWcfWebJson 1000 6 099,8 μs 6 294,8 μs 187,5000 39,0625 - 619,48 KB
SmallWcfBinary 1000 4 486,1 μs 4 804,9 μs 187,5000 39,0625 - 621,5 KB
SmallWcfNetTcp 1000 4 070,6 μs 4 243,7 μs 179,6875 39,0625 - 643,88 KB
SmallWcfMsgPackCli 1000 5 262,8 μs 5 447,1 μs 601,5625 171,8750 - 1 872,26 KB
SmallWebApiJsonNetHttpClient 1000 8 703,8 μs 9 127,8 μs 484,3750 187,5000 - 1 544,87 KB
SmallWebApiJsonNetHttpClientAsync 1000 8 681,5 μs 9 036,5 μs 484,3750 187,5000 - 1 543,54 KB
SmallWebApiJsonNetHttpWebRequest 1000 6 954,6 μs 7 082,1 μs 445,3125 140,6250 - 1 403,19 KB
SmallWebApiMessagePackHttpClient 1000 4 084,5 μs 4 484,5 μs 234,3750 62,5000 - 770,84 KB
SmallWebApiMessagePackHttpClientAsync 1000 4 234,1 μs 4 661,6 μs 234,3750 101,5625 - 770,07 KB
SmallWebApiMessagePackHttpWebRequest 1000 3 052,9 μs 3 218,4 μs 218,7500 50,7813 - 700,45 KB
SmallWebApiMsgPackCliHttpClient 1000 11 586,3 μs 11 913,2 μs 1 078,1250 296,8750 - 3 395,91 KB
SmallWebApiMsgPackCliHttpClientAsync 1000 11 734,6 μs 12 014,9 μs 1 093,7500 296,8750 - 3 394,1 KB
SmallWebApiMsgPackCliHttpWebRequest 1000 10 466,6 μs 10 964,3 μs 718,7500 234,3750 - 2 269,57 KB
SmallWebApiXmlHttpClient 1000 8 957,6 μs 9 437,3 μs 468,7500 156,2500 - 1 649,38 KB
SmallWebApiXmlHttpClientAsync 1000 9 080,0 μs 9 525,4 μs 453,1250 156,2500 - 1 647,59 KB
SmallWebApiXmlHttpWebRequest 1000 7 764,3 μs 8 270,7 μs 421,8750 140,6250 - 1 451,44 KB
SmallWebApiUtf8JsonHttpClient 1000 5 008,2 μs 5 230,1 μs 250,0000 78,1250 - 840,26 KB
SmallWebApiUtf8JsonHttpClientAsync 1000 4 981,5 μs 5 222,4 μs 273,4375 101,5625 - 842,22 KB
SmallWebApiUtf8JsonHttpWebRequest 1000 3 526,5 μs 3 561,6 μs 234,3750 70,3125 - 761,92 KB
SmallWebApiZeroFormatterHttpClient 1000 4 074,3 μs 4 389,9 μs 429,6875 210,9375 - 1 346,46 KB
SmallWebApiZeroFormatterHttpClientAsync 1000 4 039,7 μs 4 393,4 μs 421,8750 210,9375 - 1 342,02 KB
SmallWebApiZeroFormatterHttpWebRequest 1000 2 794,2 μs 2 919,8 μs 390,6250 187,5000 - 1 240,37 KB
SmallAspNetCoreJsonNetHttpClient 1000 10 322,9 μs 10 687,6 μs 359,3750 109,3750 - 1 473,25 KB
SmallAspNetCoreJsonNetHttpClientAsync 1000 10 401,2 μs 10 776,3 μs 375,0000 125,0000 - 1 475,8 KB
SmallAspNetCoreJsonNetHttpWebRequest 1000 8 998,8 μs 9 751,7 μs 375,0000 109,3750 - 1 235,5 KB
SmallAspNetCoreMessagePackHttpClient 1000 3 970,5 μs 4 300,8 μs 179,6875 54,6875 - 695,07 KB
SmallAspNetCoreMessagePackHttpClientAsync 1000 3 967,7 μs 4 317,4 μs 171,8750 54,6875 - 695,65 KB
SmallAspNetCoreMessagePackHttpWebRequest 1000 2 990,7 μs 3 056,3 μs 167,9688 7,8125 - 527,22 KB
SmallAspNetCoreMsgPackCliHttpClient 1000 11 072,9 μs 11 383,8 μs 968,7500 203,1250 - 3 286,54 KB
SmallAspNetCoreMsgPackCliHttpClientAsync 1000 11 269,9 μs 11 486,5 μs 953,1250 203,1250 - 3 282,89 KB
SmallAspNetCoreMsgPackCliHttpWebRequest 1000 10 055,8 μs 10 532,7 μs 671,8750 171,8750 - 2 176,11 KB
SmallAspNetCoreXmlHttpClient 1000 15 872,2 μs 16 587,9 μs 406,2500 62,5000 - 1 623,8 KB
SmallAspNetCoreXmlHttpClientAsync 1000 16 132,0 μs 16 742,2 μs 437,5000 31,2500 - 1 623,78 KB
SmallAspNetCoreXmlHttpWebRequest 1000 12 898,5 μs 14 694,2 μs 328,1250 78,1250 - 1 218,43 KB
SmallAspNetCoreUtf8JsonHttpClient 1000 4 489,3 μs 5 041,2 μs 195,3125 62,5000 - 745,89 KB
SmallAspNetCoreUtf8JsonHttpClientAsync 1000 4 834,4 μs 4 987,0 μs 226,5625 70,3125 - 746,11 KB
SmallAspNetCoreUtf8JsonHttpWebRequest 1000 3 584,3 μs 3 676,0 μs 183,5938 7,8125 - 577,3 KB
SmallAspNetCoreZeroFormatterHttpClient 1000 3 279,5 μs 3 447,7 μs 308,5938 125,0000 - 1 122,6 KB
SmallAspNetCoreZeroFormatterHttpClientAsync 1000 3 363,8 μs 3 592,3 μs 308,5938 136,7188 - 1 123,26 KB
SmallAspNetCoreZeroFormatterHttpWebRequest 1000 2 542,6 μs 2 691,8 μs 203,1250 82,0313 - 1 019,71 KB
LargeWcfText 1000 113 203,8 μs 116 349,7 μs 3 062,5000 1 375,0000 625,0000 26 257,81 KB
LargeWcfWebXml 1000 113 749,8 μs 119 653,4 μs 3 000,0000 1 375,0000 625,0000 26 267,92 KB
LargeWcfWebJson 1000 124 571,2 μs 126 913,4 μs 3 562,5000 1 000,0000 375,0000 19 550,39 KB
LargeWcfBinary 1000 75 785,2 μs 77 798,0 μs 2 625,0000 1 062,5000 375,0000 16 826,8 KB
LargeWcfNetTcp 1000 63 496,8 μs 65 131,4 μs 1 437,5000 750,0000 312,5000 15 259,22 KB
LargeWcfMsgPackCli 1000 226 764,2 μs 228 210,0 μs 14 312,5000 2 062,5000 812,5000 63 616,09 KB
LargeWebApiJsonNetHttpClient 1000 146 788,7 μs 150 342,6 μs 6 062,5000 1 000,0000 312,5000 28 004,73 KB
LargeWebApiJsonNetHttpClientAsync 1000 148 252,3 μs 150 701,1 μs 6 125,0000 1 000,0000 312,5000 28 005,47 KB
LargeWebApiJsonNetHttpWebRequest 1000 137 693,6 μs 140 988,9 μs 6 187,5000 1 000,0000 250,0000 24 196,63 KB
LargeWebApiMessagePackHttpClient 1000 76 918,2 μs 79 686,3 μs 5 500,0000 1 187,5000 375,0000 26 612,74 KB
LargeWebApiMessagePackHttpClientAsync 1000 79 844,3 μs 82 522,0 μs 5 500,0000 1 187,5000 375,0000 26 607,16 KB
LargeWebApiMessagePackHttpWebRequest 1000 71 342,8 μs 73 000,7 μs 5 437,5000 1 187,5000 375,0000 25 423,91 KB
LargeWebApiMsgPackCliHttpClient 1000 231 637,3 μs 233 815,8 μs 27 187,5000 1 875,0000 250,0000 87 423,5 KB
LargeWebApiMsgPackCliHttpClientAsync 1000 235 545,0 μs 237 502,2 μs 26 812,5000 1 750,0000 250,0000 87 424,05 KB
LargeWebApiMsgPackCliHttpWebRequest 1000 273 161,6 μs 274 337,6 μs 21 375,0000 1 625,0000 250,0000 68 248,17 KB
LargeWebApiXmlHttpClient 1000 138 851,2 μs 140 807,8 μs 6 500,0000 1 375,0000 500,0000 32 739,53 KB
LargeWebApiXmlHttpClientAsync 1000 137 728,4 μs 139 416,2 μs 6 437,5000 1 250,0000 500,0000 32 737,39 KB
LargeWebApiXmlHttpWebRequest 1000 117 583,8 μs 119 814,8 μs 6 312,5000 1 125,0000 312,5000 27 616,55 KB
LargeWebApiUtf8JsonHttpClientAsync 1000 108 526,5 μs 110 023,5 μs 5 937,5000 1 250,0000 625,0000 36 588,36 KB
LargeWebApiUtf8JsonHttpWebRequest 1000 99 423,4 μs 101 303,8 μs 5 875,0000 1 250,0000 625,0000 34 853,14 KB
LargeWebApiZeroFormatterHttpClient 1000 93 279,3 μs 95 066,0 μs 6 000,0000 1 875,0000 625,0000 34 568,77 KB
LargeWebApiZeroFormatterHttpClientAsync 1000 93 082,5 μs 96 336,2 μs 6 125,0000 1 812,5000 625,0000 34 556,73 KB
LargeWebApiZeroFormatterHttpWebRequest 1000 83 440,5 μs 87 326,7 μs 6 062,5000 1 750,0000 625,0000 35 920,83 KB
LargeAspNetCoreJsonNetHttpClient 1000 190 051,4 μs 193 029,4 μs 4 375,0000 1 187,5000 312,5000 29 453,69 KB
LargeAspNetCoreJsonNetHttpClientAsync 1000 191 288,1 μs 194 703,0 μs 4 312,5000 1 000,0000 312,5000 29 435,33 KB
LargeAspNetCoreJsonNetHttpWebRequest 1000 172 396,6 μs 174 307,9 μs 4 000,0000 750,0000 62,5000 22 879,07 KB
LargeAspNetCoreMessagePackHttpClient 1000 74 707,4 μs 76 628,3 μs 2 937,5000 1 062,5000 375,0000 24 513,18 KB
LargeAspNetCoreMessagePackHttpClientAsync 1000 75 239,7 μs 77 764,9 μs 3 062,5000 875,0000 375,0000 24 503,66 KB
LargeAspNetCoreMessagePackHttpWebRequest 1000 64 765,4 μs 67 297,2 μs 2 750,0000 1 000,0000 312,5000 22 184,38 KB
LargeAspNetCoreMsgPackCliHttpClient 1000 224 174,1 μs 226 700,3 μs 16 000,0000 1 875,0000 500,0000 84 368,61 KB
LargeAspNetCoreMsgPackCliHttpClientAsync 1000 226 491,1 μs 229 350,5 μs 15 625,0000 1 562,5000 250,0000 84 367,02 KB
LargeAspNetCoreMsgPackCliHttpWebRequest 1000 259 125,8 μs 260 689,1 μs 12 437,5000 1 625,0000 250,0000 66 232,65 KB
LargeAspNetCoreXmlHttpClient 1000 187 939,3 μs 191 380,4 μs 4 062,5000 1 062,5000 375,0000 29 287,81 KB
LargeAspNetCoreXmlHttpClientAsync 1000 186 831,9 μs 191 377,0 μs 3 750,0000 1 000,0000 375,0000 29 274,29 KB
LargeAspNetCoreXmlHttpWebRequest 1000 163 545,0 μs 166 214,4 μs 3 312,5000 750,0000 125,0000 21 599,57 KB
LargeAspNetCoreUtf8JsonHttpClient 1000 112 656,4 μs 114 328,7 μs 3 750,0000 1 500,0000 875,0000 35 651,9 KB
LargeAspNetCoreUtf8JsonHttpClientAsync 1000 113 442,3 μs 116 928,0 μs 3 750,0000 1 500,0000 937,5000 35 638,04 KB
LargeAspNetCoreUtf8JsonHttpWebRequest 1000 91 813,6 μs 93 977,9 μs 3 187,5000 1 250,0000 625,0000 31 173,77 KB
LargeAspNetCoreZeroFormatterHttpClient 1000 89 996,3 μs 92 385,9 μs 3 375,0000 1 562,5000 625,0000 31 020,04 KB
LargeAspNetCoreZeroFormatterHttpClientAsync 1000 89 334,9 μs 92 773,4 μs 3 312,5000 1 562,5000 625,0000 31 017,05 KB
LargeAspNetCoreZeroFormatterHttpWebRequest 1000 81 701,0 μs 85 651,5 μs 3 000,0000 1 437,5000 500,0000 32 338,78 KB