🥒 👠 👩‍👧‍👧 इकाई फ्रेमवर्क के लिए प्रोफाइलर 🎯 👩🏾‍💼 🥌

नमस्ते!

मैं प्रोग्रामिंग के बारे में लेखों की एक श्रृंखला जारी रखूंगा। इस बार, मैं 4 वें से 6 वें संस्करण के लिए एंटिटी फ्रेमवर्क (इसके बाद ईएफ के रूप में संदर्भित) के लिए लिखे गए मुफ्त प्रोफाइल के बारे में बात करना चाहता हूं, साथ ही मैंने जो कुछ समाधान लागू किए हैं, जैसे कि मक्खी पर डिकम्पाइलिंग .NET कोड। अपवाद हैंडलिंग और अधिक।
EF6 के लिए नगेट पैकेज: https://www.nuget.org/packages/EFlogger-For6/
EF4-5 के लिए नगेट पैकेज: https://www.nuget.org/packages/EFlogger-For4/

कट के तहत विवरण।

परिचय

जब मैंने EF सीखना शुरू किया, तो मेरे मन में एक सवाल था कि EF उत्पन्न करता है या नहीं। कुछ खोज के बाद, मुझे यह पता लगाने में नाराजगी थी कि ईएफ नियमित उपकरण प्रदान नहीं करता है, इसलिए मुझे अपनी राय में, अत्यंत असुविधाजनक SQL सर्वर प्रोफाइलर प्रोग्राम का उपयोग करना था या $ 389.00 के लिए बल्कि महंगे तीसरे पक्ष के उपकरण एंटिटी फ्रेमवर्क प्रोफाइलर 2.0 का उपयोग करना था , ~~और मैं लालची हूं~~ ।

ईएफ संस्करण 6 के आगमन के साथ, कमांड लॉगिंग के साथ स्थिति बदल गई है। एक तंत्र प्रकट हुआ है जो आपको अपने स्वयं के इंटरसेप्टर को जोड़ने की अनुमति देता है:

//     IDbCommandInterceptor DbInterception.Add(new LogFormatter());

 public class LogFormatter : IDbCommandInterceptor { private readonly Stopwatch _stopwatch = new Stopwatch(); public void NonQueryExecuting(DbCommand command, DbCommandInterceptionContext<int> interceptionContext) { //   _stopwatch.Restart(); } public void NonQueryExecuted(DbCommand command, DbCommandInterceptionContext<int> interceptionContext) { //   _stopwatch.Stop(); //   Log(command, interceptionContext); } public void ReaderExecuting(DbCommand command, DbCommandInterceptionContext<DbDataReader> interceptionContext) { _stopwatch.Restart(); } public void ReaderExecuted(DbCommand command, DbCommandInterceptionContext<DbDataReader> interceptionContext) { _stopwatch.Stop(); Log(command, interceptionContext); } public void ScalarExecuting(DbCommand command, DbCommandInterceptionContext<object> interceptionContext) { _stopwatch.Restart(); } public void ScalarExecuted(DbCommand command, DbCommandInterceptionContext<object> interceptionContext) { _stopwatch.Stop(); Log(command, interceptionContext); } private void Log<TResult>(DbCommand command, DbCommandInterceptionContext<TResult> interceptionContext) { Logger.Log(command, _stopwatch.ElapsedMilliseconds, interceptionContext.Exception); } }

 public static class Logger { public static void Log(DbCommand command, long elapsedMilliseconds, Exception exception) { //   Trace  Trace.WriteLine(string.Format("Command:{0}, Elapsed Milliseconds:{1}", command.CommandText, elapsedMilliseconds)); } }

ईएफ के 4 वें संस्करण के लिए, मुझे एक समान लॉगिंग तंत्र नहीं मिला।

मेरा फैसला

मेरे प्रोफाइलर को लिखने का विचार, एक भुगतान की कार्यक्षमता को दोहराते हुए, मैं काफी समय से कर रहा हूं। प्रारंभिक संस्करण ईएफ संस्करण 6 इंटरसेप्टर तंत्र पर आधारित था, लेकिन दुर्भाग्य से ईएफ संस्करण 4 में यह तंत्र काम नहीं करता है।
एक छोटी गुगली के बाद , एएसपी एमवीसी अनुप्रयोगों में ईएफ की रूपरेखा के लिए एक महान पुस्तकालय पाया गया, जिसे मिनीप्रोफाइलर कहा जाता है। इसके आधार पर, आपका आवेदन करने का निर्णय लिया गया।

क्या हुआ?

सिस्टम उपयोग और एकीकरण के लिए जितना संभव हो उतना सरल निकला। आप Wordpress-e http://ef-logger.com/ पर मेरे द्वारा बनाई गई साइट पर एक उदाहरण परियोजना के साथ बायनेरिज़ उठा सकते हैं
EF6 के लिए नगेट पैकेज: https://www.nuget.org/packages/EFlogger-For6/
मुख्य अनुप्रयोग विंडो:

के उपयोग

1. बायनेरिज़ और एक उदाहरण परियोजना के साथ एक संग्रह उठाओ

2. पुस्तकालय EFlogger.EntityFramework4.dll को EF 4-5 संस्करणों के लिए और EFlogger.EntityFramework6.dll के लिए EF 6th संस्करण से कनेक्ट करें
3. स्थैतिक विधि को निष्पादित करके प्रोफाइलर को प्रारंभ करें

 //  EF 6-  EFloggerFor6.Initialize(); //   EF  4-  6- EFloggerFor4.Initialize();

4. EFlogger.exe एप्लिकेशन लॉन्च करें

एपीआई

EFlogger.EntityFramework6.dl लाइब्रेरी के लिए एक उदाहरण, यदि EFlogger.EntityFramework4.dl का उपयोग किया जाता है, तो स्थिर वर्ग को EFloggerFor4 कहा जाएगा।

 // EFloggerFor6.Initialize(); //  IP       "127.0.0.1" EFloggerFor6.SetProfilerClientIP(“192.168.10.50″); //      EFloggerFor6.WriteMessage(“Text message”); //     (     ) EFloggerFor6.StartSendToClient(); //     EFloggerFor6.StopSendToClient(); //     EFlogger.log  EFloggerFor6.StartSaveToLogFile(); //     EFlogger.log  EFloggerFor6.StopSaveToLogFile(); //       ,   EFloggerFor6.ClearLog(); //    EFloggerFor6.DisableDecompiling(); //       Stack Trace-a EFloggerFor6.ExcludeAssembly(“MyAssemly”);

यह सब कैसे काम करता है

ईएफ 4 वें संस्करण में कार्यान्वयन तंत्र ईएफ 6 वें संस्करण से बहुत अलग है।
EF 4 में DbProviderFactory को बदलने के लिए कोई नियमित तंत्र नहीं हैं, इसलिए आपको प्रतिबिंब के माध्यम से अपने कारखाने के साथ कारखाने को बदलने के लिए जाना होगा।
प्रक्रिया स्वयं इस तरह दिखती है:

 //      DbProviderFactories.GetFactoryClasses(); //   DbProviderFactories Type type = typeof(DbProviderFactories); DataTable table = null; //  DataSet   _configTable  _providerTable object setOrTable = (type.GetField("_configTable", BindingFlags.NonPublic | BindingFlags.Static) ?? type.GetField("_providerTable", BindingFlags.NonPublic | BindingFlags.Static)).GetValue(null); var set = setOrTable as DataSet; if (set != null) table = set.Tables["DbProviderFactories"]; table = (DataTable)setOrTable; //     DataTable    foreach (DataRow row in table.Rows.Cast<DataRow>().ToList()) { DbProviderFactory factory; try { factory = DbProviderFactories.GetFactory(row); } catch (Exception) { continue; } var profType = EFProviderUtilities.ResolveFactoryType(factory.GetType()); if (profType != null) { DataRow profiled = table.NewRow(); profiled["Name"] = row["Name"]; profiled["Description"] = row["Description"]; profiled["InvariantName"] = row["InvariantName"]; profiled["AssemblyQualifiedName"] = profType.AssemblyQualifiedName; table.Rows.Remove(row); table.Rows.Add(profiled); } }

ईएफ 6 वें संस्करण में एकीकरण के लिए, आप सेवाओं को प्रतिस्थापित करने के लिए नियमित तंत्र का उपयोग कर सकते हैं:

 DbConfiguration.Loaded += (_, a) => a.ReplaceService<DbProviderServices>((s, k) => new EFProfiledDbProviderServices());

decompilation

मक्खी पर EFlogger कोड को विघटित करता है और इस या उस अनुरोध को उत्पन्न करने वाली विधि के शरीर को प्रदर्शित करता है। इसके लिए, ILSpy परावर्तक के मुक्त एनालॉग से पुस्तकालयों का उपयोग किया जाता है । एक विधि को अपघटित करने के लिए, आपको सबसे पहले स्टैक ट्रेस पर जाकर इसे ढूंढना होगा और तृतीय-पक्ष के लिए अनावश्यक कॉल को समाप्त करना होगा:

 public static string Get(out StackFrame outStackFrame) { outStackFrame = null; var frames = new StackTrace(0, true).GetFrames(); if (frames == null) { return ""; } var methods = new List<string>(); //     foreach (StackFrame t in frames) { //   var method = t.GetMethod(); //         var assembly = method.Module.Assembly.GetName().Name; if (ShouldExcludeType(method) || AssembliesToExclude.Contains(assembly) || MethodsToExclude.Contains(method.Name)) continue; //            ,           if (outStackFrame == null) { outStackFrame = t; } methods.Add(method.DeclaringType.FullName + ":" + method.Name); } return string.Join("\r\n", methods); }

 private static string GetMethodBody(StackFrame stackFrame) { MethodBase methodBase = stackFrame.GetMethod(); return Decompiler.GetSourceCode(methodBase.Module.FullyQualifiedName, methodBase.DeclaringType.Name, methodBase.Name); }

Decompiler

 using System; using System.IO; using System.Linq; using ICSharpCode.Decompiler; using ICSharpCode.Decompiler.Ast; using ICSharpCode.Decompiler.Ast.Transforms; using Mono.Cecil; namespace Common { public static class Decompiler { public static string GetSourceCode(string pathToAssembly, string className, string methodName) { try { var assemblyDefinition = AssemblyDefinition.ReadAssembly(pathToAssembly); TypeDefinition assembleDefenition = assemblyDefinition.MainModule.Types.First(type => type.Name == className); MethodDefinition methodDefinition = assembleDefenition.Methods.First(method => method.Name == methodName); var output = new StringWriter(); var plainTextOutput = new PlainTextOutput(output); DecompileMethod(methodDefinition, plainTextOutput); return output.ToString(); } catch (Exception exception) { return string.Format( "Exception in decompling. \r\n Message:{0}, \r\n Inner Exception:{1}, \r\n StackTrace:{2}",exception.Message, exception.InnerException, exception.StackTrace); } } private static void DecompileMethod(MethodDefinition method, ITextOutput output) { AstBuilder codeDomBuilder = CreateAstBuilder(currentType: method.DeclaringType, isSingleMember: true); if (method.IsConstructor && !method.IsStatic && !method.DeclaringType.IsValueType) { AddFieldsAndCtors(codeDomBuilder, method.DeclaringType, method.IsStatic); RunTransformsAndGenerateCode(codeDomBuilder, output); } else { codeDomBuilder.AddMethod(method); RunTransformsAndGenerateCode(codeDomBuilder, output); } } private static AstBuilder CreateAstBuilder(ModuleDefinition currentModule = null, TypeDefinition currentType = null, bool isSingleMember = false) { if (currentModule == null) currentModule = currentType.Module; var settings = new DecompilerSettings(); if (isSingleMember) { settings = settings.Clone(); settings.UsingDeclarations = false; } return new AstBuilder( new DecompilerContext(currentModule) { CurrentType = currentType, Settings = settings }); } private static void AddFieldsAndCtors(AstBuilder codeDomBuilder, TypeDefinition declaringType, bool isStatic) { foreach (var field in declaringType.Fields) { if (field.IsStatic == isStatic) codeDomBuilder.AddField(field); } foreach (var ctor in declaringType.Methods) { if (ctor.IsConstructor && ctor.IsStatic == isStatic) codeDomBuilder.AddMethod(ctor); } } private static void RunTransformsAndGenerateCode(AstBuilder astBuilder, ITextOutput output, IAstTransform additionalTransform = null) { astBuilder.GenerateCode(output); } } }

यांडेक्स फ़ाइलों पर काम कर रहे अपघटन परियोजना का एक उदाहरण: yadi.sk/d/AzBGet5-wwns2

अपवाद हैंडलिंग विंडो

यह कोई रहस्य नहीं है कि एप्लिकेशन समय-समय पर दुर्घटनाग्रस्त हो जाते हैं, यह कई कारणों से हो सकता है, और डेवलपर का कार्य किसी त्रुटि संदेश के लिए किसी प्रकार की विंडो को दिखाना है।
मेरा रूप इस तरह दिखता है:

प्रपत्र उपयोगकर्ता को त्रुटि के बारे में जानकारी, पुन: पेश करने के लिए कदम और प्रतिक्रिया देने के लिए उसके ईमेल के लिए संकेत देता है।
जब आप Send बटन पर क्लिक करते हैं, तो सभी डेटा के साथ एक ई-मेल डेवलपर को मेल द्वारा भेजा जाएगा।

  [STAThread] [STAThread] static void Main() { SetupLogger(); //     if (!Debugger.IsAttached) { //     Application.ThreadException += (sender, e) => HandleError(e.Exception); AppDomain.CurrentDomain.UnhandledException += (sender, e) => HandleError((Exception)e.ExceptionObject); } Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new MainForm()); } private static void HandleError(Exception exception) { try { //     try/catch         new ErrorHandlerController(exception).Run(); } catch (Exception e) { MessageBox.Show("Error processing exception. Please send log file EFlogger.log to developer: " + Settings.Default.ProgrammerEmail + " \r\n Exception:" + e); //      Logger.Error(e); if (MessageBox.Show("Attach debugger? \n Only for developer!!!", "Debugging...", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes) { Debugger.Launch(); throw; } } finally { //      Windows       Environment.Exit(1); } } //new ErrorHandlerController(exception).Run(); public void Run() { //    string exceptionInfoText = string.Format( "An unexpected error occurred: {0}" + Environment.NewLine + "Time: {1} " + Environment.NewLine + "{2}" + Environment.NewLine + "InnerException: \n {3}" + Environment.NewLine + "InnerException StackTrace: \n {4}" + Environment.NewLine, _exception.Message, DateTime.Now, _exception, _exception.InnerException, _exception.InnerException != null ? _exception.InnerException.StackTrace : string.Empty ); //      Program.Logger.Error(exceptionInfoText); _view.ExceptionInfoText = exceptionInfoText; //  ,   ShowDialog,         _view.ShowDialog(); }

त्रुटि हैंडलिंग फ़ॉर्म के साथ काम करने वाले मसौदे का एक उदाहरण यांडेक्स फ़ाइलों पर पाया जा सकता है: yadi.sk/d/7y4i_cz7NwtE3

नेटवर्क कनेक्टिविटी

आप मेरे पिछले लेख से प्लग-इन लाइब्रेरी और प्रोफाइलर के बीच नेटवर्क इंटरैक्शन का विवरण पढ़ सकते हैं: C # में टीसीपी के माध्यम से नेटवर्क संचार

थोडा हास्य

किसी मित्र के ~~प्रायोगिक~~ उपकरण पर उपकरण का परीक्षण करने के दौरान, ऐसा अविश्वसनीय उत्पन्न अनुरोध पाया गया (बहुत बड़ा और अजीब):

जांच

आदेश पाठ:

 का चयन करें 
     [प्रोजेक्ट २३ C]। [सी ४] एएस [सी १], 
     [प्रोजेक्ट २३]]। [नाम] एएस [नाम], 
     [Project238]। [Name1] AS [Name1], 
     [प्रोजेक्ट २३ C]। [सी २] एएस [सी २], 
     [प्रोजेक्ट २३ C]। [सी ३] एएस [सी ३], 
     [प्रोजेक्ट २३ C]। [सी १] एएस [सी ४]
     से (चयन करें) 
         [GroupBy1]। [A1] AS [C1], 
         [GroupBy1]। [के १] के रूप में [नाम], 
         [GroupBy1]। [K2] AS [Name1], 
         [GroupBy1]। [के ३] एएस [सी २], 
         [GroupBy1]। [के ४] एएस [सी ३], 
         1 AS [C4]
         से (चयन करें) 
             [प्रोजेक्ट २३1]। [नाम] एएस [के १], 
             [Project237]। [Name1] AS [K2], 
             [प्रोजेक्ट २३ K]। [सी १] एएस [के ३], 
             [प्रोजेक्ट २३ K]। [सी २] एएस [के ४], 
             COUNT (1) AS [A1]
             से (चयन करें) 
                 [एक्सटेंड 2]। [नाम] एएस [नाम], 
                 [एक्सटेंड 3]। [नाम] एएस [नाम १], 
                 DATEPART (वर्ष, [Join3]। [C11]) AS [C1], 
                 DATEPART (महीना, [Join3]। [C12]) AS [C2]
                 [ऑक्यूपेशनहिस्टोर] के रूप में [एक्सटेंट 1]
                 INNER JOIN [डिवीजन] AS [एक्सटेंट 2] पर [एक्सटेंट 1]। [डिवीजन] = [एक्सटेंट 2] [ईडी]।
                 INNER JOIN [स्थिति] AS [Extent3] ON [Extent1]। [PositionID] = [Extent3] [Id]।
                 क्रोस जॉइन (Select [UnionAll59]। [C1] AS [C11], [UnionAll1188] [C1] AS [C12]।
                     से (चयन करें) 
                         [UnionAll58]। [C1] AS [C1]
                         से (चयन करें) 
                             [UnionAll57]। [C1] AS [C1]
                             से (चयन करें) 
                                 [UnionAll56]। [C1] AS [C1]
                                 से (चयन करें) 
                                     [UnionAll55]। [C1] AS [C1]
                                     से (चयन करें) 
                                         [UnionAll54]। [C1] AS [C1]
                                         से (चयन करें) 
                                             [UnionAll53]। [C1] AS [C1]
                                             से (चयन करें) 
                                                 [UnionAll52]। [C1] AS [C1]
                                                 से (चयन करें) 
                                                     [UnionAll51]। [C1] AS [C1]
                                                     से (चयन करें) 
                                                         [UnionAll50]। [C1] AS [C1]
                                                         से (चयन करें) 
                                                             [UnionAll49]। [C1] AS [C1]
                                                             से (चयन करें) 
                                                                 [UnionAll48]। [C1] AS [C1]
                                                                 से (चयन करें) 
                                                                     [UnionAll47]। [C1] AS [C1]
                                                                     से (चयन करें) 
                                                                         [UnionAll46]। [C1] AS [C1]
                                                                         से (चयन करें) 
                                                                             [UnionAll45]। [C1] AS [C1]
                                                                             से (चयन करें) 
                                                                                 [UnionAll44]। [C1] AS [C1]
                                                                                 से (चयन करें) 
                                                                                     [UnionAll43]। [C1] AS [C1]
                                                                                     से (चयन करें) 
                                                                                         [UnionAll42]। [C1] AS [C1]
                                                                                         से (चयन करें) 
                                                                                             [UnionAll41]। [C1] AS [C1]
                                                                                             से (चयन करें) 
                                                                                                 [UnionAll40]। [C1] AS [C1]
                                                                                                 से (चयन करें) 
                                                                                                     [UnionAll39]। [C1] AS [C1]
                                                                                                     से (चयन करें) 
                                                                                                         [UnionAll38]। [C1] AS [C1]
                                                                                                         से (चयन करें) 
                                                                                                             [UnionAll37]। [C1] AS [C1]
                                                                                                             से (चयन करें) 
                                                                                                                 [UnionAll36]। [C1] AS [C1]
                                                                                                                 से (चयन करें) 
                                                                                                                     [UnionAll35]। [C1] AS [C1]
                                                                                                                     से (चयन करें) 
                                                                                                                         [UnionAll34]। [C1] AS [C1]
                                                                                                                         से (चयन करें) 
                                                                                                                             [UnionAll33]। [C1] AS [C1]
                                                                                                                             से (चयन करें) 
                                                                                                                                 [UnionAll32]। [C1] AS [C1]
                                                                                                                                 से (चयन करें) 
                                                                                                                                     [UnionAll31]। [C1] AS [C1]
                                                                                                                                     से (चयन करें) 
                                                                                                                                         [UnionAll30]। [C1] AS [C1]
                                                                                                                                         से (चयन करें) 
                                                                                                                                             [UnionAll29]। [C1] AS [C1]
                                                                                                                                             से (चयन करें) 
                                                                                                                                                 [UnionAll28]। [C1] AS [C1]
                                                                                                                                                 से (चयन करें) 
                                                                                                                                                     [UnionAll27]। [C1] AS [C1]
                                                                                                                                                     से (चयन करें) 
                                                                                                                                                         [UnionAll26]। [C1] AS [C1]
                                                                                                                                                         से (चयन करें) 
                                                                                                                                                             [UnionAll25]। [C1] AS [C1]
                                                                                                                                                             से (चयन करें) 
                                                                                                                                                                 [UnionAll24]। [C1] AS [C1]
                                                                                                                                                                 से (चयन करें) 
                                                                                                                                                                     [UnionAll23]। [C1] AS [C1]
                                                                                                                                                                     से (चयन करें) 
                                                                                                                                                                         [UnionAll22]। [C1] AS [C1]
                                                                                                                                                                         से (चयन करें) 
                                                                                                                                                                             [UnionAll21]। [C1] AS [C1]
                                                                                                                                                                             से (चयन करें) 
                                                                                                                                                                                 [UnionAll20]। [C1] AS [C1]
                                                                                                                                                                                 से (चयन करें) 
                                                                                                                                                                                     [UnionAll19]। [C1] AS [C1]
                                                                                                                                                                                     से (चयन करें) 
                                                                                                                                                                                         [UnionAll18]। [C1] AS [C1]
                                                                                                                                                                                         से (चयन करें) 
                                                                                                                                                                                             [UnionAll17]। [C1] AS [C1]
                                                                                                                                                                                             से (चयन करें) 
                                                                                                                                                                                                 [UnionAll16]। [C1] AS [C1]
                                                                                                                                                                                                 से (चयन करें) 
                                                                                                                                                                                                     [UnionAll15]। [C1] AS [C1]
                                                                                                                                                                                                     से (चयन करें) 
                                                                                                                                                                                                         [UnionAll14]। [C1] AS [C1]
                                                                                                                                                                                                         से (चयन करें) 
                                                                                                                                                                                                             [UnionAll13]। [C1] AS [C1]
                                                                                                                                                                                                             से (चयन करें) 
                                                                                                                                                                                                                 [UnionAll12]। [C1] AS [C1]
                                                                                                                                                                                                                 से (चयन करें) 
                                                                                                                                                                                                                     [UnionAll11]। [C1] AS [C1]
                                                                                                                                                                                                                     से (चयन करें) 
                                                                                                                                                                                                                         [UnionAll10]। [C1] AS [C1]
                                                                                                                                                                                                                         से (चयन करें) 
                                                                                                                                                                                                                             [UnionAll9]। [C1] AS [C1]
                                                                                                                                                                                                                             से (चयन करें) 
                                                                                                                                                                                                                                 [UnionAll8]। [C1] AS [C1]
                                                                                                                                                                                                                                 से (चयन करें) 
                                                                                                                                                                                                                                     [UnionAll7]। [C1] AS [C1]
                                                                                                                                                                                                                                     से (चयन करें) 
                                                                                                                                                                                                                                         [UnionAll6]। [C1] AS [C1]
                                                                                                                                                                                                                                         से (चयन करें) 
                                                                                                                                                                                                                                             [UnionAll5]। [C1] AS [C1]
                                                                                                                                                                                                                                             से (चयन करें) 
                                                                                                                                                                                                                                                 [UnionAll4]। [C1] AS [C1]
                                                                                                                                                                                                                                                 से (चयन करें) 
                                                                                                                                                                                                                                                     [UnionAll3]। [C1] AS [C1]
                                                                                                                                                                                                                                                     से (चयन करें) 
                                                                                                                                                                                                                                                         [UnionAll2]। [C1] AS [C1]
                                                                                                                                                                                                                                                         से (चयन करें) 
                                                                                                                                                                                                                                                             [UnionAll1]। [C1] AS [C1]
                                                                                                                                                                                                                                                             से (चयन करें) 
                                                                                                                                                                                                                                                                 कन्वर्ट (डाइमटाइम, '2001-01-01 00: 00: 00.000', 121) AS [C1]
                                                                                                                                                                                                                                                                 FROM (Select 1 AS X) AS [SingleRowTable1]
                                                                                                                                                                                                                                                             यूनिअन ऑल
                                                                                                                                                                                                                                                                 का चयन करें 
                                                                                                                                                                                                                                                                 कन्वर्ट (डाइमटाइम, '2001-02-01 00: 00: 00.000', 121) एएस [सी 1]
                                                                                                                                                                                                                                                                 FROM (Select 1 AS X) AS [SingleRowTable2]) AS [UnionAll1]
                                                                                                                                                                                                                                                         यूनिअन ऑल
                                                                                                                                                                                                                                                             का चयन करें 
                                                                                                                                                                                                                                                             कन्वर्ट (डेटाइम, '2001-03-01 00: 00: 00.000', 121) AS [C1]
                                                                                                                                                                                                                                                             FROM (Select 1 AS X) AS [SingleRowTable3]) AS [UnionAll2]
                                                                                                                                                                                                                                                     यूनिअन ऑल
                                                                                                                                                                                                                                                         का चयन करें 
                                                                                                                                                                                                                                                         कन्वर्ट (डाइमटाइम, '2001-04-01 00: 00: 00.000', 121) AS [C1]
                                                                                                                                                                                                                                                         FROM (Select 1 AS X) AS [SingleRowTable4]) AS [UnionAll3]
                                                                                                                                                                                                                                                 यूनिअन ऑल
                                                                                                                                                                                                                                                     का चयन करें 
                                                                                                                                                                                                                                                     कन्वर्ट (डाइमटाइम, '2001-05-01 00: 00: 00.000', 121) AS [C1]
                                                                                                                                                                                                                                                     FROM (Select 1 AS X) AS [SingleRowTable5]) AS [UnionAll4]
                                                                                                                                                                                                                                             यूनिअन ऑल
                                                                                                                                                                                                                                                 का चयन करें 
                                                                                                                                                                                                                                                 कन्वर्ट (डाइमटाइम, '2001-06-01 00: 00: 00.000', 121) एएस [सी 1]
                                                                                                                                                                                                                                                 FROM (Select 1 AS X) AS [SingleRowTable6]) AS [UnionAll5]
                                                                                                                                                                                                                                         यूनिअन ऑल
                                                                                                                                                                                                                                             का चयन करें 
                                                                                                                                                                                                                                             कन्वर्ट (डाइमटाइम, '2001-07-01 00: 00: 00.000', 121) AS [C1]
                                                                                                                                                                                                                                             FROM (Select 1 AS X) AS [SingleRowTable7]) AS [UnionAll6]
                                                                                                                                                                                                                                     यूनिअन ऑल
                                                                                                                                                                                                                                         का चयन करें 
                                                                                                                                                                                                                                         कन्वर्ट (डाइमटाइम, '2001-08-01 00: 00: 00.000', 121) एएस [सी 1]
                                                                                                                                                                                                                                         FROM (Select 1 AS X) AS [SingleRowTable8]) AS [UnionAll7]
                                                                                                                                                                                                                                 यूनिअन ऑल
                                                                                                                                                                                                                                     का चयन करें 
                                                                                                                                                                                                                                     कन्वर्ट (डेटाइम, '2001-09-01 00: 00: 00.000', 121) AS [C1]
                                                                                                                                                                                                                                     FROM (Select 1 AS X) AS [SingleRowTable9]) AS [UnionAll8]
                                                                                                                                                                                                                             यूनिअन ऑल
                                                                                                                                                                                                                                 का चयन करें 
                                                                                                                                                                                                                                 कन्वर्ट (डाइमटाइम, '2001-10-01 00: 00: 00.000', 121) AS [C1]
                                                                                                                                                                                                                                 FROM (Select 1 AS X) AS [SingleRowTable10]) AS [UnionAll9]
                                                                                                                                                                                                                         यूनिअन ऑल
                                                                                                                                                                                                                             का चयन करें 
                                                                                                                                                                                                                             कन्वर्ट (डाइमटाइम, '2001-11-01 00: 00: 00.000', 121) एएस [सी 1]
                                                                                                                                                                                                                             FROM (Select 1 AS X) AS [SingleRowTable11]) AS [UnionAll10]
                                                                                                                                                                                                                     यूनिअन ऑल
                                                                                                                                                                                                                         का चयन करें 
                                                                                                                                                                                                                         कन्वर्ट (डाइमटाइम, '2001-12-01 00: 00: 00.000', 121) एएस [सी 1]
                                                                                                                                                                                                                         FROM (Select 1 AS X) AS [SingleRowTable12]) AS [UnionAll11]
                                                                                                                                                                                                                 यूनिअन ऑल
                                                                                                                                                                                                                     का चयन करें 
                                                                                                                                                                                                                     कन्वर्ट (डाइमटाइम, '2002-01-01 00: 00: 00.000', 121) AS [C1]
                                                                                                                                                                                                                     FROM (Select 1 AS X) AS [SingleRowTable13]) AS [UnionAll12]
                                                                                                                                                                                                             यूनिअन ऑल
                                                                                                                                                                                                                 का चयन करें 
                                                                                                                                                                                                                 कन्वर्ट (डाइमटाइम, '2002-02-01 00: 00: 00.000', 121) एएस [सी 1]
                                                                                                                                                                                                                 FROM (Select 1 AS X) AS [SingleRowTable14]) AS [UnionAll13]
                                                                                                                                                                                                         यूनिअन ऑल
                                                                                                                                                                                                             का चयन करें 
                                                                                                                                                                                                             कन्वर्ट (डाइमटाइम, '2002-03-01 00: 00: 00.000', 121) AS [C1]
                                                                                                                                                                                                             FROM (Select 1 AS X) AS [SingleRowTable15]) AS [UnionAll14]
                                                                                                                                                                                                     यूनिअन ऑल
                                                                                                                                                                                                         का चयन करें 
                                                                                                                                                                                                         कन्वर्ट (डाइमटाइम, '2002-04-01 00: 00: 00.000', 121) एएस [सी 1]
                                                                                                                                                                                                         FROM (Select 1 AS X) AS [SingleRowTable16]) AS [UnionAll15]
                                                                                                                                                                                                 यूनिअन ऑल
                                                                                                                                                                                                     का चयन करें 
                                                                                                                                                                                                     कन्वर्ट (डाइमटाइम, '2002-05-01 00: 00: 00.000', 121) एएस [सी 1]
                                                                                                                                                                                                     FROM (Select 1 AS X) AS [SingleRowTable17]) AS [UnionAll16]
                                                                                                                                                                                             यूनिअन ऑल
                                                                                                                                                                                                 का चयन करें 
                                                                                                                                                                                                 कन्वर्ट (डाइमटाइम, '2002-06-01 00: 00: 00.000', 121) एएस [सी 1]
                                                                                                                                                                                                 FROM (Select 1 AS X) AS [SingleRowTable18]) AS [UnionAll17]
                                                                                                                                                                                         यूनिअन ऑल
                                                                                                                                                                                             का चयन करें 
                                                                                                                                                                                             कन्वर्ट (डाइमटाइम, '2002-07-01 00: 00: 00.000', 121) एएस [सी 1]
                                                                                                                                                                                             FROM (Select 1 AS X) AS [SingleRowTable19]) AS [UnionAll18]
                                                                                                                                                                                     यूनिअन ऑल
                                                                                                                                                                                         का चयन करें 
                                                                                                                                                                                         कन्वर्ट (डाइमटाइम, '2002-08-01 00: 00: 00.000', 121) एएस [सी 1]
                                                                                                                                                                                         FROM (Select 1 AS X) AS [SingleRowTable20]) AS [UnionAll19]
                                                                                                                                                                                 यूनिअन ऑल
                                                                                                                                                                                     का चयन करें 
                                                                                                                                                                                     कन्वर्ट (डाइमटाइम, '2002-09-01 00: 00: 00.000', 121) एएस [सी 1]
                                                                                                                                                                                     FROM (Select 1 AS X) AS [SingleRowTable21]) AS [UnionAll20]
                                                                                                                                                                             यूनिअन ऑल
                                                                                                                                                                                 का चयन करें 
                                                                                                                                                                                 कन्वर्ट (डाइमटाइम, '2002-10-01 00: 00: 00.000', 121) AS [C1]
                                                                                                                                                                                 FROM (Select 1 AS X) AS [SingleRowTable22]) AS [UnionAll21]
                                                                                                                                                                         यूनिअन ऑल
                                                                                                                                                                             का चयन करें 
                                                                                                                                                                             कन्वर्ट (डाइमटाइम, '2002-11-01 00: 00: 00.000', 121) एएस [सी 1]
                                                                                                                                                                             FROM (Select 1 AS X) AS [SingleRowTable23]) AS [UnionAll22]
                                                                                                                                                                     यूनिअन ऑल
                                                                                                                                                                         का चयन करें 
                                                                                                                                                                         कन्वर्ट (डेटाटाइम, '2002-12-01 00: 00: 00.000', 121) AS [C1]
                                                                                                                                                                         FROM (Select 1 AS X) AS [SingleRowTable24]) AS [UnionAll23]
                                                                                                                                                                 यूनिअन ऑल
                                                                                                                                                                     का चयन करें 
                                                                                                                                                                     कन्वर्ट (डाइमटाइम, '2003-01-01 00: 00: 00.000', 121) एएस [सी 1]
                                                                                                                                                                     FROM (Select 1 AS X) AS [SingleRowTable25]) AS [UnionAll24]
                                                                                                                                                             यूनिअन ऑल
                                                                                                                                                                 का चयन करें 
                                                                                                                                                                 कन्वर्ट (डाइमटाइम, '2003-02-01 00: 00: 00.000', 121) एएस [सी 1]
                                                                                                                                                                 FROM (Select 1 AS X) AS [SingleRowTable26]) AS [UnionAll25]
                                                                                                                                                         यूनिअन ऑल
                                                                                                                                                             का चयन करें 
                                                                                                                                                             रूपांतरित करें (डेटाटाइम, '2003-03-01 00: 00: 00.000', 121) AS [C1]
                                                                                                                                                             FROM (Select 1 AS X) AS [SingleRowTable27]) AS [UnionAll26]
                                                                                                                                                     यूनिअन ऑल
                                                                                                                                                         का चयन करें 
                                                                                                                                                         कन्वर्ट (डाइमटाइम, '2003-04-01 00: 00: 00.000', 121) एएस [सी 1]
                                                                                                                                                         FROM (Select 1 AS X) AS [SingleRowTable28]) AS [UnionAll27]
                                                                                                                                                 यूनिअन ऑल
                                                                                                                                                     का चयन करें 
                                                                                                                                                     कन्वर्ट (डाइमटाइम, '2003-05-01 00: 00: 00.000', 121) AS [C1]
                                                                                                                                                     FROM (Select 1 AS X) AS [SingleRowTable29]) AS [UnionAll28]
                                                                                                                                             यूनिअन ऑल
                                                                                                                                                 का चयन करें 
                                                                                                                                                 कन्वर्ट (डाइमटाइम, '2003-06-01 00: 00: 00.000', 121) AS [C1]
                                                                                                                                                 FROM (Select 1 AS X) AS [SingleRowTable30]) AS [UnionAll29]
                                                                                                                                         यूनिअन ऑल
                                                                                                                                             का चयन करें 
                                                                                                                                             कन्वर्ट (डाइमटाइम, '2003-07-01 00: 00: 00.000', 121) एएस [सी 1]
                                                                                                                                             FROM (Select 1 AS X) AS [SingleRowTable31]) AS [UnionAll30]
                                                                                                                                     यूनिअन ऑल
                                                                                                                                         का चयन करें 
                                                                                                                                         कन्वर्ट (डाइमटाइम, '2003-08-01 00: 00: 00.000', 121) एएस [सी 1]
                                                                                                                                         FROM (Select 1 AS X) AS [SingleRowTable32]) AS [UnionAll31]
                                                                                                                                 यूनिअन ऑल
                                                                                                                                     का चयन करें 
                                                                                                                                     कन्वर्ट (डाइमटाइम, '2003-09-01 00: 00: 00.000', 121) एएस [सी 1]
                                                                                                                                     FROM (Select 1 AS X) AS [SingleRowTable33]) AS [UnionAll32]
                                                                                                                             यूनिअन ऑल
                                                                                                                                 का चयन करें 
                                                                                                                                 रूपांतरित करें (डेटाटाइम, '2003-10-01 00: 00: 00.000', 121) AS [C1]
                                                                                                                                 FROM (Select 1 AS X) AS [SingleRowTable34]) AS [UnionAll33]
                                                                                                                         यूनिअन ऑल
                                                                                                                             का चयन करें 
                                                                                                                             रूपांतरित करें (डेटाटाइम, '2003-11-01 00: 00: 00.000', 121) AS [C1]
                                                                                                                             FROM (Select 1 AS X) AS [SingleRowTable35]) AS [UnionAll34]
                                                                                                                     यूनिअन ऑल
                                                                                                                         का चयन करें 
                                                                                                                         कन्वर्ट (डाइमटाइम, '2003-12-01 00: 00: 00.000', 121) AS [C1]
                                                                                                                         FROM (Select 1 AS X) AS [SingleRowTable36]) AS [UnionAll35]
                                                                                                                 यूनिअन ऑल
                                                                                                                     का चयन करें 
                                                                                                                     कन्वर्ट (डाइमटाइम, '2004-01-01 00: 00: 00.000', 121) एएस [सी 1]
                                                                                                                     FROM (Select 1 AS X) AS [SingleRowTable37]) AS [UnionAll36]
                                                                                                             यूनिअन ऑल
                                                                                                                 का चयन करें 
                                                                                                                 कन्वर्ट (डाइमटाइम, '2004-02-01 00: 00: 00.000', 121) एएस [सी 1]
                                                                                                                 FROM (Select 1 AS X) AS [SingleRowTable38]) AS [UnionAll37]
                                                                                                         यूनिअन ऑल
                                                                                                             का चयन करें 
                                                                                                             कन्वर्ट (डाइमटाइम, '2004-03-01 00: 00: 00.000', 121) AS [C1]
                                                                                                             FROM (Select 1 AS X) AS [SingleRowTable39]) AS [UnionAll38]
                                                                                                     यूनिअन ऑल
                                                                                                         का चयन करें 
                                                                                                         कन्वर्ट (डाइमटाइम, '2004-04-01 00: 00: 00.000', 121) एएस [सी 1]
                                                                                                         FROM (Select 1 AS X) AS [SingleRowTable40]) AS [UnionAll39]
                                                                                                 यूनिअन ऑल
                                                                                                     का चयन करें 
                                                                                                     कन्वर्ट (डाइमटाइम, '2004-05-01 00: 00: 00.000', 121) एएस [सी 1]
                                                                                                     FROM (Select 1 AS X) AS [SingleRowTable41]) AS [UnionAll40]
                                                                                             यूनिअन ऑल
                                                                                                 का चयन करें 
                                                                                                 कन्वर्ट (डाइमटाइम, '2004-06-01 00: 00: 00.000', 121) एएस [सी 1]
                                                                                                 FROM (Select 1 AS X) AS [SingleRowTable42]) AS [UnionAll41]
                                                                                         यूनिअन ऑल
                                                                                             का चयन करें 
                                                                                             कन्वर्ट (डाइमटाइम, '2004-07-01 00: 00: 00.000', 121) AS [C1]
                                                                                             FROM (Select 1 AS X) AS [SingleRowTable43]) AS [UnionAll42]
                                                                                     यूनिअन ऑल
                                                                                         का चयन करें 
                                                                                         कन्वर्ट (डाइमटाइम, '2004-08-01 00: 00: 00.000', 121) एएस [सी 1]
                                                                                         FROM (Select 1 AS X) AS [SingleRowTable44]) AS [UnionAll43]
                                                                                 यूनिअन ऑल
                                                                                     का चयन करें 
                                                                                     कन्वर्ट (डाइमटाइम, '2004-09-01 00: 00: 00.000', 121) एएस [सी 1]
                                                                                     FROM (Select 1 AS X) AS [SingleRowTable45]) AS [UnionAll44]
                                                                             यूनिअन ऑल
                                                                                 का चयन करें 
                                                                                 कन्वर्ट (डाइमटाइम, '2004-10-01 00: 00: 00.000', 121) एएस [सी 1]
                                                                                 FROM (Select 1 AS X) AS [SingleRowTable46]) AS [UnionAll45]
                                                                         यूनिअन ऑल
                                                                             का चयन करें 
                                                                             कन्वर्ट (डाइमटाइम, '2004-11-01 00: 00: 00.000', 121) AS [C1]
                                                                             FROM (Select 1 AS X) AS [SingleRowTable47]) AS [UnionAll46]
                                                                     यूनिअन ऑल
                                                                         का चयन करें 
                                                                         कन्वर्ट (डाइमटाइम, '2004-12-01 00: 00: 00.000', 121) एएस [सी 1]
                                                                         FROM (Select 1 AS X) AS [SingleRowTable48]) AS [UnionAll47]
                                                                 यूनिअन ऑल
                                                                     का चयन करें 
                                                                     कन्वर्ट (डाइमटाइम, '2005-01-01 00: 00: 00.000', 121) AS [C1]
                                                                     FROM (Select 1 AS X) AS [SingleRowTable49]) AS [UnionAll48]
                                                             यूनिअन ऑल
                                                                 का चयन करें 
                                                                 कन्वर्ट (डेटाटाइम, '2005-02-01 00: 00: 00.000', 121) एएस [सी 1]
                                                                 FROM (Select 1 AS X) AS [SingleRowTable50]) AS [UnionAll49]
                                                         यूनिअन ऑल
                                                             का चयन करें 
                                                             कन्वर्ट (डाइमटाइम, '2005-03-01 00: 00: 00.000', 121) AS [C1]
                                                             FROM (Select 1 AS X) AS [SingleRowTable51] के रूप में [UnionAll50]
                                                     यूनिअन ऑल
                                                         का चयन करें 
                                                         कन्वर्ट (डाइमटाइम, '2005-04-01 00: 00: 00.000', 121) AS [C1]
                                                         FROM (Select 1 AS X) AS [SingleRowTable52] के रूप में [UnionAll51]
                                                 यूनिअन ऑल
                                                     का चयन करें 
                                                     कन्वर्ट (डाइमटाइम, '2005-05-01 00: 00: 00.000', 121) AS [C1]
                                                     FROM (Select 1 AS X) AS [SingleRowTable53]) AS [UnionAll52]
                                             यूनिअन ऑल
                                                 का चयन करें 
                                                 कन्वर्ट (डाइमटाइम, '2005-06-01 00: 00: 00.000', 121) AS [C1]
                                                 FROM (Select 1 AS X) AS [SingleRowTable54]) AS [UnionAll53]
                                         यूनिअन ऑल
                                             का चयन करें 
                                             कन्वर्ट (डाइमटाइम, '2005-07-01 00: 00: 00.000', 121) AS [C1]
                                             FROM (Select 1 AS X) AS [SingleRowTable55]) AS [UnionAll54]
                                     यूनिअन ऑल
                                         का चयन करें 
                                         कन्वर्ट (डाइमटाइम, '2005-08-01 00: 00: 00.000', 121) एएस [सी 1]
                                         FROM (Select 1 AS X) AS [SingleRowTable56]) AS [UnionAll55]
                                 यूनिअन ऑल
                                     का चयन करें 
                                     कन्वर्ट (डाइमटाइम, '2005-09-01 00: 00: 00.000', 121) AS [C1]
                                     FROM (Select 1 AS X) AS [SingleRowTable57]) AS [UnionAll56]
                             यूनिअन ऑल
                                 का चयन करें 
                                 कन्वर्ट (डाइमटाइम, '2005-10-01 00: 00: 00.000', 121) AS [C1]
                                 FROM (Select 1 AS X) AS [SingleRowTable58]) AS [UnionAll57]
                         यूनिअन ऑल
                             का चयन करें 
                             कन्वर्ट (डेटाटाइम, '2005-11-01 00: 00: 00.000', 121) AS [C1]
                             FROM (Select 1 AS X) AS [SingleRowTable59]) AS [UnionAll58]
                     यूनिअन ऑल
                         का चयन करें 
                         कन्वर्ट (डाइमटाइम, '2005-12-01 00: 00: 00.000', 121) AS [C1]
                         FROM (Select 1 AS X) AS [SingleRowTable60]) AS [UnionAll59]
                     ININ JOIN (सेलेक्ट करें 
                         [UnionAll117]। [C1] AS [C1]
                         से (चयन करें) 
                             [UnionAll116]। [C1] AS [C1]
                             से (चयन करें) 
                                 [UnionAll115]। [C1] AS [C1]
                                 से (चयन करें) 
                                     [UnionAll114]। [C1] AS [C1]
                                     से (चयन करें) 
                                         [UnionAll113]। [C1] AS [C1]
                                         से (चयन करें) 
                                             [UnionAll112]। [C1] AS [C1]
                                             से (चयन करें) 
                                                 [UnionAll111]। [C1] AS [C1]
                                                 से (चयन करें) 
                                                     [UnionAll110]। [C1] AS [C1]
                                                     से (चयन करें) 
                                                         [UnionAll109]। [C1] AS [C1]
                                                         से (चयन करें) 
                                                             [UnionAll108]। [C1] AS [C1]
                                                             से (चयन करें) 
                                                                 [UnionAll107]। [C1] AS [C1]
                                                                 से (चयन करें) 
                                                                     [UnionAll106]। [C1] AS [C1]
                                                                     से (चयन करें) 
                                                                         [UnionAll105]। [C1] AS [C1]
                                                                         से (चयन करें) 
                                                                             [UnionAll104]। [C1] AS [C1]
                                                                             से (चयन करें) 
                                                                                 [UnionAll103]। [C1] AS [C1]
                                                                                 से (चयन करें) 
                                                                                     [UnionAll102]। [C1] AS [C1]
                                                                                     से (चयन करें) 
                                                                                         [UnionAll101]। [C1] AS [C1]
                                                                                         से (चयन करें) 
                                                                                             [UnionAll100]। [C1] AS [C1]
                                                                                             से (चयन करें) 
                                                                                                 [UnionAll99]। [C1] AS [C1]
                                                                                                 से (चयन करें) 
                                                                                                     [UnionAll98]। [C1] AS [C1]
                                                                                                     से (चयन करें) 
                                                                                                         [UnionAll97]। [C1] AS [C1]
                                                                                                         से (चयन करें) 
                                                                                                             [UnionAll96]। [C1] AS [C1]
                                                                                                             से (चयन करें) 
                                                                                                                 [UnionAll95]। [C1] AS [C1]
                                                                                                                 से (चयन करें) 
                                                                                                                     [UnionAll94]। [C1] AS [C1]
                                                                                                                     से (चयन करें) 
                                                                                                                         [UnionAll93]। [C1] AS [C1]
                                                                                                                         से (चयन करें) 
                                                                                                                             [UnionAll92]। [C1] AS [C1]
                                                                                                                             से (चयन करें) 
                                                                                                                                 [UnionAll91]। [C1] AS [C1]
                                                                                                                                 से (चयन करें) 
                                                                                                                                     [UnionAll90]। [C1] AS [C1]
                                                                                                                                     से (चयन करें) 
                                                                                                                                         [UnionAll89]। [C1] AS [C1]
                                                                                                                                         से (चयन करें) 
                                                                                                                                             [UnionAll88]। [C1] AS [C1]
                                                                                                                                             से (चयन करें) 
                                                                                                                                                 [UnionAll87]। [C1] AS [C1]
                                                                                                                                                 से (चयन करें) 
                                                                                                                                                     [UnionAll86]। [C1] AS [C1]
                                                                                                                                                     से (चयन करें) 
                                                                                                                                                         [UnionAll85]। [C1] AS [C1]
                                                                                                                                                         से (चयन करें) 
                                                                                                                                                             [UnionAll84]। [C1] AS [C1]
                                                                                                                                                             से (चयन करें) 
                                                                                                                                                                 [UnionAll83]। [C1] AS [C1]
                                                                                                                                                                 से (चयन करें) 
                                                                                                                                                                     [UnionAll82]। [C1] AS [C1]
                                                                                                                                                                     से (चयन करें) 
                                                                                                                                                                         [UnionAll81]। [C1] AS [C1]
                                                                                                                                                                         से (चयन करें) 
                                                                                                                                                                             [UnionAll80]। [C1] AS [C1]
                                                                                                                                                                             से (चयन करें) 
                                                                                                                                                                                 [UnionAll79]। [C1] AS [C1]
                                                                                                                                                                                 से (चयन करें) 
                                                                                                                                                                                     [UnionAll78]। [C1] AS [C1]
                                                                                                                                                                                     से (चयन करें) 
                                                                                                                                                                                         [UnionAll77]। [C1] AS [C1]
                                                                                                                                                                                         से (चयन करें) 
                                                                                                                                                                                             [UnionAll76]। [C1] AS [C1]
                                                                                                                                                                                             से (चयन करें) 
                                                                                                                                                                                                 [UnionAll75]। [C1] AS [C1]
                                                                                                                                                                                                 से (चयन करें) 
                                                                                                                                                                                                     [UnionAll74]। [C1] AS [C1]
                                                                                                                                                                                                     से (चयन करें) 
                                                                                                                                                                                                         [UnionAll73]। [C1] AS [C1]
                                                                                                                                                                                                         से (चयन करें) 
                                                                                                                                                                                                             [UnionAll72]। [C1] AS [C1]
                                                                                                                                                                                                             से (चयन करें) 
                                                                                                                                                                                                                 [UnionAll71]। [C1] AS [C1]
                                                                                                                                                                                                                 से (चयन करें) 
                                                                                                                                                                                                                     [UnionAll70]। [C1] AS [C1]
                                                                                                                                                                                                                     से (चयन करें) 
                                                                                                                                                                                                                         [UnionAll69]। [C1] AS [C1]
                                                                                                                                                                                                                         से (चयन करें) 
                                                                                                                                                                                                                             [UnionAll68]। [C1] AS [C1]
                                                                                                                                                                                                                             से (चयन करें) 
                                                                                                                                                                                                                                 [UnionAll67]। [C1] AS [C1]
                                                                                                                                                                                                                                 से (चयन करें) 
                                                                                                                                                                                                                                     [UnionAll66]। [C1] AS [C1]
                                                                                                                                                                                                                                     से (चयन करें) 
                                                                                                                                                                                                                                         [UnionAll65]। [C1] AS [C1]
                                                                                                                                                                                                                                         से (चयन करें) 
                                                                                                                                                                                                                                             [UnionAll64]। [C1] AS [C1]
                                                                                                                                                                                                                                             से (चयन करें) 
                                                                                                                                                                                                                                                 [UnionAll63]। [C1] AS [C1]
                                                                                                                                                                                                                                                 से (चयन करें) 
                                                                                                                                                                                                                                                     [UnionAll62]। [C1] AS [C1]
                                                                                                                                                                                                                                                     से (चयन करें) 
                                                                                                                                                                                                                                                         [UnionAll61]। [C1] AS [C1]
                                                                                                                                                                                                                                                         से (चयन करें) 
                                                                                                                                                                                                                                                             [UnionAll60]। [C1] AS [C1]
                                                                                                                                                                                                                                                             से (चयन करें) 
                                                                                                                                                                                                                                                                 कन्वर्ट (डाइमटाइम, '2001-01-31 00: 00: 00.000', 121) एएस [सी 1]
                                                                                                                                                                                                                                                                 FROM (Select 1 AS X) AS [SingleRowTable61]
                                                                                                                                                                                                                                                             यूनिअन ऑल
                                                                                                                                                                                                                                                                 का चयन करें 
                                                                                                                                                                                                                                                                 कन्वर्ट (डाइमटाइम, '2001-02-28 00: 00: 00.000', 121) एएस [सी 1]
                                                                                                                                                                                                                                                                 FROM (Select 1 AS X) AS [SingleRowTable62]) AS [UnionAll60]
                                                                                                                                                                                                                                                         यूनिअन ऑल
                                                                                                                                                                                                                                                             का चयन करें 
                                                                                                                                                                                                                                                             कन्वर्ट (डाइमटाइम, '2001-03-31 00: 00: 00.000', 121) AS [C1]
                                                                                                                                                                                                                                                             FROM (Select 1 AS X) AS [SingleRowTable63]) AS [UnionAll61]
                                                                                                                                                                                                                                                     यूनिअन ऑल
                                                                                                                                                                                                                                                         का चयन करें 
                                                                                                                                                                                                                                                         कन्वर्ट (डाइमटाइम, '2001-04-30 00: 00: 00.000', 121) एएस [सी 1]
                                                                                                                                                                                                                                                         FROM (Select 1 AS X) AS [SingleRowTable64]) AS [UnionAll62]
                                                                                                                                                                                                                                                 यूनिअन ऑल
                                                                                                                                                                                                                                                     का चयन करें 
                                                                                                                                                                                                                                                     कन्वर्ट (डाइमटाइम, '2001-05-31 00: 00: 00.000', 121) एएस [सी 1]
                                                                                                                                                                                                                                                     FROM (Select 1 AS X) AS [SingleRowTable65]) AS [UnionAll63]
                                                                                                                                                                                                                                             यूनिअन ऑल
                                                                                                                                                                                                                                                 का चयन करें 
                                                                                                                                                                                                                                                 कन्वर्ट (डाइमटाइम, '2001-06-30 00: 00: 00.000', 121) एएस [सी 1]
                                                                                                                                                                                                                                                 FROM (Select 1 AS X) AS [SingleRowTable66]) AS [UnionAll64]
                                                                                                                                                                                                                                         यूनिअन ऑल
                                                                                                                                                                                                                                             का चयन करें 
                                                                                                                                                                                                                                             कन्वर्ट (डाइमटाइम, '2001-07-31 00: 00: 00.000', 121) एएस [सी 1]
                                                                                                                                                                                                                                             FROM (Select 1 AS X) AS [SingleRowTable67]) AS [UnionAll65]
                                                                                                                                                                                                                                     यूनिअन ऑल
                                                                                                                                                                                                                                         का चयन करें 
                                                                                                                                                                                                                                         कन्वर्ट (डाइमटाइम, '2001-08-31 00: 00: 00.000', 121) एएस [सी 1]
                                                                                                                                                                                                                                         FROM (Select 1 AS X) AS [SingleRowTable68]) AS [UnionAll66]
                                                                                                                                                                                                                                 यूनिअन ऑल
                                                                                                                                                                                                                                     का चयन करें 
                                                                                                                                                                                                                                     कन्वर्ट (डाइमटाइम, '2001-09-30 00: 00: 00.000', 121) एएस [सी 1]
                                                                                                                                                                                                                                     FROM (Select 1 AS X) AS [SingleRowTable69]) AS [UnionAll67]
                                                                                                                                                                                                                             यूनिअन ऑल
                                                                                                                                                                                                                                 का चयन करें 
                                                                                                                                                                                                                                 कन्वर्ट (डाइमटाइम, '2001-10-31 00: 00: 00.000', 121) एएस [सी 1]
                                                                                                                                                                                                                                 FROM (Select 1 AS X) AS [SingleRowTable70]) AS [UnionAll68]
                                                                                                                                                                                                                         यूनिअन ऑल
                                                                                                                                                                                                                             का चयन करें 
                                                                                                                                                                                                                             कन्वर्ट (डाइमटाइम, '2001-11-30 00: 00: 00.000', 121) एएस [सी 1]
                                                                                                                                                                                                                             FROM (Select 1 AS X) AS [SingleRowTable71]) AS [UnionAll69]
                                                                                                                                                                                                                     यूनिअन ऑल
                                                                                                                                                                                                                         का चयन करें 
                                                                                                                                                                                                                         कन्वर्ट (डाइमटाइम, '2001-12-31 00: 00: 00.000', 121) एएस [सी 1]
                                                                                                                                                                                                                         FROM (Select 1 AS X) AS [SingleRowTable72]) AS [UnionAll70]
                                                                                                                                                                                                                 यूनिअन ऑल
                                                                                                                                                                                                                     का चयन करें 
                                                                                                                                                                                                                     कन्वर्ट (डाइमटाइम, '2002-01-31 00: 00: 00.000', 121) एएस [सी 1]
                                                                                                                                                                                                                     FROM (Select 1 AS X) AS [SingleRowTable73]) AS [UnionAll71]
                                                                                                                                                                                                             यूनिअन ऑल
                                                                                                                                                                                                                 का चयन करें 
                                                                                                                                                                                                                 कन्वर्ट (डाइमटाइम, '2002-02-28 00: 00: 00.000', 121) एएस [सी 1]
                                                                                                                                                                                                                 FROM (Select 1 AS X) AS [SingleRowTable74]) AS [UnionAll72]
                                                                                                                                                                                                         यूनिअन ऑल
                                                                                                                                                                                                             का चयन करें 
                                                                                                                                                                                                             कन्वर्ट (डाइमटाइम, '2002-03-31 00: 00: 00.000', 121) एएस [सी 1]
                                                                                                                                                                                                             FROM (Select 1 AS X) AS [SingleRowTable75]) AS [UnionAll73]
                                                                                                                                                                                                     यूनिअन ऑल
                                                                                                                                                                                                         का चयन करें 
                                                                                                                                                                                                         कन्वर्ट (डाइमटाइम, '2002-04-30 00: 00: 00.000', 121) एएस [सी 1]
                                                                                                                                                                                                         FROM (Select 1 AS X) AS [SingleRowTable76]) AS [UnionAll74]
                                                                                                                                                                                                 यूनिअन ऑल
                                                                                                                                                                                                     का चयन करें 
                                                                                                                                                                                                     कन्वर्ट (डाइमटाइम, '2002-05-31 00: 00: 00.000', 121) एएस [सी 1]
                                                                                                                                                                                                     FROM (Select 1 AS X) AS [SingleRowTable77]) AS [UnionAll75]
                                                                                                                                                                                             यूनिअन ऑल
                                                                                                                                                                                                 का चयन करें 
                                                                                                                                                                                                 कन्वर्ट (डाइमटाइम, '2002-06-30 00: 00: 00.000', 121) एएस [सी 1]
                                                                                                                                                                                                 FROM (Select 1 AS X) AS [SingleRowTable78]) AS [UnionAll76]
                                                                                                                                                                                         यूनिअन ऑल
                                                                                                                                                                                             का चयन करें 
                                                                                                                                                                                             कन्वर्ट (डाइमटाइम, '2002-07-31 00: 00: 00.000', 121) एएस [सी 1]
                                                                                                                                                                                             FROM (Select 1 AS X) AS [SingleRowTable79]) AS [UnionAll77]
                                                                                                                                                                                     यूनिअन ऑल
                                                                                                                                                                                         का चयन करें 
                                                                                                                                                                                         कन्वर्ट (डाइमटाइम, '2002-08-31 00: 00: 00.000', 121) एएस [सी 1]
                                                                                                                                                                                         FROM (Select 1 AS X) AS [SingleRowTable80]) AS [UnionAll78]
                                                                                                                                                                                 यूनिअन ऑल
                                                                                                                                                                                     का चयन करें 
                                                                                                                                                                                     कन्वर्ट (डाइमटाइम, '2002-09-30 00: 00: 00.000', 121) एएस [सी 1]
                                                                                                                                                                                     FROM (Select 1 AS X) AS [SingleRowTable81]) AS [UnionAll79]
                                                                                                                                                                             यूनिअन ऑल
                                                                                                                                                                                 का चयन करें 
                                                                                                                                                                                 कन्वर्ट (डाइमटाइम, '2002-10-31 00: 00: 00.000', 121) AS [C1]
                                                                                                                                                                                 FROM (Select 1 AS X) AS [SingleRowTable82]) AS [UnionAll80]
                                                                                                                                                                         यूनिअन ऑल
                                                                                                                                                                             का चयन करें 
                                                                                                                                                                             कन्वर्ट (डेटाटाइम, '2002-11-30 00: 00: 00.000', 121) AS [C1]
                                                                                                                                                                             FROM (Select 1 AS X) AS [SingleRowTable83]) AS [UnionAll81]
                                                                                                                                                                     यूनिअन ऑल
                                                                                                                                                                         का चयन करें 
                                                                                                                                                                         कन्वर्ट (डाइमटाइम, '2002-12-31 00: 00: 00.000', 121) एएस [सी 1]
                                                                                                                                                                         FROM (Select 1 AS X) AS [SingleRowTable84]) AS [UnionAll82]
                                                                                                                                                                 यूनिअन ऑल
                                                                                                                                                                     का चयन करें 
                                                                                                                                                                     कन्वर्ट (डाइमटाइम, '2003-01-31 00: 00: 00.000', 121) AS [C1]
                                                                                                                                                                     FROM (Select 1 AS X) AS [SingleRowTable85]) AS [UnionAll83]
                                                                                                                                                             यूनिअन ऑल
                                                                                                                                                                 का चयन करें 
                                                                                                                                                                 कन्वर्ट (डेटाटाइम, '2003-02-28 00: 00: 00.000', 121) एएस [सी 1]
                                                                                                                                                                 FROM (Select 1 AS X) AS [SingleRowTable86]) AS [UnionAll84]
                                                                                                                                                         यूनिअन ऑल
                                                                                                                                                             का चयन करें 
                                                                                                                                                             रूपांतरित (डेटाटाइम, '2003-03-31 00: 00: 00.000', 121) AS [C1]
                                                                                                                                                             FROM (Select 1 AS X) AS [SingleRowTable87]) AS [UnionAll85]
                                                                                                                                                     यूनिअन ऑल
                                                                                                                                                         का चयन करें 
                                                                                                                                                        convert(datetime, '2003-04-30 00:00:00.000', 121) AS [C1]
                                                                                                                                                        FROM ( SELECT 1 AS X ) AS [SingleRowTable88]) AS [UnionAll86]
                                                                                                                                                UNION ALL
                                                                                                                                                     का चयन करें 
                                                                                                                                                    convert(datetime, '2003-05-31 00:00:00.000', 121) AS [C1]
                                                                                                                                                    FROM ( SELECT 1 AS X ) AS [SingleRowTable89]) AS [UnionAll87]
                                                                                                                                            UNION ALL
                                                                                                                                                 का चयन करें 
                                                                                                                                                convert(datetime, '2003-06-30 00:00:00.000', 121) AS [C1]
                                                                                                                                                FROM ( SELECT 1 AS X ) AS [SingleRowTable90]) AS [UnionAll88]
                                                                                                                                        UNION ALL
                                                                                                                                             का चयन करें 
                                                                                                                                            convert(datetime, '2003-07-31 00:00:00.000', 121) AS [C1]
                                                                                                                                            FROM ( SELECT 1 AS X ) AS [SingleRowTable91]) AS [UnionAll89]
                                                                                                                                    UNION ALL
                                                                                                                                         का चयन करें 
                                                                                                                                        convert(datetime, '2003-08-31 00:00:00.000', 121) AS [C1]
                                                                                                                                        FROM ( SELECT 1 AS X ) AS [SingleRowTable92]) AS [UnionAll90]
                                                                                                                                UNION ALL
                                                                                                                                     का चयन करें 
                                                                                                                                    convert(datetime, '2003-09-30 00:00:00.000', 121) AS [C1]
                                                                                                                                    FROM ( SELECT 1 AS X ) AS [SingleRowTable93]) AS [UnionAll91]
                                                                                                                            UNION ALL
                                                                                                                                 का चयन करें 
                                                                                                                                convert(datetime, '2003-10-31 00:00:00.000', 121) AS [C1]
                                                                                                                                FROM ( SELECT 1 AS X ) AS [SingleRowTable94]) AS [UnionAll92]
                                                                                                                        UNION ALL
                                                                                                                             का चयन करें 
                                                                                                                            convert(datetime, '2003-11-30 00:00:00.000', 121) AS [C1]
                                                                                                                            FROM ( SELECT 1 AS X ) AS [SingleRowTable95]) AS [UnionAll93]
                                                                                                                    UNION ALL
                                                                                                                         का चयन करें 
                                                                                                                        convert(datetime, '2003-12-31 00:00:00.000', 121) AS [C1]
                                                                                                                        FROM ( SELECT 1 AS X ) AS [SingleRowTable96]) AS [UnionAll94]
                                                                                                                UNION ALL
                                                                                                                     का चयन करें 
                                                                                                                    convert(datetime, '2004-01-31 00:00:00.000', 121) AS [C1]
                                                                                                                    FROM ( SELECT 1 AS X ) AS [SingleRowTable97]) AS [UnionAll95]
                                                                                                            UNION ALL
                                                                                                                 का चयन करें 
                                                                                                                convert(datetime, '2004-02-29 00:00:00.000', 121) AS [C1]
                                                                                                                FROM ( SELECT 1 AS X ) AS [SingleRowTable98]) AS [UnionAll96]
                                                                                                        UNION ALL
                                                                                                             का चयन करें 
                                                                                                            convert(datetime, '2004-03-31 00:00:00.000', 121) AS [C1]
                                                                                                            FROM ( SELECT 1 AS X ) AS [SingleRowTable99]) AS [UnionAll97]
                                                                                                    UNION ALL
                                                                                                         का चयन करें 
                                                                                                        convert(datetime, '2004-04-30 00:00:00.000', 121) AS [C1]
                                                                                                        FROM ( SELECT 1 AS X ) AS [SingleRowTable100]) AS [UnionAll98]
                                                                                                UNION ALL
                                                                                                     का चयन करें 
                                                                                                    convert(datetime, '2004-05-31 00:00:00.000', 121) AS [C1]
                                                                                                    FROM ( SELECT 1 AS X ) AS [SingleRowTable101]) AS [UnionAll99]
                                                                                            UNION ALL
                                                                                                 का चयन करें 
                                                                                                convert(datetime, '2004-06-30 00:00:00.000', 121) AS [C1]
                                                                                                FROM ( SELECT 1 AS X ) AS [SingleRowTable102]) AS [UnionAll100]
                                                                                        UNION ALL
                                                                                             का चयन करें 
                                                                                            convert(datetime, '2004-07-31 00:00:00.000', 121) AS [C1]
                                                                                            FROM ( SELECT 1 AS X ) AS [SingleRowTable103]) AS [UnionAll101]
                                                                                    UNION ALL
                                                                                         का चयन करें 
                                                                                        convert(datetime, '2004-08-31 00:00:00.000', 121) AS [C1]
                                                                                        FROM ( SELECT 1 AS X ) AS [SingleRowTable104]) AS [UnionAll102]
                                                                                UNION ALL
                                                                                     का चयन करें 
                                                                                    convert(datetime, '2004-09-30 00:00:00.000', 121) AS [C1]
                                                                                    FROM ( SELECT 1 AS X ) AS [SingleRowTable105]) AS [UnionAll103]
                                                                            UNION ALL
                                                                                 का चयन करें 
                                                                                convert(datetime, '2004-10-31 00:00:00.000', 121) AS [C1]
                                                                                FROM ( SELECT 1 AS X ) AS [SingleRowTable106]) AS [UnionAll104]
                                                                        UNION ALL
                                                                             का चयन करें 
                                                                            convert(datetime, '2004-11-30 00:00:00.000', 121) AS [C1]
                                                                            FROM ( SELECT 1 AS X ) AS [SingleRowTable107]) AS [UnionAll105]
                                                                    UNION ALL
                                                                         का चयन करें 
                                                                        convert(datetime, '2004-12-31 00:00:00.000', 121) AS [C1]
                                                                        FROM ( SELECT 1 AS X ) AS [SingleRowTable108]) AS [UnionAll106]
                                                                UNION ALL
                                                                     का चयन करें 
                                                                    convert(datetime, '2005-01-31 00:00:00.000', 121) AS [C1]
                                                                    FROM ( SELECT 1 AS X ) AS [SingleRowTable109]) AS [UnionAll107]
                                                            UNION ALL
                                                                 का चयन करें 
                                                                convert(datetime, '2005-02-28 00:00:00.000', 121) AS [C1]
                                                                FROM ( SELECT 1 AS X ) AS [SingleRowTable110]) AS [UnionAll108]
                                                        UNION ALL
                                                             का चयन करें 
                                                            convert(datetime, '2005-03-31 00:00:00.000', 121) AS [C1]
                                                            FROM ( SELECT 1 AS X ) AS [SingleRowTable111]) AS [UnionAll109]
                                                    UNION ALL
                                                         का चयन करें 
                                                        convert(datetime, '2005-04-30 00:00:00.000', 121) AS [C1]
                                                        FROM ( SELECT 1 AS X ) AS [SingleRowTable112]) AS [UnionAll110]
                                                UNION ALL
                                                     का चयन करें 
                                                    convert(datetime, '2005-05-31 00:00:00.000', 121) AS [C1]
                                                    FROM ( SELECT 1 AS X ) AS [SingleRowTable113]) AS [UnionAll111]
                                            UNION ALL
                                                 का चयन करें 
                                                convert(datetime, '2005-06-30 00:00:00.000', 121) AS [C1]
                                                FROM ( SELECT 1 AS X ) AS [SingleRowTable114]) AS [UnionAll112]
                                        UNION ALL
                                             का चयन करें 
                                            convert(datetime, '2005-07-31 00:00:00.000', 121) AS [C1]
                                            FROM ( SELECT 1 AS X ) AS [SingleRowTable115]) AS [UnionAll113]
                                    UNION ALL
                                         का चयन करें 
                                        convert(datetime, '2005-08-31 00:00:00.000', 121) AS [C1]
                                        FROM ( SELECT 1 AS X ) AS [SingleRowTable116]) AS [UnionAll114]
                                UNION ALL
                                     का चयन करें 
                                    convert(datetime, '2005-09-30 00:00:00.000', 121) AS [C1]
                                    FROM ( SELECT 1 AS X ) AS [SingleRowTable117]) AS [UnionAll115]
                            UNION ALL
                                 का चयन करें 
                                convert(datetime, '2005-10-31 00:00:00.000', 121) AS [C1]
                                FROM ( SELECT 1 AS X ) AS [SingleRowTable118]) AS [UnionAll116]
                        UNION ALL
                             का चयन करें 
                            convert(datetime, '2005-11-30 00:00:00.000', 121) AS [C1]
                            FROM ( SELECT 1 AS X ) AS [SingleRowTable119]) AS [UnionAll117]
                    UNION ALL
                         का चयन करें 
                        convert(datetime, '2005-12-31 00:00:00.000', 121) AS [C1]
                        FROM ( SELECT 1 AS X ) AS [SingleRowTable120]) AS [UnionAll118] ON (((DATEPART (year, [UnionAll59].[C1])) = (DATEPART (year, [UnionAll118].[C1]))) OR ((DATEPART (year, [UnionAll59].[C1]) IS NULL) AND (DATEPART (year, [UnionAll118].[C1]) IS NULL))) AND (((DATEPART (month, [UnionAll59].[C1])) = (DATEPART (month, [UnionAll118].[C1]))) OR ((DATEPART (month, [UnionAll59].[C1]) IS NULL) AND (DATEPART (month, [UnionAll118].[C1]) IS NULL))) ) AS [Join3]
                WHERE ([Extent1].[StartDate] <= [Join3].[C12]) AND ((CASE WHEN ([Extent1].[EndDate] IS NOT NULL) THEN [Extent1].[EndDate] ELSE GetDate() END) >= [Join3].[C11])
            ) AS [Project237]
            GROUP BY [Project237].[Name], [Project237].[Name1], [Project237].[C1], [Project237].[C2]
        ) AS [GroupBy1]
    ) AS [Project238]
    ORDER BY [Project238].[C2] ASC, [Project238].[C3] ASC, [Project238].[Name] ASC, [Project238].[Name1] ASC; 
  Method Name:GetEmployeesCount; 
 Class Name:CompanyEmployees.Data.ReportBuilder; 
 Elapsed Miliseconds:336

अंतभाषण

मुझे यकीन है कि अभी भी कई कीड़े हैं, लेकिन मैं जितनी जल्दी हो सके सभी त्रुटियों को ठीक करने की कोशिश करूंगा। इसके अलावा, मैं एक सम्मानित समुदाय से सलाह लेना चाहता हूं कि इस प्रोफाइलर के साथ क्या करना है, इसलिए एक तरफ मैं एक मुफ्त उत्पाद बनाना चाहता हूं, लेकिन एक ही समय में कुछ पैसे कमा सकता हूं। वर्तमान में, मैं प्रोफाइलर को व्यक्तिगत उपयोग के लिए पूरी तरह से मुफ्त बनाने और कंपनियों के लिए भुगतान करने के बारे में सोच रहा हूं, लेकिन फिर से 20-30 रुपये के न्यूनतम मूल्य पर। खैर, या इसे एक दान बटन के साथ मुक्त छोड़ दें।

ध्यान देने के लिए आप सभी का धन्यवाद।मुझे उम्मीद है कि यह उपकरण उपयोगी होगा।

पुनश्च: सभी प्रश्नों, बग रिपोर्ट और बहुत कुछ के लिए, आप मेल पर लिख सकते हैं: developer@ef-logger.com या st.glushak@gmail.com। इसके अलावा, लेखक एक पक्ष की नौकरी की तलाश में है, क्योंकि एक बंधक। आपकी समझ के लिए धन्यवाद।
EF6 के लिए Nuget पैकेज: https://www.nuget.org/packages/EFlogger-For6/
Nuget पैकेज EF4 के लिए - 5: https://www.nuget.org/packages/EFlogger-For4 & # 39;
अपडेट किया गया: एक सर्वेक्षण जोड़ा गया:

इकाई फ्रेमवर्क के लिए प्रोफाइलर