Geekly articles weekly

Cara lain untuk mengukur kinerja metode aplikasi .NET


Seringkali, perlu untuk mengumpulkan statistik tentang kinerja metode aplikasi secara real time (ketika aplikasi sudah berjalan) untuk mengidentifikasi hambatannya dan melihat bagian mana dari aplikasi yang melambat.


Selain itu, alangkah baiknya, selain data kinerja itu sendiri (waktu pengembangan metode, tanggal mulai dan berakhirnya panggilan) untuk menyimpan konteks panggilan di mana kinerja dipantau (seperti argumen pemanggilan metode dan data sewenang-wenang yang ditambahkan oleh pengembang).


Nah, "cherry on the cake" bisa dianggap kenyamanan dan kesederhanaan alat yang digunakan, yang juga penting.


Untuk mengatasi masalah ini, pustaka .NET open-source cross-platform Unchase.FluentPerformanceMeter dikembangkan .


Pendahuluan


Jadi, artikel ini adalah deskripsi bekerja dengan Unchase Fluent Performance Meter , pustaka sumber terbuka lintas-platform .Net Standard 2.0 yang dirancang untuk menghitung kinerja metode.


Perpustakaan dapat digunakan dalam aplikasi .NET Core dan .NET Framework yang mendukung .Net Standard 2.0 , dan memungkinkan:


  • Buat pengukuran yang akurat dari kinerja metode publik untuk kelas publik dari kode Anda dan kode perpustakaan yang digunakan (dengan menetapkan waktu yang tepat dari awal dan akhir pengukuran);
  • Tambahkan data tambahan (Data Khusus) ke hasil pengukuran. Sebagai contoh, nilai-nilai parameter input metode dan hasilnya; atau metode data konteks eksekusi; atau corellationId , dengan mana dimungkinkan untuk menghubungkan beberapa pengukuran kinerja metode;
  • Hancurkan pengukuran kinerja metode menjadi langkah terpisah (Langkah) dengan memperbaiki data sendiri untuk setiap langkah. Selain itu, Anda dapat mengatur runtime minimum , yang darinya langkah akan diperhitungkan dalam pengukuran (jika langkah tersebut diselesaikan lebih cepat, itu tidak akan diukur);
  • Kecualikan setiap bagian dari kode untuk mengukur kinerja (misalnya, panggilan ke metode individual yang waktu pelaksanaannya tidak perlu diperhitungkan saat mengukur);
  • Tambahkan perintah Anda sendiri (Perintah), yang dijamin akan dieksekusi segera setelah akhir pengukuran kinerja metode (misalnya, untuk menambahkan pemrosesan tambahan dari hasil yang diperoleh, seperti mencatat atau menulis data ke penyimpanan);
  • Tambahkan exception handler Anda sendiri untuk kode yang dieksekusi dalam konteks pengukuran kinerja metode (keduanya umum untuk semua pengukuran, dan untuk setiap pengukuran secara terpisah);
  • Atur waktu untuk menyimpan hasil pengukuran produktivitas metode, setelah itu hasilnya akan dihapus;
  • Tambahkan data tentang siapa yang memanggil metode (Penelepon) melalui tugas IHttpContextAccesor atau Penelepon dalam kode ke hasil pengukuran (misalnya, Anda dapat menentukan nama layanan eksternal yang disebut metode);
  • Tambahkan ke data hasil pengukuran di tempat pengukuran kinerja dimulai (nama file dan nomor baris dengan lokasi panggilan dalam kode);
  • Untuk mengganggu pengukuran kinerja metode sampai selesai .

Data yang diperoleh sebagai hasil pengukuran kinerja metode dapat digunakan untuk menganalisis kinerja aplikasi (bagian individualnya, baik kode internal - asli, dan eksternal - kode perpustakaan yang digunakan) dan ditampilkan dalam bentuk grafik yang nyaman untuk Anda.


Isi



Memulai


Untuk menggunakan perpustakaan, instal paket NuGet di proyek Anda:


Menggunakan Manajer Paket NuGet secara manual:


Install-Package Unchase.FluentPerformanceMeter

Menggunakan .NET CLI:


 dotnet add package Unchase.FluentPerformanceMeter --version {version}

Di mana {version} adalah versi paket yang ingin Anda instal.
Misalnya, dotnet add package Unchase.FluentPerformanceMeter --version 1.0.0

Contoh Penggunaan


Metode Pengukuran Kinerja


Berikut ini adalah contoh sederhana menggunakan perpustakaan (tanpa konfigurasi dan pengaturan tambahan) untuk mengukur kinerja metode (Aksi) SimpleWatchingMethodStart pengontrol SimpleWatchingMethodStart (Pengontrol) PerformanceMeterController Asp.Net Core 2.2 aplikasi WebAPI . Untuk melakukan ini, Anda dapat menggunakan metode ekstensi .WatchingMethod().Start() atau fungsionalitas serupa .StartWatching() .
Sejak v1.0.5, Anda juga dapat menggunakan .WatchingMethod().Start(SimpleWatchingMethodStart) atau .StartWatching(SimpleWatchingMethodStart) dengan nama metode.


Semua contoh menggunakan perpustakaan dapat ditemukan di proyek Unchase.FluentPerformanceMeter.Test* dari repositori ini .

 /// <summary> /// Test GET method with simple performance watching. /// </summary> [HttpGet("SimpleWatchingMethodStart")] public ActionResult SimpleWatchingMethodStart() { // for C# 8 you can use: //using var pm = PerformanceMeter<PerformanceMeterController>.StartWatching(); using (PerformanceMeter<PerformanceMeterController>.WatchingMethod().Start()) { // put your code with some logic here return Ok(); } }

Untuk mendapatkan hasil pengukuran kinerja metode publik dari kelas controller PerformanceMeterController , Anda dapat memanggil metode berikut:


 /// <summary> /// Get methods performance info for this controller. /// </summary> /// <returns>Returns methods performance info.</returns> [HttpGet("GetPerformanceInfo")] [IgnoreMethodPerformance] public ActionResult<IPerformanceInfo> GetPerformanceInfo() { return Ok(PerformanceMeter<PerformanceMeterController>.PerformanceInfo); }

Setelah memanggil metode SimpleWatchingMethodStart saat memanggil GetPerformanceInfo kita mendapatkan:


 { "methodCalls": [ { "methodName": "SimpleWatchingMethodStart", "elapsed": "00:00:00.0016350", "caller": "unknown", "startTime": "2019-12-06T10:27:27.3385385Z", "endTime": "2019-12-06T10:27:27.3401735Z", "customData": {}, "steps": [] } ], "totalActivity": [ { "methodName": "SimpleWatchingMethodStart", "callsCount": 1 } ], "currentActivity": [ { "methodName": "SimpleWatchingMethodStart", "callsCount": 0 } ], "uptimeSince": "2019-12-06T10:27:27.3370183Z", "className": "Unchase.FluentPerformanceMeter.TestWebAPI.Controllers.PerformanceMeterController", "methodNames": [ "SimpleWatchingMethodStart" ], "customData": {}, "timerFrequency": 10000000 }

Metode pengukuran kinerja menggunakan DiagnosticSource


Dimulai dengan versi v1.1.0 , menjadi mungkin untuk mengukur kinerja metode dalam aplikasi AspNetCore MVC menggunakan DiagnosticSource dan atribut khusus WatchingWithDiagnosticSourceAttribute .
Untuk melakukan ini, tambahkan paket Unchase.FluentPerformanceMeter.AspNetCore.Mvc ke proyek NuGet dan tambahkan kode berikut ke Startap.cs :


 public void ConfigureServices(IServiceCollection services) { // ... // allows to measure methods performance for class "MeasurableClass" and "MeasurableSecondClass" services.AddPerformanceDiagnosticObserver<MeasurableClass>(); services.AddPerformanceDiagnosticObserver<MeasurableSecondClass>(); // ... the same for another classes services.AddMvc(); // ... } public void Configure(IApplicationBuilder app, IHostingEnvironment env) { // ... app.UsePerformanceDiagnosticObserver(); app.UseMvc(); }

Kemudian tandai dengan atribut WatchingWithDiagnosticSourceAttribute atau metode individual:


 [HttpGet("SimpleWatchingMethodStart")] [WatchingWithDiagnosticSource] public ActionResult SimpleWatchingMethodStart() { return Ok(); }

atau seluruh kelas:


 [ApiController] [Route("api/v1/[controller]")] [Produces("application/json")] [SwaggerTag("Unchase.PerformanceMeter Test WebAPI Controller")] [WatchingWithDiagnosticSource] public class PerformanceMeterController : ControllerBase { // measurable methods }

Dimulai dengan versi v1.2.0 , menjadi mungkin untuk menambahkan argumen doa ke data pengukuran kinerja metode pengguna dalam aplikasi AspNetCore MVC menggunakan atribut AddMethodArgumentsToCustomDataAttribute khusus bersama dengan atribut WatchingWithDiagnosticSourceAttribute :


 [HttpPost("SimpleWatchingMethodStartWithArgs")] [WatchingWithDiagnosticSource] [AddMethodArgumentsToCustomData("actionArguments")] public ActionResult SimpleWatchingMethodStartWithArgs(DTOArgument arg) { return Ok(); }

Setelah memanggil metode SimpleWatchingMethodStartWithArgs saat memanggil GetPerformanceInfo kita mendapatkan:


 { "methodCalls": [ { "methodName": "SimpleWatchingMethodStartWithArgs", "elapsed": "00:00:00.0016350", "caller": "unknown", "startTime": "2019-12-06T10:27:27.3385385Z", "endTime": "2019-12-06T10:27:27.3401735Z", "customData": { "actionArguments": { "arg": { "data": "<string_in_DTOArgument>" } } }, "steps": [] } ], "totalActivity": [ { "methodName": "SimpleWatchingMethodStartWithArgs", "callsCount": 1 } ], "currentActivity": [ { "methodName": "SimpleWatchingMethodStartWithArgs", "callsCount": 0 } ], "uptimeSince": "2019-12-06T10:27:27.3370183Z", "className": "Unchase.FluentPerformanceMeter.TestWebAPI.Controllers.PerformanceMeterController", "methodNames": [ "SimpleWatchingMethodStartWithArgs" ], "customData": {}, "timerFrequency": 10000000 }

Mengukur kinerja metode yang digunakan oleh perpustakaan


Untuk mengukur kinerja metode publik dari kelas publik dari perpustakaan pihak ketiga yang digunakan, Anda harus secara eksplisit mengatur kelas itu sendiri dan nama metodenya:


 [HttpGet("GetThreadSleepPerformance")] public ActionResult<string> GetThreadSleepPerformance() { using (PerformanceMeter<Thread>.WatchingMethod(nameof(Thread.Sleep)).Start()) { Thread.Sleep(1000); } return Ok(PerformanceMeter<Thread>.PerformanceInfo.MethodCalls.FirstOrDefault(ta => ta.MethodName == nameof(Thread.Sleep))?.Elapsed); }

Metode yang dieksekusi akan kembali:


 "00:00:01.0033040"

Anda dapat memperoleh data tentang cara memanggil metode ini melalui panggilan:


 /// <summary> /// Get methods performance info for Thread class. /// </summary> /// <returns>Returns Thread methods performance info.</returns> [HttpGet("GetThreadPerformanceInfo")] [IgnoreMethodPerformance] public ActionResult<IPerformanceInfo> GetThreadPerformanceInfo() { return Ok(PerformanceMeter<Thread>.PerformanceInfo); }

Atribut IgnoreMethodPerformance dirancang sehingga metode yang IgnoreMethodPerformance tidak diperhitungkan saat mengukur kinerja.

Menanggapi panggilan untuk metode ini akan:


 { "methodCalls": [ { "methodName": "Sleep", "elapsed": "00:00:01.0033040", "caller": "unknown", "startTime": "2019-12-06T13:08:09.336624Z", "endTime": "2019-12-06T13:08:10.339928Z", "customData": {}, "steps": [] } ], "totalActivity": [ { "methodName": "Abort", "callsCount": 0 }, // ... { "methodName": "Sleep", "callsCount": 1 } // ... ], "currentActivity": [ { "methodName": "Abort", "callsCount": 0 }, // ... { "methodName": "Sleep", "callsCount": 1 } // ... ], "uptimeSince": "2019-12-06T13:08:09.3357028Z", "className": "System.Threading.Thread", "methodNames": [ "Abort", // ... "Sleep", // ... ], "customData": {}, "timerFrequency": 10000000 }

Menambahkan Data Tambahan (Data Khusus) dan Paginasi (Langkah)


Anda dapat menambahkan data tambahan (Data Khusus) untuk semua pengukuran kinerja metode kelas tertentu. Misalnya, dalam konstruktor statis dari kelas controller PerformanceMeterController :


 [ApiController] [Route("api/v1/[controller]")] public class PerformanceMeterController : ControllerBase { /// <summary> /// Static constructor. /// </summary> static PerformanceMeterController() { // add common custom data (string) to class performance information PerformanceMeter<PerformanceMeterController>.AddCustomData("Tag", "CustomTag"); // add common custom data (anonymous class) to class performance information PerformanceMeter<PerformanceMeterController>.AddCustomData("Custom anonymous class", new { Name = "Custom Name", Value = 1 }); } // ... actions }

Selain itu, Anda dapat menambahkan data tambahan (Data Khusus) untuk pengukuran tertentu menggunakan metode ekstensi .WithSettingData.CustomData("<key>", <value>) (termasuk melalui atribut khusus metode MethodCustomDataAttribute ) dan untuk setiap langkah (Langkah ) pengukuran ini, ditambahkan menggunakan .Step("<step_name>") ekstensi .Step("<step_name>") , menggunakan .AddCustomData("<key>", <value>) ekstensi .AddCustomData("<key>", <value>) :


 /// <summary> /// Test GET method with simple performance watching (with steps). /// </summary> [HttpGet("SimpleStartWatchingWithSteps")] [MethodCustomData("Custom data from attribute", "Attr")] public ActionResult SimpleStartWatchingWithSteps() { using (var pm = PerformanceMeter<PerformanceMeterController> .WatchingMethod() .WithSettingData .CustomData("coins", 1) .CustomData("Coins sets", new { Gold = "Many", Silver = 5 }) .Start()) { // put your code with some logic here // add "Step 1" using (pm.Step("Step 1")) { Thread.Sleep(1000); } // add "Step 2" with custom data using (var pmStep = pm.Step("Step 2").AddCustomData("step2 custom data", "data!")) { // add "Step 3 in Step 2" using (pm.Step("Step 3 in Step 2")) { Thread.Sleep(1000); } // add custom data to "Step 2" pmStep.AddCustomData("step2 another custom data", "data2!"); // get and remove custom data from "Step 2" var customData = pmStep.GetAndRemoveCustomData<string>("step2 custom data"); // get custom data from "Step 2" (without removing) var anotherCustomData = pmStep.GetCustomData<string>("step2 another custom data"); // ... } } }

Akibatnya, saat memanggil GetPerformanceInfo kami mendapatkan:


 { "methodCalls": [ { "methodName": "SimpleStartWatchingWithSteps", "elapsed": "00:00:02.0083031", "caller": "unknown", "startTime": "2019-12-06T11:58:18.9006891Z", "endTime": "2019-12-06T11:58:20.9089922Z", "customData": { "Coins sets": { "gold": "Many", "silver": 5 }, "coins": 1, "Custom data from attribute": "Attr" }, "steps": [ { "stepName": "Step 1", "elapsed": "00:00:01.0009758", "startTime": "2019-12-06T11:58:18.9018272Z", "endTime": "2019-12-06T11:58:19.902803Z", "customData": {} }, { "stepName": "Step 3 in Step 2", "elapsed": "00:00:01.0004549", "startTime": "2019-12-06T11:58:19.9046523Z", "endTime": "2019-12-06T11:58:20.9051072Z", "customData": {} }, { "stepName": "Step 2", "elapsed": "00:00:01.0029596", "startTime": "2019-12-06T11:58:19.904534Z", "endTime": "2019-12-06T11:58:20.9074936Z", "customData": { "step2 another custom data": "data2!" } } ] } ], "totalActivity": [ { "methodName": "SimpleStartWatchingWithSteps", "callsCount": 1 } ], "currentActivity": [ { "methodName": "SimpleStartWatchingWithSteps", "callsCount": 0 } ], "uptimeSince": "2019-12-06T11:58:18.8801249Z", "className": "Unchase.FluentPerformanceMeter.TestWebAPI.Controllers.PerformanceMeterController", "methodNames": [ "SimpleStartWatchingWithSteps" ], "customData": { "Tag": "CustomTag", "Custom anonymous class": { "name": "Custom Name", "value": 1 } }, "timerFrequency": 10000000 }

Pengecualian dari pengukuran (Abaikan)


Anda dapat mengabaikan setiap bagian dari metode ini dalam mengukur kinerja (menggunakan .Ignore() atau .Executing().WithoutWatching().Start(<Action>) ), dan juga tidak menyimpan langkah individual (metode ekstensi .StepIf("<step_name>", <minSaveMs>) ) jika mereka tidak memenuhi ketentuan (waktu eksekusi langkah akan diperhitungkan dalam waktu eksekusi metode):


 using (var pm = PerformanceMeter<PerformanceMeterController>.WatchingMethod().Start()) { // put your code with some logic here // sleep 1 sec Thread.Sleep(1000); // ignore this block in performance watching using (pm.Ignore()) { Thread.Sleep(5000); } // skip this step with minSaveMs (not save, but consider duration in method performance watching) using (pm.StepIf("Skipped step", minSaveMs: 1000)) { Thread.Sleep(500); } // execute action without performance watching pm.Executing().WithoutWatching().Start(() => { Thread.Sleep(2000); }); return Ok(); }

Sebagai hasilnya, kita mendapatkan:


 { "methodCalls": [ { "methodName": "SimpleStartWatchingWithIgnored", "elapsed": "00:00:01.5080227", "caller": "unknown", "startTime": "2019-12-06T12:34:36.9187359Z", "endTime": "2019-12-06T12:34:38.4267586Z", "customData": {}, "steps": [] } ], "totalActivity": [ { "methodName": "SimpleStartWatchingWithIgnored", "callsCount": 1 } ], "currentActivity": [ { "methodName": "SimpleStartWatchingWithIgnored", "callsCount": 0 } ], "uptimeSince": "2019-12-06T12:34:36.9035129Z", "className": "Unchase.FluentPerformanceMeter.TestWebAPI.Controllers.PerformanceMeterController", "methodNames": [ "SimpleStartWatchingWithIgnored" ], "customData": { }, "timerFrequency": 10000000 }

Menambahkan Perintah dan Tindakan


Untuk menambahkan perintah yang akan dijamin akan dieksekusi setelah selesai mengukur kinerja metode, perlu untuk membuat kelas perintah yang akan mengimplementasikan antarmuka IPerformanceCommand .
Pada saat yang sama, Anda dapat mentransfer data sewenang-wenang melalui konstruktor dari perintah yang dibuat yang akan digunakan selama eksekusi. Sebagai contoh:


 /// <summary> /// Custom executed command. /// </summary> public class ExecutedCommand : IPerformanceCommand { /// <summary> /// Executed commad name. /// </summary> public string CommandName => this.GetType().Name; private string _customString { get; } internal bool IsCommandExecuted { get; private set; } /// <summary> /// Constructor. /// </summary> /// <remarks> /// You can pass any data through the command constructor. /// </remarks> /// <param name="customString"></param> public ExecutedCommand(string customString) { this._customString = customString; } /// <summary> /// Execute command. /// </summary> /// <param name="performanceInfo"><see cref="IPerformanceInfo"/>.</param> public void Execute(IPerformanceInfo performanceInfo) { // for example, write to the debug console some information Debug.WriteLine(this.CommandName); Debug.WriteLine(this._customString); Debug.WriteLine($"Method names count: {performanceInfo.MethodNames.Count}"); this.IsCommandExecuted = true; } }

Anda bisa menambahkan perintah (IPerformanceCommand) dan tindakan (Aksi) sehingga dijalankan di akhir pengukuran, dengan cara berikut:


 // custom "ExecutedCommand" will be executed after performance watching is completed using (PerformanceMeter<PerformanceMeterController> .WatchingMethod() .WithExecutingOnComplete .Command(new ExecutedCommand("bla-bla-bla")) .Action((pi) => { Debug.WriteLine($"Class name: {pi.ClassName}"); }) .Start()) { return Ok(); }

Akibatnya, pada akhir pengukuran kinerja metode di Debug- konsol, itu akan menampilkan:


 ExecutedCommand bla-bla-bla Method names count: 13 Class name: Unchase.FluentPerformanceMeter.TestWebAPI.Controllers.PerformanceMeterController

Menambahkan Penangan Pengecualian


Jika Anda perlu menangani pengecualian yang mungkin terjadi selama pelaksanaan bagian dari metode yang kinerjanya dipantau, Anda perlu menambahkan penangan pengecualian sebagai berikut:


 using (var pm = PerformanceMeter<PerformanceMeterController>.StartWatching()) { // execute action throws Exception with exception handler pm.Executing() .WithExceptionHandler((ex) => Debug.WriteLine(ex.Message)) .Start(() => throw new Exception("Exception")); // execute action throws custom Exception with exception handler pm.Executing<CustomException>() .WithExceptionHandler((ex) => { Debug.WriteLine(ex.Message); }) .Start(() => { throw new CustomException("Custom exception was occured!"); }); return Ok(); }

Di mana kelas CustomException , misalnya:


 /// <summary> /// Custom exception. /// </summary> public class CustomException : Exception { public CustomException(string message) : base(message) { } public CustomException(string message, Exception innerException) : base(message, innerException) { } public CustomException() { } }

Akibatnya, konsol Debug akan menampilkan:


 Exception Custom exception was occured!

Selain itu, Anda dapat menentukan penangan pengecualian yang akan digunakan secara default untuk mengukur kinerja metode apa pun dari kelas ini, misalnya, melalui konstruktor statis dari kelas pengontrol PerformanceMeterController :


 [ApiController] [Route("api/v1/[controller]")] public class PerformanceMeterController : ControllerBase { /// <summary> /// Static constructor. /// </summary> static PerformanceMeterController() { // set default exception handler for PerformanceMeterController class PerformanceMeter<PerformanceMeterController>.SetDefaultExceptionHandler((ex) => Debug.WriteLine(ex.Message)); } // ... actions }

Mengatur waktu penyimpanan data (Setel Waktu Cache)


Anda dapat mengatur waktu penyimpanan untuk data pengukuran kinerja metode, setelah itu data ini akan dihapus. Untuk setiap kelas yang pengukurannya dilakukan, waktu ini diatur secara terpisah. Misalnya, waktu dapat diatur melalui konstruktor statis dari kelas controller PerformanceMeterController :


 [ApiController] [Route("api/v1/[controller]")] public class PerformanceMeterController : ControllerBase { /// <summary> /// Static constructor. /// </summary> static PerformanceMeterController() { // set cache time for PerformanceMeterController class PerformanceMeter<PerformanceMeterController>.SetMethodCallsCacheTime(5); } // ... actions }

Menambahkan data tentang metode panggilan dan tempat panggilan (dan mengganggu pengukuran kinerja)


  • Anda dapat menentukan siapa yang memanggil metode menggunakan metode ekstensi .CallerFrom("<caller_name>") (baik string atau IHttpContextAccessor diteruskan ke sana ) atau atribut khusus dari metode [MethodCaller("<caller_name>")] . Selain itu, jika atribut dan metode ekstensi digunakan, maka nilainya akan diambil dari yang terakhir.


  • Metode ekstensi .WithSettingData.CallerSourceData() digunakan untuk menambahkan titik panggilan untuk mengukur kinerja.


  • Untuk berhenti mengukur kinerja di dalam blok using , gunakan metode ekstensi .StopWatching() atau metode Dispose() langsung:



 [HttpPost("StartWatchingWithCallerName")] [MethodCaller("testCaller")] public ActionResult<string> StartWatchingWithCallerName([FromBody] string value) { // method performance info will reach with caller name (if internal HttpContextAccessor is null) using (var pm = PerformanceMeter<PerformanceMeterController> .WatchingMethod() .WithSettingData .CallerSourceData() .CallerFrom("Test caller") .Start()) { pm.StopWatching(); // stop watching here (or you can use "pm.Dispose();") Thread.Sleep(2000); return Ok(value); } }

Sebagai hasil dari memanggil metode GetPerformanceInfo , GetPerformanceInfo mendapatkan:


 { "methodCalls": [ { "methodName": "StartWatchingWithCallerName", "elapsed": "00:00:00.0019172", "caller": "Test caller", "startTime": "2019-12-06T13:35:45.3164507Z", "endTime": "2019-12-06T13:35:45.3183679Z", "customData": { "customData123": 123, "callerSourceLineNumber": 525, "callerSource": "D:\\GitHub\\Unchase.FluentPerformanceMeter\\Unchase.FluentPerformanceMeter.TestWebAPI\\Controllers\\PerformanceMeterController.cs" }, "steps": [] } ], "totalActivity": [ { "methodName": "StartWatchingWithCallerName", "callsCount": 1 } ], "currentActivity": [ { "methodName": "StartWatchingWithCallerName", "callsCount": 0 } ], "uptimeSince": "2019-12-06T13:35:45.2601668Z", "className": "Unchase.FluentPerformanceMeter.TestWebAPI.Controllers.PerformanceMeterController", "methodNames": [ "StartWatchingWithCallerName" ], "customData": { }, "timerFrequency": 10000000 }

Kesimpulan


Dengan demikian, solusi yang disajikan memungkinkan kami untuk mengotomatisasi sebagian pengumpulan informasi tentang kinerja metode aplikasi .NET dengan cara yang lebih nyaman. Data yang dikumpulkan dapat divisualisasikan dengan cara yang lebih cocok untuk setiap pengembang spesifik.


Tentu saja, perpustakaan tidak menyelesaikan semua masalah yang terkait dengan pengumpulan data tentang kinerja metode, tetapi berusaha untuk menyederhanakan yang paling umum.


Perpustakaan adalah solusi open-source, setiap saran dan saran untuk pengembangannya hanya diterima, demikian juga laporan bug (semua orang dapat mengikuti tautan ; penulis akan berterima kasih atas bantuan apa pun!).

Source: https://habr.com/ru/post/id485198/

More articles:


All Articles