C # कोड को मापने के लिए सुविधाजनक उपकरण

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

कोड अनुभागों के निष्पादन समय को मापने के लिए आप StopWatch वर्ग का उपयोग कर सकते हैं।

कुछ इस तरह:

var sw = new Stopwatch(); sw.Start(); //   sw.Stop(); Console.WriteLine(sw.Elapsed); //   

हर बार कोड द्वारा स्टॉपवॉच को न लगाने के लिए, आप एक उच्च-क्रम फ़ंक्शन के माध्यम से माप प्रक्रिया को एकीकृत कर सकते हैं, उदाहरण के लिए, जैसे:

 static void LambdaMeter(string label, Action act) { var sw = new Stopwatch(); sw.Start(); act(); sw.Stop(); Console.WriteLine($"{label} : {sw.Elapsed}"); //   } 

और इस तरह से उपयोग करें:

 LambdaMeter("foo", () => { // TODO something }); 

आप एक्सटेंशन के माध्यम से कॉल को अंदर बाहर कर सकते हैं:

 public static class TimeInspector { public static void Meter(this Action act, string label) { var sw = new Stopwatch(); sw.Start(); act(); sw.Stop(); Console.WriteLine($"{label} : {sw.Elapsed}"); //   } } 

और इस तरह का उपयोग करें:

 new Action(() => { // TODO something }).Meter("foo"); 

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

C # में एक प्रसिद्ध और उपयोगी स्टेटमेंट का उपयोग किया गया है, यह उन प्रकारों पर लागू होता है, जो आईडीसोपायरी इंटरफ़ेस का समर्थन करते हैं। बिंदु यह है कि जब आप ऑपरेटर ब्लॉक से बाहर निकलते हैं, तो डिस्पोज़ विधि को कॉल करें, जिसमें, एक नियम के रूप में, संसाधन जारी किए जाते हैं। हालांकि, इस तंत्र का उपयोग विभिन्न उद्देश्यों के लिए किया जा सकता है। हमारे मामले में, यह ब्लॉक के निष्पादन समय का एक माप होगा, इसके बाद विश्लेषण के लिए परिणाम को बचाया जाएगा। विचार यह है कि वर्ग का एक उदाहरण प्रयोग ब्लॉक में बनाया गया है, निर्माण के समय, विभिन्न प्रकार की उपयोगी जानकारी एकत्र की जाती है और स्टॉपवॉच शुरू होता है। जब ब्लॉक से बाहर निकलने पर डिस्पोज़ निष्पादित होता है, तो परिणाम तय हो जाता है और लॉग को सहेजने के लिए ऑब्जेक्ट भेजा जाता है।

उपयोग करने वाला कथन वाक्यगत शर्करा है; जब संकलित किया जाता है, तो यह एक कोशिश-अंतिम ब्लॉक में बदल जाता है।

उदाहरण के लिए, कोड:

 using(var obj = new SomeDisposableClass()) { // TODO something } 

एक दृश्य डिजाइन में परिवर्तित:

 IDisposable obj = new SomeDisposableClass(); try { // TODO something } finally { if (obj != null) { obj.Dispose(); } } 

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

 public class Meter :IDisposable { private Stopwatch _sw; private string _label; public static Meter Job(string lable) { return new Meter(lable); } Meter(string label) { _label = label; _sw = Stopwatch.StartNew(); } public void Dispose() { _sw.Stop(); Console.WriteLine($"{_label} : {_sw.Elapsed}"); //   } } 

और इसलिए, यह हमें क्या देता है?

 //       return static int Case0() { using (Meter.Job("case-0")) { return 1; } return 2; } //     yield return static IEnumerable<string> Case1() { yield return "one"; using (Meter.Job("case-1")) { yield return "two"; yield return "three"; } yield return "four"; } //     break static void Case2() { while (true) { using (Meter.Job("case-2")) { // todo something break; } } } //    switch    static int Case3(int @case) { using (Meter.Job("case-3")) { switch (@case) { case 1: using (Meter.Job($"case-3-{@case}")) { // todo something break; } case 2: using (Meter.Job($"case-3-{@case}")) { // todo something return @case; } } return @case; } } //       static void Case4() { try { using (Meter.Job($"case-4")) { // todo something throw new Exception(); } } catch (Exception e) { Console.WriteLine(e); } } 

वर्णित तकनीक में क्या गायब है? परिणाम को सुरक्षित करने के विषय का पूरी तरह से खुलासा नहीं किया गया था, यह स्पष्ट है कि परिणाम को सांत्वना में दर्ज करने में बहुत समझदारी नहीं है। ज्यादातर मामलों में, विज़ुअलाइज़ेशन बन्स और मिनिमम कॉमिक्स के साथ लोकप्रिय लोकप्रिय उपकरण NLog, Log4Net, Serilog का उपयोग करना काफी संभव है। विशेष रूप से गंभीर मामलों में, अधिक परिष्कृत विश्लेषिकी के लिए यह पता लगाने की आवश्यकता हो सकती है कि क्या होता है।

आप परिणाम को एक साधारण पाठ फ़ाइल में संग्रहीत कर सकते हैं, लेकिन इस कार्य के लिए मुझे लगता है कि यह एक बहुत ही सुविधाजनक समाधान नहीं है, क्योंकि कोड के कई टुकड़े हो सकते हैं, और वे संभवत: नेस्टेड हो सकते हैं, इसके अलावा, कई समानांतर धागे। इसलिए, लॉग को नेविगेट करने की सुविधा के लिए, हम SQLite डेटाबेस का उपयोग करते हैं।

हम एक वर्ग को परिभाषित करने से शुरू करते हैं जो समय को मापने और बाद के विश्लेषण के लिए अतिरिक्त उपयोगी जानकारी पर कब्जा करने के लिए जिम्मेदार है।

 public class LogItem : IDisposable { public string Id; // Log item unique id public string Label; // User text labl public string Lid; // Log Id public string Method; // Method name public int Tid; // Thread Id public DateTime CallTime; // Start time public TimeSpan Elapsed; // Metering public long ElapsedMs; // Metering miliseconds public long ElapsedTicks; // Metering ticks private Stopwatch _sw; private Logger _cl; public LogItem(Logger cl, string method, string label) { Id = Guid.NewGuid().ToString("N"); _cl = cl; Lid = _cl.LId; Label = label; Method = method; Tid = Thread.CurrentThread.ManagedThreadId; CallTime = DateTime.Now; _sw = new Stopwatch(); _sw.Start(); } public void Dispose() { _sw.Stop(); Elapsed = _sw.Elapsed; ElapsedMs = _sw.ElapsedMilliseconds; ElapsedTicks = _sw.ElapsedTicks; _cl.WriteLog(this); } } 

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

लकड़हारे के पास अनिवार्य रूप से दो मुख्य कार्य होते हैं: एक LogItem ऑब्जेक्ट आरंभ करना और माप पूरा होने के बाद परिणाम रिकॉर्ड करना। चूँकि मुझे अभी भी परिणाम न केवल SQLite में, बल्कि SQLite के अलावा विभिन्न स्वरूपों या डेटाबेसों की पाठ फ़ाइलों में भी दर्ज करने की आवश्यकता है, इंटरैक्शन लॉजिक को एक अलग वर्ग में रखा गया है। लकड़हारा वर्ग में, केवल सामान्य हिस्सा बचा है।

 public class Logger { public string LId; // Log id public string Login; // User login public int Pid; // Process Id public string App; // Application name public string Host; // Host name public string Ip; // Ip address private ConcurrentQueue<dynamic> queue; // Queue log items to save public Dictionary<Type, Action<dynamic>> LogDispatcher; // Different log objects handlers dispatcher public bool IsEnabled = true; public Logger(Dictionary<Type, Action<dynamic>> logDispatcher) { queue = new ConcurrentQueue<dynamic>(); LogDispatcher = logDispatcher; LId = Guid.NewGuid().ToString("N"); Login = WindowsIdentity.GetCurrent().Name; Host = Dns.GetHostName(); Ip = Dns.GetHostEntry(Host).AddressList.FirstOrDefault(f => f.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)?.ToString(); var proc = Process.GetCurrentProcess(); Pid = proc.Id; App = proc.ProcessName; queue.Enqueue(this); // Save the starting of a new measurement new Thread(() => { // Dequeue and save loop dynamic logItem; while (true) { if (queue.TryDequeue(out logItem)) { var logT = logItem.GetType(); if (LogDispatcher.ContainsKey(logT)) { LogDispatcher[logT](logItem); } } else { Thread.Sleep(500); } }}) { IsBackground = true}.Start(); } public LogItem Watch(int level, string label = null) { return new LogItem(this, GetMethodFullName(level), label); } private static string GetMethodFullName(int level) { var t = new StackTrace().GetFrames()?[level].GetMethod(); if (t == null) return ""; var path = t.ReflectedType != null ? t.ReflectedType.FullName : "_"; return $"{path}.{t.Name}"; } public void WriteLog(LogItem li) { if (IsEnabled) { queue.Enqueue(li); } } } 

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

लॉगिंग वर्ग के लिए, जो नीचे दिया जाएगा, नगेट पैकेज System.Data / SQLite को स्थापित करके निर्भरता को संतुष्ट करना आवश्यक है।

  public class SqliteLogger { private readonly HLTimeCall.Logger _iternalLogger; protected string _connectionString; static object dbLocker = new object(); public SqliteLogger() { InitDb(); var dispatcher = new Dictionary<Type, Action<dynamic>>(); dispatcher[typeof(HLTimeCall.Logger)] = o => LogMainRecord(o); dispatcher[typeof(HLTimeCall.LogItem)] = o => LogCall(o); _iternalLogger = new HLTimeCall.Logger(dispatcher); } private void InitDb() { const string databaseFile = "TimeCallLogs.db"; _connectionString = $"Data Source = {Path.GetFullPath(databaseFile)};"; var dbFileName = Path.GetFullPath(databaseFile); if (!File.Exists(dbFileName)) { SQLiteConnection.CreateFile(dbFileName); Bootstrap(); } } struct DbNames { public const string TMainRecord = "T_MAINRECORD"; public const string TCalllog = "T_CALLLOG"; public const string FLid = "LID"; public const string FLogin = "LOGIN"; public const string FPid = "PID"; public const string FApp = "APP"; public const string FHost = "HOST"; public const string FIp = "IP"; public const string FId = "ID"; public const string FLabel = "LABEL"; public const string FMethod = "METHOD"; public const string FTid = "TID"; public const string FCallTime = "CALL_TIME"; public const string FElapsed = "ELAPSED"; public const string FElapsedMs = "ELAPSED_MS"; public const string FElapsedTicks = "ELAPSED_TICKS"; } public void Bootstrap() { lock (dbLocker) { using (var conn = Connect()) { using (var cmd = conn.CreateCommand()) { cmd.Transaction = conn.BeginTransaction(); cmd.CommandType = System.Data.CommandType.Text; cmd.CommandText = $"CREATE TABLE {DbNames.TMainRecord} ({DbNames.FLid} VARCHAR(45) PRIMARY KEY UNIQUE NOT NULL, {DbNames.FLogin} VARCHAR(45), {DbNames.FPid} INTEGER, {DbNames.FApp} VARCHAR(45), {DbNames.FHost} VARCHAR(45), {DbNames.FIp} VARCHAR(45))"; cmd.ExecuteNonQuery(); cmd.CommandText = $"CREATE TABLE {DbNames.TCalllog} ({DbNames.FId} VARCHAR(45) PRIMARY KEY UNIQUE NOT NULL, {DbNames.FLabel} VARCHAR(45), {DbNames.FLid} VARCHAR(45) NOT NULL, {DbNames.FMethod} VARCHAR(150), {DbNames.FTid} VARCHAR(45), {DbNames.FCallTime} DATETIME, {DbNames.FElapsed} TIME, {DbNames.FElapsedMs} INTEGER, {DbNames.FElapsedTicks} INTEGER)"; cmd.ExecuteNonQuery(); cmd.Transaction.Commit(); } } } } private DbConnection Connect() { var conn = new SQLiteConnection(_connectionString); conn.Open(); return conn; } public HLTimeCall.LogItem Watch(string label = null) { return _iternalLogger.Watch(3, label); } static object CreateParameter(string key, object value) { return new SQLiteParameter(key, value ?? DBNull.Value); } private void LogMainRecord(HLTimeCall.Logger logItem) { lock (dbLocker) { using (var conn = Connect()) { using (var cmd = conn.CreateCommand()) { cmd.Transaction = conn.BeginTransaction(); cmd.CommandType = System.Data.CommandType.Text; cmd.Parameters.Add(CreateParameter(DbNames.FLid, logItem.LId)); cmd.Parameters.Add(CreateParameter(DbNames.FLogin, logItem.Login)); cmd.Parameters.Add(CreateParameter(DbNames.FPid, logItem.Pid)); cmd.Parameters.Add(CreateParameter(DbNames.FApp, logItem.App)); cmd.Parameters.Add(CreateParameter(DbNames.FHost, logItem.Host)); cmd.Parameters.Add(CreateParameter(DbNames.FIp, logItem.Ip)); cmd.CommandText = $"INSERT INTO {DbNames.TMainRecord}({DbNames.FLid},{DbNames.FLogin},{DbNames.FPid},{DbNames.FApp},{DbNames.FHost},{DbNames.FIp})VALUES(:{DbNames.FLid},:{DbNames.FLogin},:{DbNames.FPid},:{DbNames.FApp},:{DbNames.FHost},:{DbNames.FIp})"; cmd.ExecuteNonQuery(); cmd.Transaction.Commit(); } } } } private void LogCall(HLTimeCall.LogItem logItem) { lock (dbLocker) { using (var conn = Connect()) { using (var cmd = conn.CreateCommand()) { cmd.Transaction = conn.BeginTransaction(); cmd.CommandType = System.Data.CommandType.Text; cmd.Parameters.Add(CreateParameter(DbNames.FId, logItem.Id)); cmd.Parameters.Add(CreateParameter(DbNames.FLabel, logItem.Label)); cmd.Parameters.Add(CreateParameter(DbNames.FLid, logItem.Lid)); cmd.Parameters.Add(CreateParameter(DbNames.FMethod, logItem.Method)); cmd.Parameters.Add(CreateParameter(DbNames.FTid, logItem.Tid)); cmd.Parameters.Add(CreateParameter(DbNames.FCallTime, logItem.CallTime)); cmd.Parameters.Add(CreateParameter(DbNames.FElapsed, logItem.Elapsed)); cmd.Parameters.Add(CreateParameter(DbNames.FElapsedMs, logItem.ElapsedMs)); cmd.Parameters.Add(CreateParameter(DbNames.FElapsedTicks, logItem.ElapsedTicks)); cmd.CommandText = $"INSERT INTO {DbNames.TCalllog}({DbNames.FId},{DbNames.FLabel},{DbNames.FLid},{DbNames.FMethod},{DbNames.FTid},{DbNames.FCallTime},{DbNames.FElapsed},{DbNames.FElapsedMs},{DbNames.FElapsedTicks})VALUES(:{DbNames.FId},:{DbNames.FLabel},:{DbNames.FLid},:{DbNames.FMethod},:{DbNames.FTid},:{DbNames.FCallTime},:{DbNames.FElapsed},:{DbNames.FElapsedMs},:{DbNames.FElapsedTicks})"; cmd.ExecuteNonQuery(); cmd.Transaction.Commit(); } } } } } 

जैसा कि पहले ही उल्लेख किया गया है, डेटाबेस में माप परिणामों को संग्रहीत करने के लिए SqliteLogger वर्ग जिम्मेदार है। इससे पहले कि आप डेटाबेस का उपयोग करना शुरू करें, आपको इसे बनाने की आवश्यकता है, कोड की अधिक लाइनें इसके लिए समर्पित हैं। यहां वर्ग लकड़हारा बनाने के तथ्य को लॉग करेगा (यह समझा जाता है कि यह एप्लिकेशन लॉन्च के साथ एक साथ होता है), परिणाम T_MAINRECORD तालिका में सहेजा जाएगा। हम तालिका T_CALLLOG में माप परिणाम भी सहेजेंगे। LogMainRecord और LogCall तरीके इन दो घटनाओं को संग्रहीत करने के लिए जिम्मेदार हैं, उनके संदर्भ डिस्पैचर शब्दकोश में संग्रहीत हैं। LogItem ऑब्जेक्ट को सही ढंग से बनाने के लिए, आपको वॉच फ़ंक्शन का उपयोग करने वाले स्टेटमेंट के प्रारंभ ब्लॉक में उपयोग करने की आवश्यकता है।

उदाहरण के लिए, इस तरह:

 var cMeter = new SqliteLogger(); using (cMeter.Watch("   ")) { // TODO } 

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

आपका ध्यान, सौभाग्य और त्वरित कोड के लिए धन्यवाद :-)