C#: Equivalente del try pitone/catch/altro blocco

Question

In Python, c'è questo utile codice di gestione delle eccezioni:

try: 
    # Code that could raise an exception 
except Exception: 
    # Exception handling 
else: 
    # Code to execute if the try block DID NOT fail 

Penso che sia utile essere in grado di separare il codice che poteva aumento e eccezione dal tuo codice normale. In Python, questo era possibile come mostrato sopra, tuttavia non riesco a trovare nulla di simile in C#.

Supponendo che la funzione o una come non esista, è prassi normale inserire il codice normale nel blocco try o dopo il blocco catch?

Il motivo che mi chiedo è perché ho il seguente codice:

if (!IsReadOnly) 
{ 
    T newobj; 
    try 
    { 
     newobj = DataPortal.Update<T>(this); 

     List<string> keys = new List<string>(BasicProperties.Keys); 
     foreach (string key in keys) 
     { 
      BasicProperties[key] = newobj.BasicProperties[key]; 
     } 
    } 
    catch (DataPortalException) 
    { 
     // TODO: Implement DataPortal.Update<T>() recovery mechanism 
    } 
} 

che richiede il codice normale essere nel blocco try perché altrimenti se un'eccezione è stata sollevata e successivamente gestito, newobj sarebbe assegnato, ma è abbastanza innaturale avere questo codice nel blocco try che non è correlato allo DataPortalException. Cosa fare?

Grazie

Answer 1

Si potrebbe fare qualcosa di simile:

if (!IsReadOnly) 
{ 
    T newobj = null; 
    try 
    { 
     newobj = DataPortal.Update<T>(this);  
    } 
    catch (DataPortalException) 
    { 
     // TODO: Implement DataPortal.Update<T>() recovery mechanism 
    } 
    if (newobj != null) 
    { 
     List<string> keys = new List<string>(BasicProperties.Keys); 
     foreach (string key in keys) 
     { 
      BasicProperties[key] = newobj.BasicProperties[key]; 
     } 
    } 
} 

Answer 2

che sarebbe la dichiarazione vuota come colpi

try 
{ 
    somethingThatCanThrow(); 
} 
catch(Exception ex) 
{ 
    LogException(ex); 
    return; 
} 
ContinueFlow(); 

Answer 3

preferirei vedere il resto del codice al di fuori del prova/cattura, quindi è chiaro da dove proviene l'eccezione che stai cercando di catturare e che non accidentalmente trovi un'eccezione che non stavi cercando di catturare.

Penso che l'equivalente più vicino a Python try/catch/else sia quello di utilizzare una variabile booleana locale per ricordare se è stata generata o meno un'eccezione.

bool success; 

try 
{ 
    foo(); 
    success = true; 
} 
catch (MyException) 
{ 
    recover(); 
    success = false; 
} 

if (success) 
{ 
    bar(); 
} 

Ma se si sta facendo questo, mi piacerebbe chiedere il motivo per cui non si recuperano sia pienamente l'eccezione in modo che sia possibile continuare come se non ci fosse stato il successo, oppure completamente interrompe restituendo un codice di errore o anche solo lasciare che l'eccezione si propaghi al chiamante.

Answer 4

C# non ha un tale concetto, quindi si è appena lasciato con tre opzioni,

• mettere il codice altro all'interno della prova.
• inserire il codice else all'esterno del blocco catch try, utilizzare una variabile locale per indicare il successo o l'insuccesso e un blocco if nel codice else.
• inserire il codice else nel blocco finally, utilizzare una variabile locale per indicare l'esito positivo o negativo e un blocco if per il codice else else.

Answer 5

Basta inserire il blocco "else" prima del il fermo. Poi, si eseguirà solo se l'esecuzione di codice raggiunge quel punto:

try 
{ 
    fee(); 
    fi(); 
    foe(); 
    fum(); 

    /// put your "else" stuff here. 
    /// It will only be executed if fee-fi-foe-fum did not fail. 
} 
catch(Exception e) 
{ 
    // handle exception 
} 

Dato che, non riesco a vedere l'uso di try..catch ... altro a meno che non ci sia qualcosa di vitale manca dalla descrizione del PO.

Answer 6

Consentitemi di ripetere un'idea da un similar StackOverflow question. Non puoi farlo direttamente, ma puoi scrivere un metodo che incapsula il comportamento di cui hai bisogno. Osserva la domanda originale per vedere come implementare il metodo (se non hai familiarità con espressioni lambda e delegati Func). L'utilizzo potrebbe assomigliare a questo:

TryExceptRaise(() => { 
    // code that can throw exception 
    }, (Exception e) => { 
    // code to run in case of an exception 
    return (...); 
    },() => { 
    // code to run if there is no exception 
    return (...); 
    }); 

Answer 7

soluzione Barbaric: creare una classe derivata da Exception Else, lanciare un'istanza alla fine del blocco try, e utilizzare catch (Else) {...} per gestire le altre cose.

Mi sento così sporco.

Answer 8

Questo potrebbe essere downvoted ma non C# ha goto (nota che non ho quasi nessuna conoscenza di C# quindi non ho idea se questo funziona).

che dire qualcosa di simile

try 
{ 
... 
} 
catch(Exception ex) 
{ 
... 
goto Jump_past_tryelse 
} 
...//Code to execute if the try block DID NOT fail 

Jump_past_tryelse: 
... 

Answer 9

if (!IsReadOnly) 
     { 
      T newobj; 
      bool Done; 
      try 
      { 
       newobj = DataPortal.Update<T>(this); 
       List<string> keys = new List<string>(BasicProperties.Keys); 
       foreach (string key in keys) 
       { 
        BasicProperties[key] = newobj.BasicProperties[key]; 
       } 
       Done = true; 
      } 
      catch (DataPortalException) 
      { 
       // TODO: Implement DataPortal.Update<T>() recovery mechanism 
       Done = false; 
      } 
      finally 
      { 
       if (newobj != null && Done == false) 
       { 
        List<string> keys = new List<string>(BasicProperties.Keys); 
        foreach (string key in keys) 
        { 
         BasicProperties[key] = newobj.BasicProperties[key]; 
        } 
       } 
      } 
     } 

Answer 10

Con C# versione 7, si potrebbe usare funzioni locali per emulare questo comportamento:

Esempio 1:

void Main() 
{ 
    void checkedCode() 
    { 
     try 
     { 
      foo(); 
     } 
     catch (Exception ex) 
     { 
      recover(); 
      return; 
     } 
     // ElseCode here 
    } 
    checkedCode(); 
} 

Se si preferisce sintassi lambda, si potrebbe anche dichiarare un metodo run

void Run(Action r) { r(); } 

che ha solo bisogno di essere lì una volta nel codice, e quindi utilizzare il modello per i metodi anonimi come segue

esempio 2:

Run(() => { 
    try 
    { 
     foo(); 
    } 
    catch (Exception) 
    { 
     recover(); 
     return; 
    } 
    // ElseCode here 
}); 

dovunque è necessario racchiudere il codice in un contesto di sicurezza.

---

Note:

• In entrambi gli esempi un contesto funzione viene creato in modo che possiamo utilizzare return; per uscire in caso di errore.
• Un modello simile a quello utilizzato in Esempio 2 è possibile trovare in JavaScript: Self-invoking anonymous functions (ad esempio, JQuery li utilizza). Poiché in C# non puoi autoinvocare, viene utilizzato il metodo helper Run.
• Dal Run non deve essere una funzione locale, Esempio 2 funziona con le versioni più vecchie # C così