प्रोग्रामिंग कठिनाइयों के बारे में, या C # हमें नहीं बचाएगा?

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



यह पोस्ट " मम्म ... सुपर भाषा ... मुझे सी ++ कृपया! " पोस्ट में वर्णित मेरे सहयोगी के विचारों को जारी रखती है। उस लेख को जनता के बीच समझ नहीं मिली। अब मैं कोशिश करूंगा।



कटौती के तहत C # में कई अंश हैं, जो लोकप्रिय Microsoft Visual Studio वातावरण में PVS-Studio स्थिर कोड विश्लेषक को एकीकृत करने के लिए मॉड्यूल से लिया गया है। इन अंशों के साथ, मैं उस लेखन को दिखाना चाहता हूं, उदाहरण के लिए, C # में C ++ में लिखना आसान नहीं है। जो लोग बहस करना चाहते हैं - "टिप्पणियों पर वेलकम।" कौन कहना चाहता है कि कोड के लेखक को प्रोग्राम लिखने का तरीका नहीं पता है - यह भी लिखें, हम चर्चा करेंगे।

साधारण कॉम्बोक्स

तो, पहला कोड टुकड़ा छवि से टूलबार पर नोर्मल कॉम्बोबॉक्स में तीन लाइनों में से एक के चयन को संसाधित कर रहा है।



चित्रा 1 - एक सरल तीन-लाइन कॉम्बोक्स



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

  निजी शून्य OnMenuMyDropDownCombo (ऑब्जेक्ट प्रेषक, EventArgs e)
 {
   अगर (e == EventArgs.Empty)
   {
     फेंक (नया तर्कबोधक) ();
   }

   OleMenuCmdEventArgs eventArgs = e के रूप में OleMenuCmdEventArgs;

   अगर (EventArgs! = null)
   {
     string newChoice = eventArgs.InValue स्ट्रिंग के रूप में;
     IntPtr vOut = eventArgs.OutValue;

     अगर (vOut! = IntPtr.Zero && newChoice! = null)
     {
       फेंक (नया तर्कबोधक) ();
     }
     और यदि (vOut! = IntPtr.Zero)
     {
       मार्शल .गैरनेटिव वेरिएंटऑर्बजेक्ट (
         this.currentDropDownComboChoice, vOut);
     }

     और अगर (newChoice! = null)
     {
       bool validInput = false;
       int indexInput = -1;
       के लिए (indexInput = 0;
            indexInput <dropDownComboChoices.Length;
            indexInput ++)
       {
         अगर (स्ट्रिंग .Compare (
             dropDownComboChoices [indexInput], newChoice,
             सच) == 0)
         {
           validInput = true;
           तोड़;
         }
       }

       अगर (मान्य)
       {
         this.currentDropDownComboChoice =
             dropDownComboChoices [indexInput];
         if (currentDropDownComboChoice ==
             Resources.Viva64)
           UseViva64Analysis (अशक्त, अशक्त);
         और यदि (currentDropDownComboChoice ==
                  Resources.GeneralAnalysis)
           UseGeneralAnalysis (अशक्त, अशक्त);
         और यदि (currentDropDownComboChoice ==
                  Resources.VivaMP)
           UseVivaMPAnalysis (अशक्त, अशक्त);
         अन्यथा
         {
           फेंक (नया तर्कबोधक) ();
         }
       }
       अन्यथा
       {
         फेंक (नया तर्कबोधक) ();
       }
     }
     अन्यथा
     {
       फेंक (नया तर्कबोधक) ();
     }
   }
   अन्यथा
   {
     फेंक (नया तर्कबोधक) ();
   }
 } 

और यहाँ IntPtr.Zero और Mars.GetNativeVariantForObject () है? खैर, यह आवश्यक है ... एक साधारण कॉम्बोक्स को संसाधित करना आसान नहीं है।



इसके अलावा, यह कोड पर्याप्त नहीं है। एक ही आकार के बारे में एक नजदीकी OnMenuMyDropDownComboGetList () फ़ंक्शन भी है।



यहाँ C # किसी भी अन्य भाषा से बेहतर नहीं है। नहीं, निश्चित रूप से, यह अच्छा है कि उसने मुझसे OLE, मार्शलिंग को समझाया। सी में, सब कुछ बहुत दुखी होगा। लेकिन यह किसी भी तरह से किसी भी तरह से सभी एक ही है यह कैसे पुस्तकों और इंजीलवादियों में प्रस्तुत नहीं किया गया है। सादगी कहां है? मैं सिर्फ एक ड्रॉप-डाउन सूची के साथ काम करना चाहता था।

विजुअल स्टूडियो में कोड नेविगेशन

जब आप Visual Studio में त्रुटि संदेश पर क्लिक करते हैं, तो फ़ाइल खोलने और त्रुटि के साथ लाइन पर जाने के लिए इस कोड जैसा कुछ ट्रिगर होता है।

  सार्वजनिक शून्य OpenDocumentAndNavigateTo (स्ट्रिंग पथ, int लाइन, 
   इंट कॉलम)
 {
 IVsUIShellOpenDocument ओपनडॉक =
               Package.GetGlobalService (
               टाइपोफ़ (IVsUIShellOpenDocument))
               IVsUIShellOpenDocument के रूप में;
      अगर (OpenDoc == null)
        वापसी;
      IVsWindowFrame फ्रेम;
      Microsoft.VisualStudio.OLE.Interop.IServiceProvider सपा;
      IVsUIHierarchy hier;
      यूंट आइटम;
      गाइड लॉजिकल व्यू = VSConstants.LOGVIEWID_Code;
      अगर (ErrorHandler.Failed)
         OpenDoc.OpenDocumentViaProject (पथ, रेफ तार्किक देखें, 
           बाहर सपा, बाहर hier, बाहर आइटम, बाहर फ्रेम))
             ||  फ्रेम == अशक्त)
               वापसी;
      ऑब्जेक्ट डॉकडेटा;
      फ्रेम। GetProperty ((int) __ VSFPROPID.VSFPROPID_DocData, 
        डॉकडॉट आउट);

      VsTextBuffer बफर = VsTextBuffer के रूप में docData;
      अगर (बफर == अशक्त)
      {
           IVsTextBufferProvider बफरProvider = 
               IVDTextBufferProvider के रूप में docData;
           अगर (बफरप्रोइडर! = अशक्त)
           {
             IVsTextLines लाइनें;
             ErrorHandler.ThrowOnFailure (
               बफरपॉइडर.जीट टेक्स्टबफर (आउट लाइन));
             बफर = VsTextBuffer के रूप में लाइनें;
             अगर (बफर == अशक्त)
               वापसी;
           }
      }
   IVsTextManager mgr = 
     Package.GetGlobalService (टाइपोफ़ (VsTextManagerClass))
     IVsTextManager के रूप में;
   अगर (mgr == null)
     वापसी;
   mgr.NavigateToLineAndColumn (
      बफर, रेफ तार्किक व्यू, लाइन, कॉलम, लाइन, कॉलम);
 } 

यो-माई ... हॉरर। जादू मंत्र का सेट। एक बार C # में लिखे गए इस कोड ने फिर से अपने डेवलपर के लिए जीवन आसान बना दिया। कौन कहता है कि यह XYZ में बेहतर लगेगा? समस्या के हल के लिए यहाँ की भाषा "लंबवत" है और व्यावहारिक रूप से इसका कोई प्रभाव नहीं है।

दिनांक के साथ काम करें

ठीक है, सी # में तारीखों के साथ काम करना बिल्कुल शीर्ष पर होना चाहिए! आखिरकार, बहुत सारे अलग-अलग सुविधाजनक प्रारूप हैं। मैंने सोचा, जब तक बाहरी कार्यक्रम से __time64_t प्रारूप में समय नहीं आया, और C # कोड में DateTime वर्ग का उपयोग करना आवश्यक था।



डेटा टाइम के लिए __time64_t परिवर्तित करना निश्चित रूप से मुश्किल नहीं है, इसके लिए आपको बस इस तरह एक फ़ंक्शन लिखने की आवश्यकता है:

  सार्वजनिक स्थैतिक DateTime Time_T2DateTime (long time_t)
 {
   // 116444736000000000 - यह 1600 है
   long win32FileTime = 10000000 * time_t + 116444736000000000;
   DateTime.FromFileTime (win32FileTime) वापस करें;
 } 

और यहाँ C # बेहतर नहीं निकला ... शायद मुझे रूपांतरण फ़ंक्शन नहीं मिला। ठीक है, वास्तव में डेटाइम के लिए आवश्यक निर्माता बनाना असंभव था? ठीक है, क्यों, पर्यावरण के साथ बातचीत की तरह, फिर से, पुराने फैशन में, आपको "पेन" करना होगा?

एक समाधान की सभी परियोजनाओं की गणना

किसी कार्य के लिए, उन सभी परियोजनाओं को हल करना आवश्यक है जो समाधान (विजुअल स्टूडियो समाधान) में हैं।



एक सरल और सुरुचिपूर्ण फॉर्च्यूनर के बजाय, कोड इस तरह दिखता है:

  Solution2 समाधान = PVSStudio.DTE.Solution समाधान 2 के रूप में;
 SolutionBuild2 solutionBuild = 
     (SolutionBuild2) solution.SolutionBuild;
 SolutionContexts ProjectContexts = 
     solutionBuild.ActiveConfiguration.SolutionContexts;

 int prjCount = projectContexts.Count;
 for (int i = 1; मैं <= prjCount; i ++)
 {
     SolutionContext projectContext = null;
     कोशिश
     {
         projectContext = projectContexts.Item (i);
     }
     पकड़ना (अपवाद)
     {
         // try / catch ब्लॉक एक वर्कअराउंड है। 
         // समाधान पर सही काम करने के लिए इसकी आवश्यकता है 
         // अनलोडेड प्रोजेक्ट्स के साथ।
         जारी रखने के लिए;
     }
 ... 

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

निष्कर्ष

इस पोस्ट के साथ मैं यह बताना चाहता था कि C # (या किसी अन्य भाषा) में कोड हमेशा C / C ++ के कोड से अधिक सरल नहीं होता है। और इसलिए, आँख बंद करके विश्वास करना कि "आपको C # में सब कुछ फिर से लिखना होगा" आवश्यक नहीं है। फिर भी, मैं बिल्कुल नहीं सोचता कि "C # बेकार" है, क्योंकि कई जगहों पर यह वास्तव में जीवन को सरल बनाता है।



क्या कारण हैं कि पोस्ट में बताए गए कोड स्निपेट सी में ++ की तरह ही जटिल दिखते हैं?

1. विभिन्न एपीआई के साथ सहभागिता। उदाहरण के लिए, जैसा कि विजुअल स्टूडियो एपीआई के साथ बातचीत थी।
2. अन्य भाषाओं में कार्यक्रमों के साथ सहभागिता। उदाहरण के लिए, टाइप __time64_t, निश्चित रूप से, C ++ एप्लिकेशन से आया है।
3. ऑपरेटिंग सिस्टम के साथ सहभागिता। यह विंडोज के चेहरे में वास्तविकता के साथ एक सुंदर और सही सी # कोड को डॉक करने के लिए हमेशा संभव है।
4. डेटा प्रोसेसिंग एल्गोरिदम का प्रभाव। यदि आप स्ट्रिंग्स के साथ काम करते हैं, तो कोड में "+1" से आप कहीं भी नहीं जाएंगे, चाहे आप कोई भी भाषा लिखें।

उदाहरणों में प्रयुक्त कोड का औचित्य:

1. टिप्पणियों को काट दिया जाता है, कोड को लेख में न्यूनतम आवश्यक तक घटा दिया जाता है।
2. हां, कोड के लेखक C # में लिखने में सक्षम नहीं हैं, लेकिन इससे C # अधिक जादुई नहीं बनता है।