dene / yakala + kullan, doğru sözdizimi

Hangisi:

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

VEYA

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

İkincisini tercih ederim. Ayrıca nesnenin oluşturulmasıyla ilgili hataları da yakalayabilir.

Bir kullanma bloğu sadece bir try / nihayet ( MSDN ) bir sözdizimi sadeleştirme olduğundan, ikinci seçeneğinizden önemli ölçüde farklı olduğundan şüphe duyuyorum, şahsen aşağıdakilerle giderdim:

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

Değişir. Windows Communication Foundation (WCF) kullanıyorsanız, deyimdeki using(...) { try... }proxy usingistisna durumdaysa düzgün çalışmaz , yani bu proxy'nin kullanılması başka bir istisnaya neden olur.

Şahsen, asgari elleçleme yaklaşımına inanıyorum, yani sadece uygulama noktasında farkında olduğunuz istisnayı ele alacağım. Başka bir deyişle, bir değişkenin başlatılmasının usingbelirli bir istisna atabileceğini biliyorsanız , onu sarıyorum try-catch. Benzer şekilde, usingvücutta değişkenle doğrudan ilgili olmayan bir şey olabilirse using, o tryistisna için başka biriyle sarıyorum. Nadiren kullanmak Exceptionbenim de catches.

Ama böyle yapmak IDisposableve usingböylece olsa belki önyargılı.

Catch ifadenizin bir using ifadesinde bildirilen değişkene erişmesi gerekiyorsa, içerideki tek seçenek budur.

Catch deyiminiz kullanılmadan önce kullanımda başvurulan nesneye ihtiyaç duyuyorsa, içerideki tek seçenek budur.

Catch deyiminiz, kullanıcıya bir mesaj görüntülemek gibi bilinmeyen bir süre boyunca işlem yaparsa ve kaynaklarınızı bundan önce atmak istiyorsanız, dışarıda en iyi seçeneğiniz olur.

Buna benzer bir senaryo bulduğumda, try-catch bloğu genellikle farklı bir yöntemde çağrı yığınını kullanmaktan daha yukarıdadır. Bir yöntemde, bunun içinde meydana gelen istisnaların nasıl ele alınacağını bilmek tipik değildir.

Genel tavsiyem dışarıda, dışarıda.

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

Her ikisi de geçerli sözdizimidir. Gerçekten ne yapmak istediğinize gelir: nesneyi oluşturma / atma ile ilgili hataları yakalamak istiyorsanız, ikincisini kullanın. Değilse, ilkini kullanın.

İlki olacak: Ben burada arayacağım tek önemli şey vardır değil çağırarak kaynaklanan herhangi istisna yakalamak MyClassyapıcı.

C # 8.0'dan, ikincisini aynı şekilde kullanmayı tercih ederim

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

    public void Dispose()
    {
    }
}

ve sonra

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

Using () bloğunda başlattığınız nesne herhangi bir istisna fırlatabilirse, ikinci sözdizimini kullanmalısınız, aksi takdirde her ikisi de eşit derecede geçerlidir.

Senaryomda, bir dosyayı açmak zorunda kaldım ve Using () bloğunda başlattığım nesnenin yapıcısında filePath geçiriyordum ve filePath yanlış / boşsa istisna atabilir. Bu durumda, ikinci sözdizimi mantıklıdır.

Örnek kodum: -

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

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

C # 8.0'dan itibaren using, iç içe bloktan kurtulmak için bazı koşullar altında ifadeleri basitleştirebilirsiniz ve daha sonra sadece kapalı blok için geçerlidir.

Böylece iki örneğiniz aşağıdakilere indirgenebilir:

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

Ve:

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

İkisi de oldukça açık; ve sonra bu ikisi arasındaki seçimi, nesnenin kapsamının ne olmasını istediğiniz, örnekleme hatalarını işlemek istediğiniz yerde ve ne zaman atmak istediğinize bağlıdır.