Slik benchmarker du C # -kode ved hjelp av BenchmarkDotNet

BenchmarkDotNet er et lett, åpen kildekode, kraftig. NET-bibliotek som kan forvandle metodene dine til referanser, spore disse metodene, og deretter gi innsikt i ytelsesdataene som er fanget. Det er enkelt å skrive BenchmarkDotNet-referanser, og resultatene av referanseprosessen er også brukervennlige.

Du kan dra nytte av BenchmarkDotNet for å måle både .NET Framework og .NET Core-applikasjoner. I denne artikkelen vil vi undersøke hvordan vi kan jobbe med BenchmarkDotNet i .NET Core. Du finner BenchmarkDotNet på GitHub.

For å jobbe med kodeeksemplene som er gitt i denne artikkelen, bør du ha Visual Studio 2019 installert på systemet ditt. Hvis du ikke allerede har en kopi, kan du laste ned Visual Studio 2019 her.

Opprett et konsollapplikasjonsprosjekt i Visual Studio

La oss først lage et .NET Core-konsollapplikasjonsprosjekt i Visual Studio. Forutsatt at Visual Studio 2019 er installert i systemet ditt, følger du trinnene som er beskrevet nedenfor for å opprette et nytt .NET Core-konsollapplikasjonsprosjekt i Visual Studio.

Start Visual Studio IDE.
Klikk på "Opprett nytt prosjekt."
I vinduet "Opprett nytt prosjekt" velger du "Konsollapp (.NET Core)" fra listen over maler som vises.
Klikk på Neste.
I vinduet “Konfigurer ditt nye prosjekt” som vises, angir du navnet og stedet for det nye prosjektet.
Klikk på Opprett.

Dette vil opprette et nytt .NET Core-konsollapplikasjonsprosjekt i Visual Studio 2019.

Merk at når du oppretter konsollapplikasjonsprosjektet, vil den resulterende programklassen (generert automatisk i Program.cs-filen) se slik ut:

klasse Program
{
  statisk tomrom Main (streng [] args)
  {
  Console.WriteLine ("Hello World!");
  }
}

Vi bruker dette prosjektet og programklassen til å jobbe med BenchmarkDotNet i de påfølgende delene av denne artikkelen.

Installer BenchmarkDotNet NuGet-pakken

For å jobbe med BenchmarkDotNet må du installere BenchmarkDotNet-pakken. Du kan gjøre dette enten via NuGet Package Manager inne i Visual Studio 2019 IDE, eller ved å utføre følgende kommando i NuGet Package Manager-konsollen:

Install-Package BenchmarkDotNet

Hvorfor referansekode?

Et mål er en måling eller et sett med målinger relatert til ytelsen til et stykke kode i en applikasjon. Benchmarking-kode er viktig for å forstå ytelsesberegningene for metodene i applikasjonen din. Det er alltid en god tilnærming å ha beregningene tilgjengelig når du optimaliserer koden. Det er veldig viktig for oss å vite om endringene i koden har forbedret eller forverret ytelsen. Benchmarking hjelper deg også med å begrense delene av koden i applikasjonen som trenger refactoring.

Fremgangsmåte for benchmarking av kode ved bruk av BenchmarkDotNet

For å kjøre BenchmarkDotNet i .NET Framework eller .NET Core-applikasjonen må du følge disse trinnene:

Legg til den nødvendige NuGet-pakken
Legg til benchmark-attributter til metodene dine
Opprett en BenchmarkRunner-forekomst
Kjør applikasjonen i frigjøringsmodus

Lag en benchmarking-klasse i .NET Core

Åpne Program.cs-filen og skriv følgende kode der inne.

  [MemoryDiagnoser]
  offentlig klasse MemoryBenchmarkerDemo
    {
  int NumberOfItems = 100000;
  [Referanse]
  offentlig streng ConcatStringsUsingStringBuilder ()
        {
  var sb = ny StringBuilder ();
  for (int i = 0; i <NumberOfItems; i ++)
            {
  sb.Append ("Hello World!" + i);
            }
  returner sb.ToString ();
        }
  [Referanse]
  offentlig streng ConcatStringsUsingGenericList ()
        {
  var list = new List (NumberOfItems);
  for (int i = 0; i <NumberOfItems; i ++)
            {
  list.Add ("Hello World!" + i);
            }
  returliste.ToString ();
        }
    }

Ovennevnte program illustrerer hvordan du kan skrive metoder for benchmarking. Legg merke til bruken av Benchmark-attributtet på toppen av hver av metodene som skal benchmarkes.

I hovedmetoden til Program.cs-filen må du spesifisere det opprinnelige startpunktet - BenchmarkRunner-klassen. Dette er en måte å informere BenchmarkDotNet om å kjøre referanser på den spesifiserte klassen. Så erstatt standardkoden til hovedmetoden i Program.cs-filen ved hjelp av følgende kodebit.

statisk tomrom Main (streng [] args)
{
  var oppsummering = BenchmarkRunner.Run ();
}

Kjør referansen i .NET Core-applikasjonen

Hvis du kjører programmet i feilsøkingsmodus, ser du feilmeldingen:

Ved benchmarking bør du alltid sørge for at du kjører prosjektet i utgivelsesmodus. Årsaken er at koden optimaliseres annerledes for både feilsøkings- og utgivelsesmodus under kompilering. C # -kompilatoren gjør noen få optimaliseringer i utgivelsesmodus som ikke er tilgjengelige i feilsøkingsmodus.

Derfor bør du bare kjøre prosjektet i utgivelsesmodus. For å kjøre benchmarking, spesifiser følgende kommando ved Visual Studio-ledeteksten.

dotnet run -p BenchmarkDotNetDemo.csproj -c Utgivelse

For best resultat, bør du sørge for at alle applikasjoner er stengt og at alle unødvendige prosesser stoppes før du kjører referanser.

Vær oppmerksom på at hvis du ikke spesifiserer konfigurasjonsparameteren, vil kjøretiden prøve å gjøre benchmarking på ikke-optimalisert feilsøkingskode. Og du får den samme feilen som vist i figur 1.

Analyser benchmarking-resultatene

Når gjennomføringen av referanseprosessen er fullført, vil et sammendrag av resultatene vises i konsollvinduet. Sammendraget inneholder informasjon relatert til miljøet som referanseverdiene ble utført i, for eksempel BenchmarkDotNet-versjonen, operativsystem, maskinvare, .NET-versjon, kompilatorinformasjon og informasjon relatert til ytelsen til applikasjonen.

Noen få filer vil også bli opprettet i BenchmarkDotNet.Artifacts-mappen under programmets rotmappe. Her er et sammendrag av resultatene.

Som det fremgår av sammendraget vist i figur 2, vil du for hver referansemetode se en rad med data som spesifiserer ytelsesberegningene som gjennomsnittlig utførelsestid, Gen 0, Gen 1, Gen 2 samlinger, etc.

Når du undersøker resultatene vist i figur 3, kan du se at ConcatStringUsingGenericList er mye raskere enn ConcatStringUsingStringBuilder-metoden. Du kan også se at det er mange flere tildelinger etter å ha kjørt ConcatStringUsingStringBuilder-metoden.

Legg nå til RankColumn-attributtet på toppen av MemoryBenchmarkerDemo-klassen. Dette vil legge til en ekstra kolonne i utgangen som indikerer hvilken metode som var raskere. Kjør referanseprosessen igjen ved hjelp av følgende kommando.

dotnet run -p BenchmarkDotNetDemo.csproj -c Utgivelse

Når du kjører denne kommandoen, starter benchmarking-prosessen og viser utdataene etter at benchmarking-prosessen er utført. Figur 4 nedenfor viser produksjonen med RankColumn lagt til.

BenchmarkDotNet er et fint verktøy som gir en enkel måte å ta en informert beslutning om ytelsesberegningene for søknaden din. I BenchmarkDotNet er påkallelse av en metode som har Benchmark-attributt settet kjent som en operasjon. En iterasjon er navnet på en samling av flere operasjoner.

Du kan utforske en demo ASP.NET Core-applikasjon som illustrerer flere måter å måle koden på. Du kan få applikasjonen fra ASP.NET repo på GitHub.