try / catch + using, sintassi corretta

Quale:

using (var myObject = new MyClass())
{
   try
   {
      // something here...
   }
   catch(Exception ex)
   {
      // Handle exception
   }
}

O

try
{
   using (var myObject = new MyClass())
   {
      // something here...
   }
}
catch(Exception ex)
{
   // Handle exception
}

Preferisco il secondo. Può anche intrappolare errori relativi alla creazione dell'oggetto.

Poiché un blocco using è solo una semplificazione della sintassi di un try / finally ( MSDN ), personalmente sceglierei quanto segue, anche se dubito che sia significativamente diverso dalla tua seconda opzione:

MyClass myObject = null;
try {
  myObject = new MyClass();
  //important stuff
} catch (Exception ex) {
  //handle exception
} finally {
  if(myObject is IDisposable) myObject.Dispose();
}

Dipende. Se si utilizza Windows Communication Foundation (WCF), using(...) { try... }non funzionerà correttamente se il proxy usingnell'istruzione si trova in stato di eccezione, ovvero l'eliminazione di questo proxy causerà un'altra eccezione.

Personalmente, credo nell'approccio di gestione minima, ovvero gestire solo le eccezioni di cui sei a conoscenza al momento dell'esecuzione. In altre parole, se sai che l'inizializzazione di una variabile usingpuò generare una particolare eccezione, la avvolgo con try-catch. Allo stesso modo, se all'interno del usingcorpo può accadere qualcosa, che non è direttamente correlato alla variabile in using, allora la avvolgo con un'altra tryper quella particolare eccezione. Uso raramente Exceptionnei miei catches.

Ma mi piace IDisposablee usinganche se forse sono di parte.

Se la tua dichiarazione catch deve accedere alla variabile dichiarata in un'istruzione using, allora all'interno è l'unica opzione.

Se la tua dichiarazione catch ha bisogno dell'oggetto a cui fa riferimento l'utilizzo prima di essere eliminata, allora all'interno è l'unica opzione.

Se la tua dichiarazione di cattura intraprende un'azione di durata sconosciuta, come la visualizzazione di un messaggio all'utente e desideri disporre delle tue risorse prima che ciò accada, allora l'esterno è l'opzione migliore.

Ogni volta che ho uno scenario simile a questo, il blocco try-catch è di solito in un metodo diverso più avanti nello stack di chiamate dall'uso. Non è tipico per un metodo sapere come gestire le eccezioni che si verificano al suo interno in questo modo.

Quindi la mia raccomandazione generale è fuori, molto fuori.

private void saveButton_Click(object sender, EventArgs args)
{
    try
    {
        SaveFile(myFile); // The using statement will appear somewhere in here.
    }
    catch (IOException ex)
    {
        MessageBox.Show(ex.Message);
    }
}

Entrambe sono sintassi valide. Dipende davvero da cosa vuoi fare: se vuoi catturare errori relativi alla creazione / eliminazione dell'oggetto, usa il secondo. In caso contrario, utilizzare il primo.

C'è una cosa importante che chiamerò qui: la prima non catturerà alcuna eccezione derivante dalla chiamata al MyClasscostruttore.

Da C # 8.0, preferisco usare il secondo come questo

public class Person : IDisposable
{
    public Person()
    {
        int a = 0;
        int b = Id / a;
    }
    public int Id { get; set; }

    public void Dispose()
    {
    }
}

e poi

static void Main(string[] args)
    {

        try
        {
            using var person = new Person();
        }
        catch (Exception ex) when
        (ex.TargetSite.DeclaringType.Name == nameof(Person) &&
        ex.TargetSite.MemberType == System.Reflection.MemberTypes.Constructor)
        {
            Debug.Write("Error Constructor Person");
        }
        catch (Exception ex) when
       (ex.TargetSite.DeclaringType.Name == nameof(Person) &&
       ex.TargetSite.MemberType != System.Reflection.MemberTypes.Constructor)
        {
            Debug.Write("Error Person");
        }
        catch (Exception ex)
        {
            Debug.Write(ex.Message);
        }
        finally
        {
            Debug.Write("finally");
        }
    }

Se l'oggetto che si sta inizializzando nel blocco Using () potrebbe generare un'eccezione, è necessario scegliere la seconda sintassi, altrimenti entrambe ugualmente valide.

Nel mio scenario, ho dovuto aprire un file e stavo passando filePath nel costruttore dell'oggetto che stavo inizializzando nel blocco Using () e potrebbe generare un'eccezione se filePath è errato / vuoto. Quindi, in questo caso, la seconda sintassi ha senso.

Il mio codice di esempio: -

try
{
    using (var obj= new MyClass("fileName.extension"))
    {

    }
}
catch(Exception ex)
{
     //Take actions according to the exception.
}

Da C # 8.0 in poi , è possibile semplificare le usingistruzioni in alcune condizioni per eliminare il blocco nidificato, quindi si applica solo al blocco che lo racchiude.

Quindi i tuoi due esempi possono essere ridotti a:

using var myObject = new MyClass();
try
{
   // something here...
}
catch(Exception ex)
{
   // Handle exception
}

E:

try
{
   using var myObject = new MyClass();
   // something here...
}
catch(Exception ex)
{
   // Handle exception
}

Entrambi sono abbastanza chiari; e quindi ciò riduce la scelta tra i due a una questione di ciò che si desidera raggiungere l'ambito dell'oggetto, dove si desidera gestire gli errori di istanza e quando si desidera eliminarlo.