कोशिश/पकड़ ब्लॉक का उपयोग कब करें?

Question

मैं अपने पढ़ने किया है और समझते हैं कि एक आज़माएं/कैच ब्लॉक करता है और एक का उपयोग करने कारण है कि यह महत्वपूर्ण है है। लेकिन मैं जानते हुए भी जब/जहां उन्हें इस्तेमाल करने पर अटक कर रहा हूँ। कोई सलाह? मैं आशा करता हूं कि मेरे उदाहरण के लिए कुछ सिफारिशें करने के लिए कुछ समय है, मैं नीचे दिए गए कोड का एक नमूना पोस्ट करूंगा।

public AMPFileEntity(string filename) 
    { 
     transferFileList tfl = new transferFileList(); 
     _AMPFlag = tfl.isAMPFile(filename); 
     _requiresPGP = tfl.pgpRequired(filename); 
     _filename = filename.ToUpper(); 
     _fullSourcePathAndFilename = ConfigurationSettings.AppSettings.Get("sourcePath") + _filename; 
     _fullDestinationPathAndFilename = ConfigurationSettings.AppSettings.Get("FTPStagePath") + _filename; 
     _hasBeenPGPdPathAndFilename = ConfigurationSettings.AppSettings.Get("originalsWhichHaveBeenPGPdPath"); 
    } 


    public int processFile() 
    { 

     StringBuilder sb = new StringBuilder(); 
     sb.AppendLine(" "); 
     sb.AppendLine(" --------------------------------"); 
     sb.AppendLine("  Filename: " + _filename); 
     sb.AppendLine("  AMPFlag: " + _AMPFlag); 
     sb.AppendLine("  Requires PGP: " + _requiresPGP); 
     sb.AppendLine(" --------------------------------"); 
     sb.AppendLine(" "); 

     string str = sb.ToString(); 
     UtilityLogger.LogToFile(str); 
     if (_AMPFlag) 
     { 
      if (_requiresPGP == true) 
      { 
       encryptFile(); 
      } 
      else 
      { 
       UtilityLogger.LogToFile("This file does not require encryption. Moving file to FTPStage directory."); 
       if (File.Exists(_fullDestinationPathAndFilename)) 
       { 
        UtilityLogger.LogToFile(_fullDestinationPathAndFilename + " alreadyexists. Archiving that file."); 
        if (File.Exists(_fullDestinationPathAndFilename + "_archive")) 
        { 
         UtilityLogger.LogToFile(_fullDestinationPathAndFilename + "_archive already exists. Overwriting it."); 
         File.Delete(_fullDestinationPathAndFilename + "_archive"); 
        } 
        File.Move(_fullDestinationPathAndFilename, _fullDestinationPathAndFilename + "_archive"); 
       } 
       File.Move(_fullSourcePathAndFilename, _fullDestinationPathAndFilename); 
      } 
     } 
     else 
     { 
      UtilityLogger.LogToFile("This file is not an AMP transfer file. Skipping this file."); 
     } 

      return (0); 
    } 


    private int encryptFile() 
    { 

     UtilityLogger.LogToFile("This file requires encryption. Starting encryption process."); 


     // first check for an existing PGPd file in the destination dir. if exists, archive it - otherwise this one won't save. it doesn't overwrite. 
     string pgpdFilename = _fullDestinationPathAndFilename + ".PGP"; 



     if(File.Exists(pgpdFilename)) 
     { 
      UtilityLogger.LogToFile(pgpdFilename + " already exists in the FTPStage directory. Archiving that file."); 
      if(File.Exists(pgpdFilename + "_archive")) 
      { 
       UtilityLogger.LogToFile(pgpdFilename + "_archive already exists. Overwriting it."); 
       File.Delete(pgpdFilename + "_archive"); 
      } 
      File.Move(pgpdFilename, pgpdFilename + "_archive"); 
     } 

     Process pProc = new Process(); 
     pProc.StartInfo.FileName = "pgp.exe"; 

     string strParams = @"--encrypt " + _fullSourcePathAndFilename + " --recipient infinata --output " + _fullDestinationPathAndFilename + ".PGP"; 

     UtilityLogger.LogToFile("Encrypting file. Params: " + strParams); 
     pProc.StartInfo.Arguments = strParams; 
     pProc.StartInfo.UseShellExecute = false; 
     pProc.StartInfo.RedirectStandardOutput = true; 
     pProc.Start(); 
     pProc.WaitForExit(); 

     //now that it's been PGPd, save the orig in 'hasBeenPGPd' dir 
     UtilityLogger.LogToFile("PGP encryption complete. Moving original unencrypted file to " + _hasBeenPGPdPathAndFilename); 
     if(File.Exists(_hasBeenPGPdPathAndFilename + _filename + "original_which_has_been_pgpd")) 
     { 
      UtilityLogger.LogToFile(_hasBeenPGPdPathAndFilename + _filename + "original_which_has_been_pgpd already exists. Overwriting it."); 
      File.Delete(_hasBeenPGPdPathAndFilename + _filename + "original_which_has_been_pgpd"); 
     } 
      File.Move(_fullSourcePathAndFilename, _hasBeenPGPdPathAndFilename + _filename + "original_which_has_been_pgpd"); 

     return (0); 

    } 
} 

}

Answer 1

अंगूठे का बुनियादी नियम को पकड़ने के लिए अपवाद पकड़ अपवाद यदि और केवल यदि आप उन्हें से निपटने में एक सार्थक तरीके से है।

नहीं पकड़ एक अपवाद अगर आप केवल अपवाद लॉग इन करें और यह ढेर ऊपर फेंक करने जा रहे हैं मत करो। यह कोई मतलब और अव्यवस्था कोड परोसता है।

अपवाद प्राप्त करें जब आप अपने कोड के एक विशिष्ट भाग में विफलता की उम्मीद कर रहे हैं, और यदि आपके पास इसके लिए फॉलबैक है।

बेशक आप हमेशा जांचे हुए अपवादों जो तुम कोशिश/पकड़ ब्लॉक का उपयोग करने की आवश्यकता होती है, ऐसी स्थिति में आप कोई अन्य विकल्प नहीं है के मामले है। यहां तक ​​कि एक अपवाद के साथ भी, सुनिश्चित करें कि आप ठीक से लॉग इन करें और यथासंभव स्वच्छ रूप से संभाल लें।

Answer 2

Exceptions and Exception Handling (C# Programming Guide)

Exceptions and Exception Handling (C# Programming Guide) अपडेट किया गया लिंक (एमएस) के द्वारा हालांकि अन्य अभी भी चालू है।

Exception Handling (C# Programming Guide)

Answer 3

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

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

आपके मामले में, आप File.Exists जो अच्छा है का उपयोग कर रहे हैं, लेकिन उनकी संभवतः डिस्क है कि एक और त्रुटि है कि File.Exists नहीं संभाल कर सकते हैं फेंक सकता है के साथ एक और समस्या। हाँ, यह एक बूलियन विधि है, लेकिन कहते हैं कि फ़ाइल अवरोधित किया गया है और क्या होता है अगर आप इसे करने के लिए लिखने की कोशिश? पकड़ने के साथ, आप एक दुर्लभ परिदृश्य के लिए योजना बना सकते हैं, लेकिन कोशिश/पकड़/आखिरकार, आप कोड को पूरी तरह से अप्रत्याशित परिस्थितियों में उजागर कर सकते हैं।

Answer 4

अन्य लोग काफी अच्छा संकेत दिए गए और अनेक संदर्भ उपस्थित दिया है।

मेरा इनपुट एक छोटा सा है:
इसका उपयोग कब करना है, समान रूप से या अधिक आयातक रूप से इसका उपयोग कैसे किया जाए।

पीएस: "यह" "कोशिश करने वाले अपवादों" को रेफर कर रहा है।

Answer 5

कुछ अन्य लोगों की तरह कहा है, आप कोड के चारों ओर प्रयास पकड़ ब्लॉक का उपयोग करना चाहते हैं जो एक अपवाद फेंक सकता है और आप इससे निपटने के लिए तैयार हैं।

आपके लिए विशेष उदाहरण, फ़ाइल। डिलीट IOException, UnauthorizedAccessException के साथ-साथ अन्य सहित कई अपवाद भी फेंक सकता है। आप उन परिस्थितियों में अपने आवेदन को क्या करना चाहते हैं? यदि आप फ़ाइल को हटाने का प्रयास करते हैं लेकिन कहीं और इसका उपयोग कर रहा है, तो आपको IOException मिलेगा।

try 
    {  
     File.Delete(pgpdFilename + "_archive") 
    } 
    catch(IOException) 
    { 
     UtilityLogger.LogToFile("File is in use, could not overwrite."); 
     //do something else meaningful to your application 
     //perhaps save it under a different name or something 
    } 

यह भी ध्यान रखें कि अगर यह असफल है, तो आप अपने File.Move ब्लॉक अगले भी (फिर से एक IOException विफल हो जाएगा यदि के बाहर करते हैं - के बाद से फ़ाइल को नहीं हटाया गया यह अभी भी वहाँ है जो कदम विफल होने का कारण बन जाएगा)।