Alıştırma - Visual Studio Code ile hata ayıklama

20 dakika

Yeni edinilen hata ayıklama bilgilerinizi uygulamaya geçirmenin zamanı geldi. İlk iş gününüzde, şirketin bir numaralı ürünü olan Fibonacci hesap makinesindeki bir hatayı düzeltmek amacıyla .NET hata ayıklama becerilerinizi göstermeniz gerekiyor.

Hata ayıklama için örnek bir .NET projesi oluşturma

Visual Studio Code’u .NET’te hata ayıklamak üzere yapılandırmak için ilk olarak bir .NET projesine ihtiyacımız var. Visual Studio Code, tümleşik terminali sayesinde yeni proje oluşturmayı kolaylaştırır.

Visual Studio Code'da Dosya>Klasör Aç'ı seçin.
İstediğiniz bir konumda DotNetDebugging adlı yeni bir klasör oluşturun. Ardından Klasör Seç'i seçin.
Ana menüdenTerminali> seçerek Visual Studio Code'dan tümleşik terminali açın.
Aşağıdaki komutu kopyalayıp terminal penceresine yapıştırın:
```
dotnet new console
```
Bu komut, klasörünüzde önceden yazılmış temel bir "Merhaba Dünya" programı içeren bir Program.cs dosyası oluşturur. Ayrıca DotNetDebugging.csproj adlı bir C# proje dosyası oluşturur.
Terminal penceresinde, "Merhaba Dünya" programını çalıştırmak için aşağıdaki komutu kopyalayıp yapıştırın.
```
dotnet run
```
Terminal penceresinde çıkış olarak "Merhaba Dünya!" görüntülenir.

Visual Studio Code’u .NET hatalarını ayıklamak için ayarlama

Program.cs seçerek açın.
Visual Studio Code’da ilk kez bir C# dosyası açtığınızda, C# için önerilen uzantıları yüklemenize yönelik bir istem alırsınız. Bu istemi görürseniz, istemdeki Yükle düğmesini seçin.
Visual Studio Code, C# uzantısını yükleyecek ve projenizi derlemek ve hata ayıklamak için gerekli dosyaları eklemek üzere bir diğer mesaj gösterecektir. Evet düğmesini seçin.
Hata ayıklayacağımız koda odaklanmak için Uzantı: C# sekmesini kapatabilirsiniz.

Fibonacci program mantığını ekleme

Geçerli projemizde konsola “Merhaba Dünya” iletisi yazıldığından, hata ayıklayabileceğimiz çok fazla bir öğe yok. Bunun yerine, Fibonacci dizisinin N^. sayısını hesaplamak için kısa bir .NET programı kullanacaksınız.

Fibonacci dizisi, 0 ve 1 ile başlayan ve her sayının kendisinden önce gelen iki sayının toplamı olduğu bir sayı dizisidir. Sıra burada gösterildiği şekilde devam eder:

0, 1, 1, 2, 3, 5, 8, 13, 21...

Program.cs seçerek açın.

Program.cs içeriğini aşağıdaki kodla değiştirin:

int result = Fibonacci(5);
Console.WriteLine(result);

static int Fibonacci(int n)
{
    int n1 = 0;
    int n2 = 1;
    int sum;

    for (int i = 2; i < n; i++)
    {
        sum = n1 + n2;
        n1 = n2;
        n2 = sum;
    }

    return n == 0 ? n1 : n2;
}

Not

Bu kod, modülün devamında ayıklayacağımız bir hata içeriyor. Bu hata düzeltilene kadar, söz konusu kodu görev açısından kritik Fibonacci uygulamalarında kullanmamanızı öneririz.

Windows ve Linux için Ctrl+S tuşlarına basarak dosyayı kaydedin. Mac için Cmd+S'yi seçin.
Şimdi hata ayıklamadan önce güncelleştirilmiş kodun nasıl çalıştığına göz atalım. Terminalde aşağıdaki komutu girerek programı çalıştırın:
```
dotnet run
```
3 sonucu terminal çıkışında gösterilir. Parantez içindeki her değer için sıfır tabanlı sıra konumunu gösteren bu Fibonacci sıra grafiğine başvurduğunuzda sonucun 5 olması gerektiğini görürsünüz. Şimdi hata ayıklayıcıyı daha yakından inceleyip bu programı düzeltebiliriz.
```
0 (0), 1 (1), 1 (2), 2 (3), 3 (4), 5 (5), 8 (6), 13 (7), 21 (8)...
```

Sorunları analiz etme

Soldaki Çalıştır ve Hata Ayıkla sekmesini ve ardından Hata ayıklamayı başlat düğmesini seçerek programı başlatın. Önce Çalıştır ve Hata Ayıkla düğmesini ve ardından Program.cs dosyasını seçmeniz gerekebilir.

Programın hızla tamamlandığını görmeniz gerekir. Henüz kesme noktası eklemediğiniz için bu normaldir.

Hata ayıklama konsolu görünmüyorsa Windows ve Linux için Ctrl+Shift+Y veya Mac için Cmd+Shift+Y'yi seçin. Tanılama bilgilerinin yer aldığı birkaç satırı ve devamında aşağıdaki satırların yer aldığını görmeniz gerekir:

...
Loaded 'C:\Program Files\dotnet\shared\Microsoft.NETCore.App\6.0.0\System.Threading.dll'. Skipped loading symbols. Module is optimized and the debugger option 'Just My Code' is enabled.
Loaded 'C:\Program Files\dotnet\shared\Microsoft.NETCore.App\6.0.0\System.Text.Encoding.Extensions.dll'. Skipped loading symbols. Module is optimized and the debugger option 'Just My Code' is enabled.
3
The program '[88820] DotNetDebugging.dll' has exited with code 0 (0x0).

Üstteki satırlara göz attığınızda, varsayılan hata ayıklama ayarlarının “Yalnızca Kendi Kodum” seçeneğini etkinleştirdiğini anlıyorsunuz. Bu, hata ayıklayıcının yalnızca kodunuzda hata ayıklanacağı ve bu modu devre dışı bırakmadığınız sürece .NET için kaynak koduna adım atmayacağı anlamına gelir. Bu seçenek, kendi kodunuzdaki hataları ayıklamaya ağırlık vermenizi sağlar.

Hata ayıklama konsolu çıkışının sonunda, programın konsola 3 yazdığını ve 0 koduyla çıkış yaptığını görürsünüz. Program çıkış kodu olan 0, genellikle bir programın çalıştığını ve kilitlenmeden kapatıldığını belirtir. Ancak, kilitlenme ve doğru değer döndürme arasında bir fark vardır. Bu örnekte, programın Fibonacci dizisinin beşinci değerini hesaplamasını istemiştik:

0 (0), 1 (1), 1 (2), 2 (3), 3 (4), 5 (5), 8 (6), 13 (7), 21 (8)...

Bu listedeki beşinci değer 5 olmasına rağmen programımız 3 değerini döndürdü. Bu hatayı tanılayıp düzeltmek için hata ayıklayıcıyı kullanalım.

Kesme noktalarını ve adım adım yürütmeyi kullanma

üzerinde 1int result = Fibonacci(5);sol kenar boşluğuna tıklayarak kesme noktası ekleyin.
Hata ayıklamayı yeniden başlatın. Program yürütülmeye başlar. Ayarladığınız kesme noktası nedeniyle 1. satırda kesme (yürütmeyi duraklatır) . Fibonacci() işlevine geçmek için hata ayıklayıcı denetimlerini kullanın.

Değişkenlerin durumunu denetleme

Şimdi Değişkenler panelini kullanarak farklı değişkenlerin değerlerini incelemek için biraz zaman ayırabilirsiniz.

Değişkenler panelinin ekran görüntüsü.

n parametresi için gösterilen değer nedir?
İşlevin yürütülmesinin başında n1, n2 ve sum yerel değişkenlerinin değerleri neydi?

Daha sonra, for hata ayıklayıcı denetimini kullanarak döngüsüne ilerleyeceğiz.
for döngüsündeki, aşağıdakilerin yazdığı ilk satıra ulaşana kadar ilerlemeye devam edin:
```
sum = n1 + n2;
```

Not

for(...) {} satırında ilerlemek için birden fazla içine adımlama komutu kullanmanız gerektiğini fark etmiş olabilirsiniz. Bu durum, bu satırda birden çok deyim olduğundan oluşur. Adımladığınızda, kodunuzda sonraki deyime geçersiniz. Genellikle her satırda bir deyim bulunur. Ancak bir sonraki satıra geçmek için birden fazla adıma ihtiyaç duyduğunuz durumlar da olabilir.

Kodu düşünün

Hata ayıklamanın önemli bir kısmı, ara vermek ve kod parçalarının (döngüler gibi işlevler ve bloklar) ne yapmaya çalıştığına ilişkin bilgiye dayalı tahminler yapmaktır. Emin değilseniz sorun değil, bu da hata ayıklama sürecinin bir parçasıdır. Ancak, hata ayıklama sürecinde etkin bir şekilde çalışmak hataları çok daha hızlı bir şekilde tespit etmenize yardımcı olacaktır.

Ayrıntılara ilerlemeden önce, Fibonacci dizisinin 0 ve 1 ile başlayan ve her sayının kendisinden önce gelen iki sayının toplamı olduğu bir sayı dizisi olduğunu anımsayalım.

Bunun anlamı:

Fibonacci(0) = 0
Fibonacci(1) = 1
Fibonacci(2) = 1 (0 + 1)
Fibonacci(3) = 2 (1 + 1)
Fibonacci(4) = 3 (1 + 2)
Fibonacci(5) = 5 (2 + 3)

Bu tanımı anlayıp bu for döngüsüne bakarak şunu çıkarabiliriz:

Döngü 2 ila n (aradığımız Fibonacci dizisi sayısı) arasındaki sayıları sayıyor:
n 2’den küçükse döngü asla çalışmaz. İşlevin sonundaki return deyimi, n 0 ise 0, n 1 veya 2 ise 1 döndürür. Bunlar, doğası gereği Fibonacci dizisinin sıfırıncı, birinci ve ikinci değerleridir.
Daha ilgi çekici bir durum n 2 ' den büyük olur. Bu durumlarda, geçerli değer önceki iki değerin toplamı olarak tanımlanır. Yani bu döngüde, önceki iki değer n1 ve n2, geçerli yineleme değeri ise sum olur. Bu nedenle, önceki iki değerin toplamını her hesapladığımızda ve sum olarak ayarladığımızda, n1 ve n2 değerlerimizi de güncelleştirmiş oluruz.

Bunun üzerinde daha fazla düşünmemiz gerekmiyor. Hata ayıklayıcımızı kullanabiliriz. Ancak kod üzerine düşünmek ve beklediğimiz işlemi yapıp yapmadığını görmek, yapmadığında ise buna dair bilgi sahibi olmak önemlidir.

Kesme noktalarıyla hatayı bulma

Özellikle döngülerle veya sürekli olarak çağrılan diğer kodlarla çalışırken kodunuzu adım adım ilerletebilirsiniz. Döngüde defalarca ilerlemek yerine, döngünün ilk satırında bir kesme noktası ayarlayabiliriz.

Bunu yaparken, kesme noktalarımızı koyacağımız yer konusunda stratejik davranmak önemlidir. Geçerli en yüksek Fibonacci değerini temsil ettiğinden, özellikle değeriyle sumilgileniyoruz. Bu nedenle, kesme noktamızı ayarlandıktan sum satıra ekleyelim.

13. satıra ikinci bir kesme noktası ekleyin.

Not

Kodunuzu çalıştırmaya devam edip bir veya iki satır atladığınızı fark ederseniz kesme noktalarınızı daha verimli satırlarla kolayca güncelleştirebilirsiniz.
Artık döngüde iyi bir kesme noktası ayarladığımıza göre, kesme noktasına isabet edene kadar ilerlemek için Devam hata ayıklayıcısı denetimini kullanın. Yerel değişkenlerimize baktığımızda aşağıdaki satırları görüyoruz:
```
n [int]: 5
n1 [int]: 0
n2 [int]: 1
sum [int]: 1
i [int]: 2
```
Bu satırların hepsi doğru görünüyor. Döngüdeki ilk zaman noktasında, önceki iki değerin sum değeri 1’dir. Satır satır ilerlemek yerine, döngüdeki sonraki zaman noktasına atlamak için kesme noktalarımızdan yararlanabiliriz.
Bir sonraki döngü geçişinde olacağı bir kesme noktasına isabet edene kadar programın akışına devam etmek için Devam'ı seçin.

Not

Devam'i kullanırken hatanın atlanması konusunda endişelenmeyin. Genelde sorunu bulmak için kodda birkaç kez hata ayıklaması yapmanız gerekebilir. Birkaç kez çalıştırmak, genellikle çok dikkatli bir şekilde adımlamaya kıyasla daha kısa sürer.

Bu kez, aşağıdaki değerleri görüyoruz:
```
n [int]: 5
n1 [int]: 1
n2 [int]: 1
sum [int]: 2
i [int]: 3
```
Bunlar üzerine düşünelim. Bu değerler hala mantıklı mı? Öyle görünüyorlar. Üçüncü Fibonacci sayısı için, sum değerimizin 2’ye eşit olmasını bekliyoruz ve öyle olduğunu görüyoruz.
Tamam, tekrar döngü yapmak için Devam'ı seçelim.
```
n [int]: 5
n1 [int]: 1
n2 [int]: 2
sum [int]: 3
i [int]: 4
```
Yine herhangi bir sorun görünmüyor. Dizideki dördüncü değerin 3 olmasını bekliyoruz.
Bu noktada, kodun aslında tamamen sorunsuz olduğunu ve hatanın hayal ürününüz olduğunu düşünmeye başlamış olabilirsiniz. Döngüdeki son zaman noktasına kadar devam edelim. Bir kez daha Devam Et'i seçin.

Bir dakika. Program çalışmayı tamamladı ve 3 değerini yazdırdı! Burada bir sorun var.

Pekala, endişelenmeyelim. Başarısız olmadık, öğrendik. Artık kodun i değeri 4’e eşit olana kadar döngüde düzgün bir şekilde çalıştığını, ancak son değeri hesaplamadan programdan çıktığını biliyoruz. Hatanın nerede olduğu hakkında bazı fikirler edinmeye başladım. Öyle misin?
Şimdi 17. satırda şu şekilde bir kesme noktası daha ayarlayalım:
```
return n == 0 ? n1 : n2;
```
Bu kesme noktası, işlev çıkış yapmadan önce program durumunu incelememize olanak sağlar. 1. ve 13. satırlardaki önceki kesme noktalarımızdan bekleyebileceğiniz her şeyi zaten öğrendik, böylece bunları temizleyebiliriz.
1. ve 13. satırlardaki önceki kesme noktalarını kaldırın. Bunu yapmak için satır numaralarının yanındaki kenar boşluğuna tıklayabilir veya sol alttaki Kesme Noktaları bölmesindeki 1. ve 13. satırlar için kesme noktası onay kutularını temizleyebilirsiniz.

Şu anda kodumuzdaki durumu çok daha iyi bir şekilde anlayıp programımızı yanlış çalıştığında yakalayabilecek şekilde tasarlanan bir kesme noktası ayarladığımıza göre, bu hatayı yakalamamız gerekir.
Hata ayıklayıcıyı son kez çalıştırın.
```
n [int]: 5
n1 [int]: 2
n2 [int]: 3
sum [int]: 3
```
Burada bir sorun var. Fibonacci(5) değerini istedik ancak Fibonacci(4) değerini aldık. Bu işlev n2 değerini döndürür, her döngü yinelemesi sum değerini hesaplar ve n2 değerini sum değerine eşit olacak şekilde ayarlar.

Bu bilgileri ve önceki hata ayıklama çalıştırmamızı temel alarak, döngünün i değeri 5 değil, 4 olduğunda çıkış yaptığını görebiliriz.

for döngüsünün ilk satırına biraz daha yakından bakalım.
```
for (int i = 2; i < n; i++)
```
Bir dakika! Bu, for döngüsünün üst kısmı artık değerinden küçük iolmadığını n görür görmez çıkılacağı anlamına gelir. Bu, döngü kodunun i değerinin n değerine eşit olduğu durumlar için çalıştırılmayacağı anlamına gelir. i <= n değerine ulaşana kadar çalıştırmak istiyorduk, ancak bunun yerine şu senaryo gerçekleşiyor:
```
for (int i = 2; i <= n; i++)
```
Yani bu değişiklikle birlikte, güncelleştirilmiş programınızın bu örnekteki gibi görünmesi gerekir:
```
int result = Fibonacci(5);
Console.WriteLine(result);

static int Fibonacci(int n)
{
    int n1 = 0;
    int n2 = 1;
    int sum;

    for (int i = 2; i <= n; i++)
    {
        sum = n1 + n2;
        n1 = n2;
        n2 = sum;
    }

    return n == 0 ? n1 : n2;
}
```
Henüz yapmadıysanız hata ayıklama oturumunu durdurun.
Ardından, önceki değişikliği 10. satırda yapın ve kesme noktamızı 17. satırda bırakın.
Hata ayıklayıcıyı yeniden başlatın. Bu kez, 17. satırdaki kesme noktasına bastığımızda aşağıdaki değerleri göreceğiz:
```
n [int]: 5
n1 [int]: 3
n2 [int]: 5
sum [int]: 5
```
Oldu! Bu kez başardık! Harika bir iş, Fibonacci, Inc. için günü kurtardın!
Programın doğru değeri döndürdüğünden emin olmak için Devam'ı seçin.
```
5
The program '[105260] DotNetDebugging.dll' has exited with code 0 (0x0).
```
Böylece doğru çıkışı elde etmiş olduk.

Başardınız! Visual Studio Code’daki .NET hata ayıklayıcısını kullanarak başkalarının yazdığı kodların bazılarında hata ayıkladınız.

Sonraki ünitede, .NET’teki yerleşik günlüğe kaydetme ve izleme özelliklerinden yararlanarak, yazdığınız kodlarda hata ayıklamayı daha kolay hale getirmeyi öğreneceksiniz.

Geri Bildirim

Bu sayfayı yararlı buldunuz mu?