try / catch + using, richtige Syntax

Welcher:

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

ODER

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

Ich bevorzuge den zweiten. Kann auch Fehler in Bezug auf die Erstellung des Objekts einfangen.

Da ein using-Block nur eine Syntaxvereinfachung eines try / finally ( MSDN ) ist, würde ich persönlich Folgendes tun, obwohl ich bezweifle, dass er sich erheblich von Ihrer zweiten Option unterscheidet:

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

Es hängt davon ab, ob. Wenn Sie Windows Communication Foundation (WCF) verwenden, using(...) { try... }funktioniert dies nicht ordnungsgemäß, wenn sich der Proxy in der usingAnweisung im Ausnahmestatus befindet. Das Entsorgen dieses Proxys führt zu einer weiteren Ausnahme.

Persönlich glaube ich an einen minimalen Handhabungsansatz, dh nur an eine Ausnahme, die Ihnen zum Zeitpunkt der Ausführung bekannt ist. Mit anderen Worten, wenn Sie wissen, dass die Initialisierung einer Variablen in usingeine bestimmte Ausnahme auslösen kann, schließe ich sie mit ein try-catch. In ähnlicher Weise, wenn innerhalb des usingKörpers etwas passieren kann, das nicht direkt mit der Variablen in zusammenhängt using, dann verpacke ich es tryfür diese bestimmte Ausnahme mit einem anderen . Ich benutze selten Exceptionin meinen catches.

Aber ich mag IDisposable und usingobwohl ich vielleicht voreingenommen bin.

Wenn Ihre catch-Anweisung auf die in einer using-Anweisung deklarierte Variable zugreifen muss, ist inside Ihre einzige Option.

Wenn Ihre catch-Anweisung das Objekt benötigt, auf das in der Verwendung verwiesen wird, bevor es entsorgt wird, ist inside Ihre einzige Option.

Wenn Ihre catch-Anweisung eine Aktion von unbekannter Dauer ausführt, z. B. das Anzeigen einer Nachricht an den Benutzer, und Sie Ihre Ressourcen vorher entsorgen möchten, ist außerhalb Ihre beste Option.

Immer wenn ich ein ähnliches Szenario habe, befindet sich der Try-Catch-Block normalerweise in einer anderen Methode weiter oben im Aufrufstapel als die Verwendung. Es ist nicht typisch für eine Methode, zu wissen, wie mit Ausnahmen umgegangen wird, die in dieser Methode auftreten.

Meine allgemeine Empfehlung ist also draußen - weit draußen.

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);
    }
}

Beide sind gültige Syntax. Es kommt wirklich darauf an, was Sie tun möchten: Wenn Sie Fehler beim Erstellen / Entsorgen des Objekts feststellen möchten, verwenden Sie die zweite. Wenn nicht, verwenden Sie die erste.

Es ist eine wichtige Sache , die ich hier aus anrufen würde: Die erste wird nicht jede Ausnahme fängt die sich aus aufrufen MyClassKonstruktor.

Ab C # 8.0 bevorzuge ich die zweite

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

    public void Dispose()
    {
    }
}

und dann

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");
        }
    }

Wenn das Objekt, das Sie im Block Using () initialisieren, möglicherweise eine Ausnahme auslöst, sollten Sie die zweite Syntax verwenden, andernfalls sind beide gleichermaßen gültig.

In meinem Szenario musste ich eine Datei öffnen und habe filePath im Konstruktor des Objekts übergeben, das ich im Using () -Block initialisiert habe, und es kann eine Ausnahme auslösen, wenn der filePath falsch / leer ist. In diesem Fall ist die zweite Syntax also sinnvoll.

Mein Beispielcode: -

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

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

Ab C # 8.0 können Sie vereinfachenusing Anweisungen unter bestimmten Bedingungen , um den verschachtelten Block zu entfernen. Dies gilt dann nur für den umschließenden Block.

So können Ihre beiden Beispiele reduziert werden auf:

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

Und:

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

Beide sind ziemlich klar; Dies reduziert die Auswahl zwischen beiden auf die Frage, wie der Umfang des Objekts aussehen soll, wo Instanziierungsfehler behandelt werden sollen und wann Sie es entsorgen möchten.