Catching Exception inside Using statement

Question

So che l'istruzione Using elimina l'oggetto che si sta creando. Come se volevo fare qualcosa di simile:

Using(SqlConnection conn = new SqlConnection(connString)) 
    { 
     //some code 
     //How to show the users if conn is not opened up or generated some kind of error? 
    } 

Come mostrare agli utenti se conn non viene aperto o generato qualche tipo di errore?

Answer 1

using non offre alcuna backdoor nello catch.

semplicemente espandere manualmente (inutile avere il try/catch all'interno del usando IMO):

SqlConnection conn = null; 

try 
{ 
    conn = new SqlConnection(""); 
} 
catch ... 
{ 

} 
finally 
{ 
    if (conn != null) 
     conn.Dispose(); 
} 

prediligo questo oltre avvolgendo il using in un try-catch o incorporare un try-catch nel using la maggior parte del tempo per evitare che il codice finisca con uno try-catch nidificato una volta compilato. Se hai solo bisogno di coprire un sottogruppo molto piccolo di un grande pezzo di codice all'interno di uno using, tuttavia, sarei più granulare e lo incorporo.

Answer 2

Non c'è niente di speciale su codice scritto all'interno di un blocco using - basta usare un try.catch per gestire le eccezioni:

using(SqlConnection conn = new SqlConnection(connString)) 
{ 
    try 
    { 
     conn.Open(); 
     // do more stuff here...... 

    } 
    catch(SqlException sqlEx) 
    { 
     // log error and possibly show to user in a MessageBox or something else 
    } 
} 

Il using(...) { ... } blocco stesso è stato progettato solo al fine di garantire che la risorsa/oggetto che "incapsula" è correttamente smaltito quando non è più necessario. Non c'è nulla che tu possa fare con l'istruzione using per far sì che gestisca gli errori.

Quindi, se si prevede che solo la creazione dell'oggetto potrebbe fallire, allora si avrebbe dovuto mettere l'intero using blocco all'interno del blocco try ... catch, o ripiegare ad un blocco try ... catch ... finally e garantire il corretto smaltimento te stesso (come Adam ha suggerito nel suo risposta).

Answer 3

Questo è esattamente come lo faresti senza.

using(SqlConnection conn = new SqlConnection(connString)) 
{ 
    try{ 
    //some code 
    } 
    catch(SqlException e) 
    MessageBox.Show(e.Message); 
} 

Answer 4

Proprio in modo normale:

In entrambi i

try 
{ 
    using(SqlConnection conn = new SqlConnection(connString)) 
    { 
     //some code   
    } 
} 
catch (Exception exc) 
{ 
    //handle error 
} 

o

using(SqlConnection conn = new SqlConnection(connString)) 
{ 
    try 
    { 
     //some code 
    } 
    catch (Exception exc) 
    { 
     //handle error 
    }     
} 

Answer 5

Non lo fanno all'interno del using

try 
{ 
    using(SqlConnection conn = new SqlConnection(connString)) 
    { 
     // Some code for when "conn" is succesfully instantiated 
    } 
} 
catch (SomeSpecificConnectionInstantiationException ex) 
{ 
    // Use ex to handle a bizarre instantiation exception? 
}  

Answer 6

class SqlConnection 
{ 
    using(sqlConnection) 
    { 

    } 
} 

class Consumer 
{ 
    try 
    { 

    } 
    catch(SqlException) 
    { 

    } 

} 

Spetta al consumatore della classe decidere cosa fare con l'eccezione.

Answer 7

Come altre risposte hanno dichiarato, è sufficiente aggiungere un normale try/catch.

Tuttavia, vorrei aggiungere che questo è sbagliato posto mettere che try/catch, soprattutto se il tuo obiettivo è "mostrare gli utenti" un messaggio. Lascia che l'eccezione si verifichi a questo livello e permetti che bolla lo stack al codice che è in una posizione migliore per sapere come rispondere ad esso.

In altre parole, lasciare il codice di esempio così com'è. Non aggiungere nulla di nuovo ... a quel metodo. Ma forse il codice che chiama questo metodo dovrebbe pensare a come gestire un'eccezione ... qualsiasi eccezione ... dal database.

Answer 8

È consigliabile utilizzare try {} catch() {} nell'istruzione using se si desidera rilevare un'eccezione generata dal codice all'interno del blocco using. Ora, prendi in considerazione i seguenti due esempi: questo spiega perché il blocco try-catch all'interno dell'istruzione using è una buona pratica.

Esempio 1

 try{ 
      using(SomeObject so = new SomeObject){ 
       // Perform some tasks 
      } 
     }catch(SomeException objSomeException){ 
      // Perform some actions, if exception occurs 
     } 

Esempio 2

 using(SomeObject so = new SomeObject){ 
      try{  
       // Perform some tasks 
       }catch(SomeException objSomeException){ 
        // Perform some actions, if exception occurs 
       } 
     } 

Ora, se si verifica un'eccezione durante l'esecuzione di alcune attività all'interno della istruzione using, saranno entrambi ad esempio avere la stesso risultato. La semplice risposta è no, motivo ???

Quando si verifica un'eccezione nell'esempio 1, viene catturata dal blocco catch, senza raggiungere la fine del blocco using. Pertanto, someObject nell'esempio 1 non verrà eliminato correttamente. Anche se CLR è generoso (su cui non dovresti contare) - la memoria utilizzata da someObject nell'esempio 1 non verrà ripristinata (o il massimo finirà nella raccolta GC di Generazione 2).

Nel caso dell'esempio 2, il blocco di cattura si trova all'interno dell'istruzione using. Ciò significa che l'esecuzione raggiungerà la fine del blocco using. Pertanto, il tuo oggetto sarà eliminato e non dovrai preoccuparti della perdita di memoria (deterioramento,

Answer 9

Quando si incorpora il blocco using() all'interno di try/catch, il blocco using() garantisce effettivamente che Dispose Tuttavia, se il codice non gestito in qualsiasi punto all'interno del blocco utilizza genera un'eccezione, l'uso di() lo mangerà e non raggiungerà il problema. Utilizza try/catch nel blocco using(), salta using() e fai un try/catch/finally, o usa la sintassi dispari "using() try" con un blocco catch (che ti lascia con un numero dispari di parentesi ed è probabile che confonda i diavoli di programmatori di medio livello che successivamente incontreranno