try-catch (C# Başvurusu)try-catch (C# Reference)

Try-catch deyiminin oluşan bir try blok izlenen bir veya daha fazla tarafından catch farklı özel durumlar için işleyiciler belirten yan tümceleri.The try-catch statement consists of a try block followed by one or more catch clauses, which specify handlers for different exceptions.

AçıklamalarRemarks

Ortak dil çalışma zamanı (CLR) bir özel durum oluştuğunda arar catch bu özel durumu işleyen bir ifade.When an exception is thrown, the common language runtime (CLR) looks for the catch statement that handles this exception. Şu anda yürütülen yöntemi gibi içermiyorsa bir catch engelleme, vb. çağrı yığınında yukarı geçerli bir yöntemi çağıran yönteme CLR bakar.If the currently executing method does not contain such a catch block, the CLR looks at the method that called the current method, and so on up the call stack. Hayır ise catch bloğu bulundu ve ardından CLR kullanıcıya bir işlenmeyen özel durum iletisi görüntüler ve programın yürütülmesini durdurur.If no catch block is found, then the CLR displays an unhandled exception message to the user and stops execution of the program.

try Bloğu özel durumuna neden olabilir korunan kodu içerir.The try block contains the guarded code that may cause the exception. Blok, bir özel durum veya başarıyla tamamlanana kadar yürütülür.The block is executed until an exception is thrown or it is completed successfully. Aşağıdaki örnek, atama yapmayı bir null nesne harekete geçirirse NullReferenceException özel durum:For example, the following attempt to cast a null object raises the NullReferenceException exception:

object o2 = null;
try
{
    int i2 = (int)o2;   // Error
}

Ancak catch yan tümcesi bağımsız değişkenler herhangi bir türde özel durum yakalamak için kullanılabilir, bu kullanım önerilmez.Although the catch clause can be used without arguments to catch any type of exception, this usage is not recommended. Genel olarak, yalnızca, kurtarılır biliyorsunuz özel durumları yakalamalısınız.In general, you should only catch those exceptions that you know how to recover from. Bu nedenle, her zaman türetilen bir nesne bağımsız değişkeni belirtmeniz gerekir System.Exception örneğin:Therefore, you should always specify an object argument derived from System.Exception For example:

catch (InvalidCastException e)
{
}

Birden fazla özel kullanmak da mümkündür catch aynı try-catch deyiminin yan tümcesi.It is possible to use more than one specific catch clause in the same try-catch statement. Bu durumda, sırası catch yan tümceleri önemlidir çünkü catch yan tümceleri sırayla incelenir.In this case, the order of the catch clauses is important because the catch clauses are examined in order. Less yazımına özgü olanlardan önce daha özel istisnaları yakalayın.Catch the more specific exceptions before the less specific ones. Böylece bir sonraki bloğuna hiç ulaşılmadı, catch engeller sipariş, derleyici bir hata oluşturur.The compiler produces an error if you order your catch blocks so that a later block can never be reached.

Kullanarak catch bağımsız değişkenler, işlemek istediğiniz özel durumları filtrelemek için bir yoludur.Using catch arguments is one way to filter for the exceptions you want to handle. Daha fazla uygulayacağınıza karar vermek için özel durum inceleyen bir özel durum filtresi de kullanabilirsiniz.You can also use an exception filter that further examines the exception to decide whether to handle it. Ardından, özel durum filtresi false döndürürse, işleyici için arama devam eder.If the exception filter returns false, then the search for a handler continues.

catch (ArgumentException e) when (e.ParamName == "…")
{
}

Özel durum filtreleri yakalama ve filtreleri yaralanmadığı türde yığın bıraktığınızdan (aşağıda anlatıldığı) yeniden atma tercih edilir.Exception filters are preferable to catching and rethrowing (explained below) because filters leave the stack unharmed. Bir sonraki işleyici yığın dökümleri, nereden özel durumun ilk olarak, bunu döndükten hemen son yer yerine geldiğini görebilirsiniz.If a later handler dumps the stack, you can see where the exception originally came from, rather than just the last place it was rethrown. Özel durum filtre ifadeleri yaygın kullanımı günlüğe kaydetme.A common use of exception filter expressions is logging. Her zaman yeniden oluşturma ve bunları işlemek zorunda kalmadan ilerledikçe özel durumları günlüğe kaydetmek bir günlük için de çıkarır false döndüren bir filtre oluşturabilirsiniz.You can create a filter that always returns false that also outputs to a log, you can log exceptions as they go by without having to handle them and rethrow.

A throw deyimi kullanılabilir bir catch blok tarafından yakalanan özel durumu yeniden harekete geçirileceğini catch deyimi.A throw statement can be used in a catch block to re-throw the exception that is caught by the catch statement. Aşağıdaki örnekte kaynak bilgileri ayıklayan bir IOException özel durum ve ardından üst yöntemi özel durum oluşturur.The following example extracts source information from an IOException exception, and then throws the exception to the parent method.

catch (FileNotFoundException e)
{
    // FileNotFoundExceptions are handled here.
}
catch (IOException e)
{
    // Extract some information from this exception, and then 
    // throw it to the parent method.
    if (e.Source != null)
        Console.WriteLine("IOException source: {0}", e.Source);
    throw;
}

Bir özel durumu yakalar ve farklı bir özel durum.You can catch one exception and throw a different exception. Bunu yaptığınızda, aşağıdaki örnekte gösterildiği gibi iç özel durum Yakalanan özel durum belirtin.When you do this, specify the exception that you caught as the inner exception, as shown in the following example.

catch (InvalidCastException e) 
{
    // Perform some action here, and then throw a new exception.
    throw new YourCustomException("Put your error message here.", e);
}

Belirtilen bir koşul true olduğunda aşağıdaki örnekte gösterildiği gibi ayrıca bir özel durum yeniden oluşturabilecek.You can also re-throw an exception when a specified condition is true, as shown in the following example.

catch (InvalidCastException e)
{
    if (e.Data == null)
    {
        throw;
    }
    else
    {
        // Take some action.
    }
}

Not

Genellikle daha net bir şekilde (aynı zamanda bu belgede daha önce açıklandığı gibi yığını değiştirme değil) benzer bir sonuç almak için bir özel durum filtresi kullanmak da mümkündür.It is also possible to use an exception filter to get a similar result in an often cleaner fashion (as well as not modifying the stack, as explained earlier in this document). Aşağıdaki örnek, önceki örnek olarak arayanlar için benzer bir davranış sahiptir.The following example has a similar behavior for callers as the previous example. İşlevin InvalidCastException çağırana geri olduğunda e.Data olduğu null.The function throws the InvalidCastException back to the caller when e.Data is null.

catch (InvalidCastException e) when (e.Data != null) 
{
    // Take some action.
}

Gelen içinde bir try sıralamadaki bildirilen değişkenlerini başlatmak, engelleyin.From inside a try block, initialize only variables that are declared therein. Aksi takdirde, bloğun yürütülmesini tamamlanmadan önce bir özel durum ortaya çıkabilir.Otherwise, an exception can occur before the execution of the block is completed. Örneğin, aşağıdaki kod örneği, değişken içinde n içinde başlatılan try blok.For example, in the following code example, the variable n is initialized inside the try block. Bu değişken dışında kullanma girişimi try engelleyin Write(n) deyimi bir derleyici hatası üretir.An attempt to use this variable outside the try block in the Write(n) statement will generate a compiler error.

static void Main() 
{
    int n;
    try 
    {
        // Do not initialize this variable here.
        n = 123;
    }
    catch
    {
    }
    // Error: Use of unassigned local variable 'n'.
    Console.Write(n);
}

Yakalama hakkında daha fazla bilgi için bkz: try-catch-finally.For more information about catch, see try-catch-finally.

Zaman uyumsuz yöntemlerde özel durumlarıExceptions in Async Methods

Zaman uyumsuz bir yöntem tarafından işaretlenen bir zaman uyumsuz değiştiricisi ve genellikle bir içeriyor ya da daha fazla await ifadeler veya deyimler.An async method is marked by an async modifier and usually contains one or more await expressions or statements. Await ifadesi geçerli await işleci bir Task veya Task<TResult>.An await expression applies the await operator to a Task or Task<TResult>.

Ulaştığında denetlemek bir await awaited görevi tamamlanıncaya kadar zaman uyumsuz yöntemin yöntem ediyor askıya alındı.When control reaches an await in the async method, progress in the method is suspended until the awaited task completes. Görev tamamlandığında, yürütme yönteminde devam edebilir.When the task is complete, execution can resume in the method. Daha fazla bilgi için Asynchronous Programming with async ve await ve zaman uyumsuz programlarda akış kontrolü.For more information, see Asynchronous Programming with async and await and Control Flow in Async Programs.

Tamamlanan görev await uygulanan hatalı bir durumda, görev döndüren yöntem içinde işlenmeyen bir özel durum nedeniyle olabilir.The completed task to which await is applied might be in a faulted state because of an unhandled exception in the method that returns the task. Bekleyen görev özel durum oluşturur.Awaiting the task throws an exception. Bunu döndüren zaman uyumsuz işlem iptal edilirse bir görev bir iptal edildi durumunda da kalabilirsiniz.A task can also end up in a canceled state if the asynchronous process that returns it is canceled. Bekleyen iptal edilen bir görev oluşturur bir OperationCanceledException.Awaiting a canceled task throws an OperationCanceledException. Zaman uyumsuz bir işlem iptal etme hakkında daha fazla bilgi için bkz. Fine-Tuning Async uygulamanızda.For more information about how to cancel an asynchronous process, see Fine-Tuning Your Async Application.

Özel durum yakalamak için görev await bir try engelleyin ve özel durum ilişkili catch catch blok.To catch the exception, await the task in a try block, and catch the exception in the associated catch block. Örneğin, "Örnek" bölümüne bakın.For an example, see the "Example" section.

Beklenen zaman uyumsuz yöntemin birden çok özel durum oluştuğu için bir görev hatalı bir durumda olabilir.A task can be in a faulted state because multiple exceptions occurred in the awaited async method. Örneğin, görev yapılan bir çağrının sonucu olabilir Task.WhenAll.For example, the task might be the result of a call to Task.WhenAll. Böyle bir görevi beklerken, yakalanan özel durumlardan yalnızca birini ve özel durum yakalandı tahmin edemezsiniz.When you await such a task, only one of the exceptions is caught, and you can't predict which exception will be caught. Örneğin, "Örnek" bölümüne bakın.For an example, see the "Example" section.

ÖrnekExample

Aşağıdaki örnekte, try bloğu içeren bir çağrı ProcessString yönteminin bir özel durumuna neden olabilir.In the following example, the try block contains a call to the ProcessString method that may cause an exception. catch Yan tümcesi içeren özel durum işleyici, yalnızca ekranda bir ileti görüntüler.The catch clause contains the exception handler that just displays a message on the screen. Zaman throw deyimi çağrılır içindeki MyMethod, sistem arar catch deyimi ve iletisini görüntüler Exception caught.When the throw statement is called from inside MyMethod, the system looks for the catch statement and displays the message Exception caught.

class TryFinallyTest
{
    static void ProcessString(string s)
    {
        if (s == null)
        {
            throw new ArgumentNullException();
        }
    }

    static void Main()
    {
        string s = null; // For demonstration purposes.

        try
        {               
            ProcessString(s);
        }
        catch (Exception e)
        {
            Console.WriteLine("{0} Exception caught.", e);
        }
    }
}
/*
Output:
System.ArgumentNullException: Value cannot be null.
   at TryFinallyTest.Main() Exception caught.
 * */

ÖrnekExample

Aşağıdaki örnekte, iki catch blokları kullanılır ve ilk birlikte gelen en özel durum yakalandı.In the following example, two catch blocks are used, and the most specific exception, which comes first, is caught.

En az spesifiğe istisna yakalamak için throw deyiminde değiştirebilirsiniz ProcessString şu ifadeyle: throw new Exception().To catch the least specific exception, you can replace the throw statement in ProcessString with the following statement: throw new Exception().

En az Özel catch bloğu ilk örnekte yerleştirirseniz aşağıdaki hata iletisi görüntülenir: A previous catch clause already catches all exceptions of this or a super type ('System.Exception').If you place the least-specific catch block first in the example, the following error message appears: A previous catch clause already catches all exceptions of this or a super type ('System.Exception').

class ThrowTest3
{
    static void ProcessString(string s)
    {
        if (s == null)
        {
            throw new ArgumentNullException();
        }
    }

    static void Main()
    {
        try
        {
            string s = null;
            ProcessString(s);
        }
        // Most specific:
        catch (ArgumentNullException e)
        {
            Console.WriteLine("{0} First exception caught.", e);
        }
        // Least specific:
        catch (Exception e)
        {
            Console.WriteLine("{0} Second exception caught.", e);
        }
    }
}
/*
 Output:
 System.ArgumentNullException: Value cannot be null.
 at Test.ThrowTest3.ProcessString(String s) ... First exception caught.
*/

ÖrnekExample

Aşağıdaki örnekte, özel durum işleme için zaman uyumsuz yöntemler gösterilmektedir.The following example illustrates exception handling for async methods. Zaman uyumsuz bir görev oluşturan bir özel durum yakalamak için yerleştirin await ifadesinde bir try blok ve özel durumu bir catch blok.To catch an exception that an async task throws, place the await expression in a try block, and catch the exception in a catch block.

Açıklamadan çıkarın throw new Exception özel durum işleme göstermek için örnek satır.Uncomment the throw new Exception line in the example to demonstrate exception handling. Görevin IsFaulted özelliği True, görevin Exception.InnerException özelliği, özel duruma ayarlanır ve özel durum yakalandı catch blok.The task's IsFaulted property is set to True, the task's Exception.InnerException property is set to the exception, and the exception is caught in the catch block.

Açıklamadan çıkarın throw new OperationCanceledException zaman uyumsuz bir işlem iptal ettiğinizde ne göstermek için satır.Uncomment the throw new OperationCanceledException line to demonstrate what happens when you cancel an asynchronous process. Görevin IsCanceled özelliği true, ve özel durum yakalandı catch blok.The task's IsCanceled property is set to true, and the exception is caught in the catch block. Bu örnek için görev ait uygulama bazı koşullar altında IsFaulted özelliği true ve IsCanceled ayarlanır false.Under some conditions that don't apply to this example, the task's IsFaulted property is set to true and IsCanceled is set to false.

public async Task DoSomethingAsync()
{
    Task<string> theTask = DelayAsync();

    try
    {
        string result = await theTask;
        Debug.WriteLine("Result: " + result);
    }
    catch (Exception ex)
    {
        Debug.WriteLine("Exception Message: " + ex.Message);
    }
    Debug.WriteLine("Task IsCanceled: " + theTask.IsCanceled);
    Debug.WriteLine("Task IsFaulted:  " + theTask.IsFaulted);
    if (theTask.Exception != null)
    {
        Debug.WriteLine("Task Exception Message: "
            + theTask.Exception.Message);
        Debug.WriteLine("Task Inner Exception Message: "
            + theTask.Exception.InnerException.Message);
    }
}

private async Task<string> DelayAsync()
{
    await Task.Delay(100);

    // Uncomment each of the following lines to
    // demonstrate exception handling.

    //throw new OperationCanceledException("canceled");
    //throw new Exception("Something happened.");
    return "Done";
}

// Output when no exception is thrown in the awaited method:
//   Result: Done
//   Task IsCanceled: False
//   Task IsFaulted:  False

// Output when an Exception is thrown in the awaited method:
//   Exception Message: Something happened.
//   Task IsCanceled: False
//   Task IsFaulted:  True
//   Task Exception Message: One or more errors occurred.
//   Task Inner Exception Message: Something happened.

// Output when a OperationCanceledException or TaskCanceledException
// is thrown in the awaited method:
//   Exception Message: canceled
//   Task IsCanceled: True
//   Task IsFaulted:  False

ÖrnekExample

Aşağıdaki örnek, özel durum işleme birden çok görev içinde birden çok özel durum burada sonuçlanabilir gösterir.The following example illustrates exception handling where multiple tasks can result in multiple exceptions. try Bloğu için bir çağrı tarafından döndürülen görev bekler Task.WhenAll.The try block awaits the task that's returned by a call to Task.WhenAll. WhenAll uygulandığı üç görev tamamlandığında, görev tamamlandıysa.The task is complete when the three tasks to which WhenAll is applied are complete.

Her biri üç görev, bir özel durum neden olur.Each of the three tasks causes an exception. catch Blok yinelenir bulunan özel durumlar üzerinden Exception.InnerExceptions özelliği tarafından döndürülen görevin Task.WhenAll.The catch block iterates through the exceptions, which are found in the Exception.InnerExceptions property of the task that was returned by Task.WhenAll.

public async Task DoMultipleAsync()
{
    Task theTask1 = ExcAsync(info: "First Task");
    Task theTask2 = ExcAsync(info: "Second Task");
    Task theTask3 = ExcAsync(info: "Third Task");

    Task allTasks = Task.WhenAll(theTask1, theTask2, theTask3);

    try
    {
        await allTasks;
    }
    catch (Exception ex)
    {
        Debug.WriteLine("Exception: " + ex.Message);
        Debug.WriteLine("Task IsFaulted: " + allTasks.IsFaulted);
        foreach (var inEx in allTasks.Exception.InnerExceptions)
        {
            Debug.WriteLine("Task Inner Exception: " + inEx.Message);
        }
    }
}

private async Task ExcAsync(string info)
{
    await Task.Delay(100);
    
    throw new Exception("Error-" + info);
}

// Output:
//   Exception: Error-First Task
//   Task IsFaulted: True
//   Task Inner Exception: Error-First Task
//   Task Inner Exception: Error-Second Task
//   Task Inner Exception: Error-Third Task

C# dili belirtimiC# language specification

Daha fazla bilgi edinmek için, bkz. C# Dil Belirtimi.For more information, see the C# Language Specification. Dil belirtimi, C# sözdizimi ve kullanımı için kesin bir kaynaktır.The language specification is the definitive source for C# syntax and usage.

Ayrıca bkz.See also