Hata Kodları mı, Hata Fırlatma mı?Beğen

Nesne yönelimli programlamada, akış zincirindeki hataların yakalanması ve yönetilmesi için metot seviyesinde temelde 2 yöntem mevcuttur. Bunlar:

1. Hata Kodları:

Basit bir örnekle anlatacak olursak,

    public class MethodResult
    {
        public MethodResult() { }

        public MethodResult(int errorCode, string errorMsg)
        {
            ErrorCode = errorCode;
            ErrorMessage = errorMsg;
        }

        public int ErrorCode { get; protected set; }
        public string ErrorMessage { get; protected set; }
        public bool HasError => ErrorCode != 0;
    }

    public class MethodResult<T> : MethodResult
    {
        public MethodResult(int errorCode, string errorMsg)
            : base(errorCode, errorMsg) { }

        public MethodResult(T data)
        {
            Data = data;
        }

        public T Data { get; protected set; }
    }

Yukarıdaki gibi bir sonuç sınıfı kullanarak tüm metot dönüşlerimizi MethodResult tipinde döneceğiz. Ör:

        public static MethodResult<double> Divide(double a, double b)
        {
            if (b == 0)
                return new MethodResult<double>(1, "Divider must be a value other than zero!");

            return new MethodResult<double>(a / b);
        }

Bu metodu da uygulamamızda aşağıdaki gibi kullanacağız.

            var methodResult = Divide(5, 0);
            if (methodResult.HasError)
            {
                Console.WriteLine($"{methodResult.ErrorCode}-{methodResult.ErrorMessage}");
                return;
            }
            Console.WriteLine(methodResult.Data);

2. Hata Fırlatma:

Bu yöntem ise hata fırlatma ve üst metotlarda bunu yakalama şeklindeki en klasik yöntemdir. Hata mesajı Exception nesnesi üzerinden geçer. Ayrıca, hata kodu içeren kendimize ait yeni bir MyException sınıfı oluşturarak kod alanını da ekleyebiliriz.

    public class MyException : Exception
    {
        public int ErrorCode { get; set; }
        public MyException(int errorCode, string message, Exception innerException = null) 
            : base(message, innerException)
        {
            ErrorCode = errorCode;
        }
    }

Bölme metodumuz da aşağıdaki gibi olacaktır:

        public static double Divide2(double a, double b)
        {
            if (b == 0)
                throw new MyException(1, "Divider must be a value other than zero!");

            return a / b;
        }

Aşağıdaki gibi hangi katmanda ve seviyede yakalamak istiyorsak, o aşamada try-catch kullanıyoruz.

            try
            {
                var result = Divide2(5, 0);
                Console.WriteLine(result);
            }
            catch (MyException ex)
            {
                Console.WriteLine($"{ex.ErrorCode}-{ex.Message}");
            }

Bu 2 yöntemi melez bir şekilde de kullanabiliriz. Avantaj ve dezavantaj olarak inceleyecek olursak:

1. Hata kodları dönen metotlar şeklinde bir tasarım, tasarım kalitesini ciddi seviyede düşürecektir. Özellikle iç içe çağırım sayısı arttıkça yönetim daha da zorlaşacak, gereksiz kod kalabalıkları (if has error) ortaya çıkacaktır.
2. Tüm metot çağırımları ile birlikte hata kodlarını da "if has error" şeklinde kontrol etmemiz gerekiyor. Aksi takdirde hataları yutarak uygulama hatalı verilerle çalışmaya devam edecektir. (Örneğin yukarıdaki bölme metodu için hata kodunu kontrol etmeden devam edersek data 0 olduğu için uygulama 0 değeri ile tutarsız şekilde çalışmaya devam edecektir.) Hata fırlatma için böyle bir problem söz konusu değil. Yardımcı Microsoft yazısına bu link üzerinden ulaşabilirsiniz.
3. Hata fırlatma yönteminin bir dezavantajı olarak; eğer hatalara göre sıkça değişen bir akışımız mevcutsa bu durumda kodumuzda birçok try-catch bloğu ortaya çıkacaktır.

Benim tercihim ise tasarım kalitesini de yükselttiği için klasik hata fırlatma yöntemidir. Hata kodları kullandığım dönemler de mevcut ancak .Net için artık gereksiz olduğuna inanıyorum. Zaten uç uygulama katmanında (WCF service layer, MVC controllers vb.) yer alan ErrorHandler vb. gibi global hata yakalama birimleri ile birlikte kullanıldığında exception kullanımı fazlasıyla etkili, yeterli ve sürdürülebilir olmaktadır.