👨‍👧‍👦 👇🏾 ⏰ .NET अनुप्रयोग विधियों के प्रदर्शन को मापने का एक और तरीका है 🚶🏾 🏇🏾 👙

अक्सर, अपनी अड़चनों को पहचानने के लिए और वास्तविक समय में आवेदन के तरीकों के प्रदर्शन पर आँकड़े एकत्र करना आवश्यक होता है (जब आवेदन पहले से ही चल रहा है)।

इसके अलावा, कॉल के संदर्भ को बचाने के लिए अच्छा होगा जिसमें प्रदर्शन को ट्रैक किया जाता है (जैसे कि डेवलपर को कॉल करने के लिए तर्क और मनमाने ढंग से डेटा डेवलपर द्वारा जोड़ा जाता है), प्रदर्शन डेटा के अलावा (विधि विकास समय, इसके कॉल की शुरुआत और समाप्ति की तारीख)।

खैर, "केक पर चेरी" का उपयोग किए जाने वाले उपकरण की सुविधा और सादगी पर विचार किया जा सकता है, जो महत्वपूर्ण भी है।

इन समस्याओं को हल करने के लिए, एक क्रॉस-प्लेटफॉर्म ओपन-सोर्स .NET लाइब्रेरी Unchase.FluentPerformanceMeter विकसित किया गया था ।

परिचय

इसलिए, यह लेख Unchase धाराप्रवाह प्रदर्शन मीटर के साथ काम करने का विवरण है, एक क्रॉस-प्लेटफ़ॉर्म ओपन-सोर्स .net Standard 2.0 लाइब्रेरी जो विधियों के प्रदर्शन की गणना करने के लिए डिज़ाइन किया गया है।

पुस्तकालय का उपयोग .NET कोर और .NET फ्रेमवर्क अनुप्रयोगों में किया जा सकता है जो .Net मानक 2.0 का समर्थन करते हैं, और अनुमति देते हैं:

अपने कोड और उपयोग किए गए पुस्तकालयों के सार्वजनिक वर्गों के लिए सार्वजनिक तरीकों के प्रदर्शन का सटीक माप करें (माप की शुरुआत और समाप्ति का सही समय फिक्स करने के साथ);
माप परिणामों में अतिरिक्त डेटा (कस्टम डेटा) जोड़ें । उदाहरण के लिए, विधि और परिणाम के इनपुट मापदंडों के मूल्य; या विधि निष्पादन संदर्भ डेटा; या corellationId , जिसके द्वारा तरीकों के प्रदर्शन के कई मापों को जोड़ना संभव होगा;
प्रत्येक चरण के लिए स्वयं के डेटा को ठीक करने के साथ अलग-अलग चरणों (चरणों) में विधि प्रदर्शन माप को तोड़ें । इसके अलावा, आप न्यूनतम रनटाइम सेट कर सकते हैं, जिसमें से कदम को माप में ध्यान में रखा जाएगा (यदि कदम तेजी से पूरा हो गया है, तो इसे मापा नहीं जाएगा);
प्रदर्शन को मापने से कोड के अलग-अलग हिस्सों को छोड़ दें (उदाहरण के लिए, व्यक्तिगत विधियों को कॉल करें जिनके निष्पादन के समय को मापने के बाद ध्यान में रखने की आवश्यकता नहीं है);
अपने स्वयं के कमांड (कमांड) जोड़ें , जो विधि प्रदर्शन माप के अंत के तुरंत बाद निष्पादित होने की गारंटी है (उदाहरण के लिए, प्राप्त परिणामों के अतिरिक्त प्रसंस्करण को जोड़ने के लिए, जैसे लॉगिंग या स्टोरेज के लिए डेटा लिखना);
विधि के प्रदर्शन को मापने के संदर्भ में निष्पादित कोड के लिए अपना स्वयं का अपवाद हैंडलर जोड़ें (सभी मापों के लिए दोनों सामान्य है, और प्रत्येक माप के लिए अलग से);
तरीकों की उत्पादकता के माप के परिणामों को संग्रहीत करने के लिए समय निर्धारित करें , जिसके बाद परिणाम हटा दिए जाएंगे;
माप परिणामों के लिए कोड में IHttpContextAccesor या कॉलर के कार्य के माध्यम से कॉल करने वाले के बारे में डेटा जोड़ें (उदाहरण के लिए, आप उस बाहरी सेवा का नाम निर्दिष्ट कर सकते हैं जिसे विधि कहा जाता है);
उस स्थान पर माप परिणाम डेटा में जोड़ें जहां प्रदर्शन माप शुरू किया गया था (कोड में कॉल स्थान के साथ फ़ाइल नाम और लाइन नंबर);
निष्पादन के अंत से पहले विधि के प्रदर्शन के माप को बाधित करने के लिए ।

विधियों के प्रदर्शन को मापने के परिणामस्वरूप प्राप्त डेटा का उपयोग अनुप्रयोग के प्रदर्शन (इसके व्यक्तिगत भागों, दोनों आंतरिक - देशी कोड, और बाहरी - उपयोग किए गए पुस्तकालयों के कोड) के विश्लेषण के लिए किया जा सकता है और आपके लिए सुविधाजनक चित्रमय रूप में प्रदर्शित किया जा सकता है।

सामग्री

शुरुआत हो रही है

पुस्तकालय का उपयोग करने के लिए, अपनी परियोजना में NuGet पैकेज स्थापित करें:

मैन्युअल रूप से NuGet पैकेज मैनेजर का उपयोग करना:

Install-Package Unchase.FluentPerformanceMeter

.NET CLI का उपयोग करना:

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

जहां {संस्करण} उस पैकेज का संस्करण है जिसे आप इंस्टॉल करना चाहते हैं।
उदाहरण के लिए, dotnet add package Unchase.FluentPerformanceMeter --version 1.0.0

उपयोग के उदाहरण

विधि प्रदर्शन मापन

SimpleWatchingMethodStart कंट्रोलर (कंट्रोलर) PerformanceMeterController SimpleWatchingMethodStart Core 2.2 WebAPI एप्लिकेशन के प्रदर्शन (क्रिया) SimpleWatchingMethodStart प्रदर्शन को मापने के लिए लाइब्रेरी (कॉन्फ़िगरेशन और अतिरिक्त सेटिंग्स के बिना) का उपयोग करने का एक सरल उदाहरण है। ऐसा करने के लिए, आप विस्तार विधि का उपयोग कर सकते हैं .WatchingMethod().Start() या एक समान कार्यक्षमता .StartWatching() ।
.WatchingMethod().Start(SimpleWatchingMethodStart) बाद से, आप .WatchingMethod().Start(SimpleWatchingMethodStart) उपयोग कर सकते हैं .WatchingMethod().Start(SimpleWatchingMethodStart) या .StartWatching(SimpleWatchingMethodStart) विधि नाम के साथ करें।

पुस्तकालय का उपयोग करने के सभी उदाहरण Unchase.FluentPerformanceMeter.Test* में इस रिपॉजिटरी के प्रोजेक्ट्स में Unchase.FluentPerformanceMeter.Test* जा सकते हैं।

 /// <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(); } }

PerformanceMeterController नियंत्रक वर्ग के सार्वजनिक तरीकों के प्रदर्शन माप के परिणाम प्राप्त करने के लिए, आप निम्न विधि को कॉल कर सकते हैं:

 /// <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); }

SimpleWatchingMethodStart कॉल करते समय SimpleWatchingMethodStart विधि को कॉल करने के बाद:

 { "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 }

`DiagnosticSource` का उपयोग करते हुए विधि प्रदर्शन माप

संस्करण v1.1.0 के साथ शुरू करना, DiagnosticSource और विशेष WatchingWithDiagnosticSourceAttribute विशेषता का उपयोग करके AspNetCore MVC अनुप्रयोग में विधियों के प्रदर्शन को मापना संभव हो गया।
ऐसा करने के लिए, NuGet प्रोजेक्ट में Unchase.FluentPerformanceMeter.AspNetCore.Mvc पैकेज जोड़ें और निम्न कोड 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(); }

फिर विशेषता WatchingWithDiagnosticSourceAttribute या अलग-अलग तरीकों से चिह्नित करें:

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

या पूरी कक्षा:

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

संस्करण v1.2.0 से शुरू होकर, AddMethodArgumentsToCustomDataAttribute विशेषता के साथ संयोजन के रूप में विशेष AddMethodArgumentsToCustomDataAttribute विशेषता का उपयोग करके AspNetCore MVC अनुप्रयोग में उपयोगकर्ता विधि प्रदर्शन माप डेटा के लिए आह्वान तर्क जोड़ना संभव हो गया।

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

SimpleWatchingMethodStartWithArgs कॉल करने पर SimpleWatchingMethodStartWithArgs पद्धति पर कॉल करने के बाद:

 { "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 }

पुस्तकालय द्वारा उपयोग की जाने वाली विधि के प्रदर्शन को मापना

सार्वजनिक रूप से उपयोग की जाने वाली तृतीय-पक्ष लाइब्रेरी की सार्वजनिक विधि के प्रदर्शन को मापने के लिए, आपको स्पष्ट रूप से कक्षा और उसकी विधि का नाम निर्धारित करना होगा:

 [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); }

निष्पादित विधि वापस आ जाएगी:

 "00:00:01.0033040"

आप कॉल के माध्यम से इस विधि को कॉल करने के बारे में डेटा प्राप्त कर सकते हैं:

 /// <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); }

IgnoreMethodPerformance विशेषता IgnoreMethodPerformance डिज़ाइन किया गया है ताकि प्रदर्शन को मापते समय जिस विधि को IgnoreMethodPerformance किया गया है, उस पर ध्यान न दिया जाए।

इस पद्धति के लिए कॉल के जवाब में होगा:

 { "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 }

अतिरिक्त डेटा (कस्टम डेटा) और पृष्ठांकन (चरण) जोड़ना

आप किसी विशेष वर्ग के तरीकों के सभी प्रदर्शन मापों के लिए अतिरिक्त डेटा (कस्टम डेटा) जोड़ सकते हैं। उदाहरण के लिए, 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 }

इसके अलावा, आप एक्सटेंशन पद्धति का उपयोग करके एक विशिष्ट माप के लिए अतिरिक्त डेटा (कस्टम डेटा) जोड़ सकते हैं। .WithSettingData.CustomData("<key>", <value>) ( MethodCustomDataAttribute विधि की एक विशेष विशेषता सहित) और प्रत्येक चरण के लिए (चरण) इस माप का), .Step("<step_name>") एक्सटेंशन .Step("<step_name>") , .AddCustomData("<key>", <value>) एक्सटेंशन .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"); // ... } } }

परिणामस्वरूप, GetPerformanceInfo कॉल करते GetPerformanceInfo हम प्राप्त करते हैं:

 { "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 }

माप से अपवाद (उपेक्षा)

आप प्रदर्शन को मापने के तरीके ( .Ignore() या .Executing().WithoutWatching().Start(<Action>) ) को मापने के लिए अलग-अलग हिस्सों को अनदेखा कर सकते हैं, और अलग-अलग चरणों (एक्सटेंशन विधि .StepIf("<step_name>", <minSaveMs>) ) को भी नहीं बचा .StepIf("<step_name>", <minSaveMs>) ) अगर वे शर्त को पूरा नहीं करते हैं (विधि निष्पादन समय में कदम निष्पादन समय को ध्यान में रखा जाएगा):

 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(); }

नतीजतन, हम प्राप्त करते हैं:

 { "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 }

कमांड और क्रियाएँ जोड़ना

एक कमांड जोड़ने के लिए जिसे किसी विधि के प्रदर्शन को मापने के पूरा होने पर निष्पादित करने की गारंटी दी जाएगी, आपको एक कमांड क्लास बनाना होगा जो IPerformanceCommand इंटरफ़ेस को लागू करेगा।
उसी समय, आप निर्मित कमांड के निर्माता के माध्यम से मनमाना डेटा स्थानांतरित कर सकते हैं जो इसके निष्पादन के दौरान उपयोग किया जाएगा। उदाहरण के लिए:

 /// <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; } }

आप एक कमांड (IPerformanceCommand) और एक एक्शन (एक्शन) जोड़ सकते हैं ताकि वे माप के अंत में निष्पादित हों, निम्नलिखित तरीके से:

 // 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(); }

परिणामस्वरूप, डिबग- कंसोल में विधि के प्रदर्शन को मापने के अंत में, यह प्रदर्शित करेगा:

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

अपवाद हैंडलर जोड़ना

यदि आपको अपवादों को संभालने की आवश्यकता होती है, जो उस विधि के एक हिस्से के निष्पादन के दौरान हो सकता है जिसके लिए प्रदर्शन की निगरानी की जाती है, तो आपको निम्न के रूप में अपवाद हैंडलर जोड़ने की आवश्यकता है:

 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(); }

उदाहरण के लिए, CustomException वर्ग कहाँ है:

 /// <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() { } }

परिणामस्वरूप, डिबग कंसोल प्रदर्शित होगा:

 Exception Custom exception was occured!

इसके अलावा, आप एक अपवाद हैंडलर निर्दिष्ट कर सकते हैं जिसका उपयोग डिफ़ॉल्ट रूप से इस वर्ग की किसी भी विधि के प्रदर्शन को मापने के लिए किया जाएगा, उदाहरण के लिए, 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 }

डेटा संग्रहण समय सेट करना (कैश समय सेट करें)

आप तरीकों के प्रदर्शन माप के डेटा के लिए भंडारण समय निर्धारित कर सकते हैं, जिसके बाद यह डेटा हटा दिया जाएगा। प्रत्येक वर्ग के लिए जिसके लिए माप किया जाता है, यह समय अलग से निर्धारित किया जाता है। उदाहरण के लिए, टाइम को 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 }

कॉलिंग विधि और कॉल की जगह के बारे में डेटा जोड़ना (और प्रदर्शन की माप को बाधित करना)

आप निर्दिष्ट कर सकते हैं कि एक्सटेंशन विधि का उपयोग करके कौन कॉल कर रहा है। .CallerFrom("<caller_name>") (या तो एक स्ट्रिंग या IHttpContextAccessor इसे पास कर दिया गया है ) या विधि की एक विशेष विशेषता है - [MethodCaller("<caller_name>")] । इसके अलावा, यदि विशेषता और विस्तार विधि दोनों का उपयोग किया जाता है, तो मूल्य उत्तरार्द्ध से लिया जाएगा।
प्रदर्शन विधि .WithSettingData.CallerSourceData() उपयोग प्रदर्शन को मापने के लिए कॉल बिंदु जोड़ने के लिए किया जाता है।
using ब्लॉक के अंदर प्रदर्शन को मापने से रोकने के लिए, .StopWatching() एक्सटेंशन विधि या .StopWatching() Dispose() विधि का सीधे उपयोग करें:

 [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); } }

GetPerformanceInfo पद्धति को कॉल करने के GetPerformanceInfo , GetPerformanceInfo मिलेगा:

 { "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 }

निष्कर्ष

इस प्रकार, प्रस्तुत समाधान हमें एक सुविधाजनक तरीके से .NET आवेदन विधियों के प्रदर्शन के बारे में जानकारी के संग्रह को आंशिक रूप से स्वचालित करने की अनुमति देता है। एकत्रित डेटा को इस तरह से देखा जा सकता है जो प्रत्येक विशिष्ट डेवलपर के लिए अधिक उपयुक्त हो।

बेशक, पुस्तकालय तरीकों के प्रदर्शन पर डेटा एकत्र करने से जुड़ी सभी समस्याओं को हल नहीं करता है, लेकिन सबसे आम लोगों को सरल बनाने का प्रयास करता है।

पुस्तकालय एक ओपन-सोर्स समाधान है, इसके विकास के लिए कोई भी सुझाव और सुझाव केवल स्वागत योग्य हैं, जैसे बग-रिपोर्ट (हर कोई लिंक का अनुसरण कर सकता है, लेखक किसी भी मदद के लिए आभारी होगा!)।

.NET अनुप्रयोग विधियों के प्रदर्शन को मापने का एक और तरीका है