Yapmış olduğumuz projelerde, hayata geçirdiğimiz her bir fonksiyonun hatasız bir sistemin çalışan dişlileri gibi çalışması her zaman beklenemez. İster istemez bazı işlemler sonucunda hatalar ile karşılaşabiliriz. Bu hata durumlarını yakalamak için ise “Exception Handling” kavramını tanımamız ve uygulamamız gerekir.
Bu yüzden bu rehber içeriğimizde “C# Hata Yakalama” işleminin nasıl gerçekleştiğini, hangi hata (exception) türlerinin olduğunu öğreneceğimiz yeni bir bilgi edinim serüvenine çıkacağız. 🧗🏻🎓
C# Hata Yakalama Nedir?
Hata yakalama, Exception Handling ya da İstisnai durum yönetimi gibi çeşitli isimlerde karşımıza çıkacak bu yöntemi rehber içeriğimiz boyunca hata yakalama ya da exception handling olarak ele alacağım.
C# Hata Yakalama, çoğu zaman projelerimizde sorunsuz bir şekilde kod bloklarını oluşturduğumuzu düşünürüz. Fakat bazen mantıksal, sistemsel veya kullanıcıdan alacağımız bir veri yüzünden oluşacak kullanıcı kaynaklı hatalar ile karşılaşmamız olası bir durumdur. Bu tür durumlar için programımızı güvenli bir yapı haline getirebilmek için karşımıza çıkacak bu hataları yakalamamız, tabiri caizse avlamamız gerekiyor. 👮🏻♀️🎯🧛🏻♀️
Bu avlamamız gereken hata yapılarını aklımızda canlandırabilmek için basit bir örnek vermek istiyorum. Projelerimizde bazen bir klasöre erişmek, internet sitesine erişmek ya da veri tabanı bağlantısı kurmak isteriz. Fakat erişmek istediğimiz dosyanın yolu değişmiş olabilir, internet bağlantımız olmayabilir ya da veri tabanımızın bilgileri yanlış olabilir. Bu tür durumlarda programımız bize bir hata göndereceği için bu hatayı yakalayarak güvenli bir yapı da gereken işlemleri gerçekleştirmek isteriz.
Karşımıza çıkabilecek bu hata türleri literatür içerisinde üç temel başlığa ayrılır. Konuyu daha rahat anlayabilmemiz için bu hata türlerine daha yakından göz atalım. 👀
C# Hata Türleri
C# Hata Türleri, karşılaşacağımız farklı senaryo yapılarında alabileceğimiz üç genel başlık altında yer alan çeşitli exception yapıları bulunur.
Bu hata türlerini aşağıda maddeler halinde açıklamaya gayret göstereceğim.
- Checked Exception (🕵🏻): Programımız bazı konularda hatanın oluşabileceğini öngördüğü için bizlerden bazı yapıların try-catch içerisinde oluşturmamızı ister. Bu türde oluşacak herhangi bir hataya ise literatür içerisinde “Checked Exception” denilmektedir. Örneğin programımız içerisinde bir dosyaya ulaşmak istediğimiz zaman programımız bizden bir IOException kullanmamızı isteyecektir.
- Unchecked Exception (😴): Checked Exception yapılarının aksine programımız gerçekleştirmek istediğimiz işlemin bir hata meydana getireceğini tahmin edemediğinden dolayı “try-catch” yapısı oluşturmamız için bizi zorlamıyor. Bu hata türüne RuntimeException, ArithmeticException yapıları örnek olarak gösteriliriz.
- Error(🤯):Error olarak bilinen hata türleri ile çoğu kişi karşılaşmak istemez. Programın çalışma esnasında oluşabilecek StackOverFlow, OutOfMemory gibi hatalar sonucunda çözüm için bazen yazmış olduğumuz programı baştan aşağı tekrar oluşturmamız gerekeceğinden dolayı çoğu kişinin karşılaşmak istemediği bir durumdur.
Karşılaşabileceğimiz “C# Hata Türleri” konusunda bir fikir sahibi olduğumuza göre artık bu hata türlerini yakalayacağımız tabiri caizse avlayacağımız try-catch blok yapılarını tanıma aşamasına geçebiliriz.
Hata Avcısı Try-Catch Bloklarını Tanıyalım
Programımız içerisinde çalıştıracağımız bazı kod satırlarının hata çıkartacağını ve programımızda çökmelere sebep olacağını düşünüyorsak try-catch bloklarından yardım alırız.
Gelin teorik olarak bu blok yapılarının işlevlerini maddeler halinde inceleyelim ve öğrenelim.
- Try Bloğu (🔎): Programımız içerisinde bulunan kod satırlarının çalışma esnasında hata oluşturacağını düşündüğümüz kod parçacıklarını bu blok içerisine yazarız. Yani bu blok yapımız bizim için oluşacak hataları tespit eder ve programımızın çökmesini önlemek için catch bloğunu çalıştırır.
- Catch Bloğu (🛑): Try bloğu içerisinde yakalanan hata ilgili catch bloklarına yönlendirildikten sonra, Catch bloğumuz hatanın çözüm senaryosu için oluşturmuş olduğumuz kod parçacıklarını çalıştırır.
- Finally Bloğu (✔️): Try bloğu içerisinde hata ile karşılaşılmış olsa da, olmasa da her türlü koşulda çalışacak yapılarımızı yazacağımız blok yapısıdır. İsteğe göre blok yapılarımıza ekleyebilir ya da eklemeyebiliriz.
Karşılaşacağımız hataları nasıl yakalayacağımızı ve nasıl müdahale edeceğimizi öğrendiğimize göre basit bir örnek oluşturabilir ve try-catch bloklarını kod içerisinde nasıl kullanacağımızı öğrenebiliriz.
Bu örnek için uygulayacağım aşamaları, kod bloklarını ve ilgili kod çıktılarını aşağıdaki maddelerden takip edebiliriniz.
- İşlemlerimi karmaşık bir yapı halinde kullanmak yerine “Main” sınıfı içerisinde gerekli tanımlama işlemlerimi gerçekleştireceğim.
- “C# Hata Yakalama” konusunu daha iyi anlayabilmek ve nasıl hatalar ile karşılaşabileceğimizi görmek için basit bir kaç tanımlama ile “ArithmeticException” hatası alabileceğimiz bir sistem oluşturdum.
- Bu karşılaşmış olduğumuz hata yapısını try-catch blokları içerisinde kullanmak ve bir önlem almak isteseydik eğer aşağıdaki yapıya benzer bir kod satırı oluşturmamız gerekecekti.
Bu oluşturmuş olduğum yapının sonucunda kod bloğum aşağıdaki halini almış oldu.
namespace ExceptionHandlingApp
{
class Program
{
static void Main(string[] args)
{
string ayrac = new string('-', 6);
int a = 100, b = 0;
Console.WriteLine("{0}\n< C# Exception Handling (Hata Yakalama) >\n{1}\n-> {2} / {3} işleminin sonucu: {4}\n{5}", ayrac, ayrac, a, b, (a / b), ayrac);
}
}
}
Kod Çıktısı:
namespace ExceptionHandlingApp
{
class Program
{
static void Main(string[] args)
{
string ayrac = new string('-', 6);
int a = 100, b = 0;
try
{
Console.WriteLine("{0}\n< C# Exception Handling (Hata Yakalama) >\n{1}\n-> {2} / {3} işleminin sonucu: {4}\n{5}", ayrac, ayrac, a, b, (a / b), ayrac);
}
catch
{
if(a != 0 && b == 0)
{
b = (a / 10);
Console.WriteLine("{0}\n< C# Exception Handling (Hata Yakalama) >\n{1}\n-> B'nin değeri hata oluşturduğu için güncellenmiş ve {2} değeri atanmıştır.\n-> {3} / {4} işleminin sonucu: {5}\n{6}",ayrac,ayrac,b,a,b,(a/b),ayrac);
}
else if(a == 0 && b != 0)
{
a = (b*10);
Console.WriteLine("{0}\n< C# Exception Handling (Hata Yakalama) >\n{1}\n-> A'nin değeri hata oluşturduğu için güncellenmiş ve {2} değeri atanmıştır.\n-> {3} / {4} işleminin sonucu: {5}\n{6}", ayrac, ayrac, a, a, b, (a / b), ayrac);
}
else if (a == 0 && b == 0)
{
a = 50;
b = 10;
Console.WriteLine("{0}\n< C# Exception Handling (Hata Yakalama) >\n{1}\n-> {2} / {3} işleminin sonucu: {4}\n{5}", ayrac, ayrac, a, b, (a / b), ayrac);
}
}
}
}
}
Kod Çıktısı:
Bu hata yakalayıcılarımızda hatanın kaynağını, ismini, hangi metot içerisinde oluştuğunu dahi öğrenmemiz mümkün. Bu yüzden Try-Catch blokları içerisinde kullanabileceğimiz Exception yapıları bizim için oldukça önemli. Çünkü bu yapıların içerisinde çeşitli metotları kullanma imkanımız ortaya çıkıyor. İsterseniz bu exception metot yapılarını yakından inceleyelim ve öğrenelim.
C# Exception (Hata) Metotları
C# üzerinde System.Exception sınıfından türeyen hata yapılarında kullanabileceğimiz çeşitli metot yapıları mevcuttur. Bu metotlar çoğu zaman projelerimizde nerede, nasıl hata oluştuğu konusunda bize fikir vererek yardımcı olan fonksiyonlardır. Bu metot yapılarından en çok kullanacağımız, bilinen metot yapıları ise şu şekildedir:
- Message(): Try-Catch bloklarımız içerisinde yakalanan hata hakkında ilgili açıklayıcı bir mesaj döndüren metot yapısıdır.
- Source():İstisnai oluşan durum nesnesinin gönderildiği uygulama ya da dosyanın adıdır.
- StackTrace(): Hatanın ortaya çıktığı metot ya da program hakkında bize bilgi verir ve çözüm sürecini hızlandırır.
- TargetSite(): İstisnai durumun oluşmasını sağlayan metot hakkında bize bilgi verir.
- InnerException(): Hata yakalama sonucunda çalışacak “Catch” bloğumuzun içerisinde bir hata ortaya çıkarsa meydana gelen bir fonksiyondur.
- ToString(): Ortaya çıkan hata yapısının metninin tamamını dizi olarak geriye dönmesini sağlar.
Bu yukarıdaki metotları daha yakından tanıyabilmemiz için basit bir try-catch blok yapısı kurarak metotlarımızın çalışma prensiplerini görelim.
namespace ExceptionHandlingApp
{
class Program
{
static void Main(string[] args)
{
string ayrac = new string('-', 6);
byte v;
try
{
Console.Write("{0}\n< C# Exception Handling Metotları >\n{1}\n-> Byte tipinde bir değer girin: ",ayrac,ayrac);
v = Convert.ToByte(Console.ReadLine());
Console.Write(ayrac);
}
catch (Exception e)
{
Console.WriteLine(ayrac);
Console.WriteLine("-> Message: {0}\n-> Source: {1}\n-> StackTrace: {2}\n-> TargetSite: {3}\n{4}",
e.Message, e.Source, e.StackTrace,e.TargetSite,ayrac);
}
}
}
}
Kod Çıktısı:
Teorik olarak “C# Hata Yakalama” konusunda bilgi sahibi olduk. Fakat konu ile alakalı detaylı bir şekilde oluşan kullanım örnekleri oluşturmadık. Kendinizi hazır hissediyorsanız bir sonraki aşamamız olan bu örnek yapılarını uygulamaya geçelim.
C# Hata Yakalama Örnekleri
Hata yakalarken kullanabileceğimiz çeşitli exception sınıfları mevcut. Eğer detaylı bir proje yapıyorsak ve çıkabilecek hata türleri hakkında bir öngörümüz mevcutsa bu sınıfları kullanarak projelerimizi daha güvenli bir sistem mimarisinde kurmuş oluruz.
Gelin bu yukarıda bahsetmiş olduğum yapıyı basit bir örnek üzerinden kod haline dökelim ve çalışma mantığını daha detaylı anlamış olalım.
- Main sınıfı içerisinde kullanıcıdan değerler alabilmek için çeşitli değişkenler tanımlayarak işlemime başladım.
- Bu veri tipinden farklı bir değer girilebileceği, yapılan işlem sonucunda oluşması muhtemel hata yapısı için gerekli Exception yapılarını kafamda belirleyerek try-catch bloklarını oluşturdum.
- Oluşturmuş olduğum try bloğunun içerisine gelerek kullanıcıdan değer alma işlemlerini gerçekleştirdim.
Bu işlemlerin sonunda oluşan kod bloğu yapım aşağıdaki halini almış oldu.
namespace ExceptionHandlingApp
{
class Program
{
static void Main(string[] args)
{
string ayrac = new string('-', 6);
int aV, bV;
try
{
Console.Write("{0}\n < C# Hata Yakalama Örnekleri >\n{1}\n-> Bölünecek Değeri Girin: ",ayrac,ayrac);
aV = Convert.ToInt32(Console.ReadLine());
Console.Write("-> Bölen Değeri Girin: ");
bV = Convert.ToInt32(Console.ReadLine());
double cV = (aV / bV);
Console.WriteLine("{0}\n-> {1} değerinin {2} değerine bölümünün sonucu: {3}\n{4}", ayrac, aV, bV, cV, ayrac);
}
catch(DivideByZeroException e)
{
Console.WriteLine("{0}\n-> Hata! Sıfıra bölüm işlemi gerçekleştirilemez.\n-> Hata Mesajı: {1}\n{2}", ayrac, e.Message, ayrac);
}
catch(FormatException e)
{
Console.WriteLine("{0}\n-> Hata! Sadece Int32 türünde veri girişi yapabilirsiniz.\n-> Hata Mesajı: {1}\n{2}", ayrac, e.Message, ayrac);
}
catch(Exception e)
{
Console.WriteLine("{0}\n-> Beklenmedik Bir Hata!\n-> Hata Mesajı: {1}\n{2}", ayrac, e.Message, ayrac);
}
finally
{
Console.WriteLine("-> Finally Bloğu Çalışıyor.\n{0}",ayrac);
}
}
}
}
Kod Çıktısı:
Bu örnek yapımız sadece aklımızda bazı şeylerin canlanmasını sağlayacak basit bir yapıya sahip. Örneğimiz içerisinde kullanıcı veri girişi yaparken “Integer” veri tipi yerine “String” veya “Boolean” gibi değerler girebileceği için bunun için özel bir catch bloğu, ekstra olarak gerçekleşecek işlem (bölme) sonucunda hata oluşabileceği için ayrı bir catch bloğu ve son olarak genel bir catch yapısı oluşturarak programımızı daha güvenli bir mimaride kurmuş oldum.
Teorik olarak “C# Hata Yakalama” konusunda çeşitli alt başlıklara değinerek bilgiler oluşturdum. Tabii konuyu daha iyi kavrayabilmek için başka bir kaynaktan daha konuyu incelemek istiyor olabilirsiniz. Bu durum için sizlere Microsoft‘un hazırlamış olduğu rehber içeriğini öneririm. Bahsetmiş olduğum içeriğe buraya tıklayarak ulaşabilirsiniz.
Unutmayın, aklınıza takılan, sormak istediğiniz ya da konu işleyişi ile alakalı önerilerinizi aşağıda bulunan yorum yap kısmından bana iletebilirsiniz. 👋🏻
