Latihan - Debug dengan Visual Studio Code

20 menit

Saatnya untuk mempraktekkan pengetahuan penelusuran kesalahan yang baru diperoleh. Ini hari pertama Anda bekerja, dan saatnya untuk menempatkan keterampilan penelusuran kesalahan .NET Anda dengan memperbaiki bug dalam produk unggulan perusahaan, kalkulator Fibonacci.

Membuat sampel proyek .NET untuk penelusuran kesalahan

Untuk menyiapkan Visual Studio Code untuk penelusuran kesalahan .NET, pertama-tama kita memerlukan proyek .NET. Visual Studio Code dilengkapi dengan terminal terintegrasi, yang memudahkan pembuatan proyek baru.

Di Visual Studio Code, pilih File>Buka Folder.
Buat folder baru bernama DotNetDebugging di lokasi pilihan Anda. Lalu pilih Pilih Folder.
Buka terminal terpadu dari Visual Studio Code dengan memilih Tampilkan>Terminal dari menu utama.
Di jendela terminal, salin dan tempel perintah berikut:
```
dotnet new console
```
Perintah ini membuat file Program.cs di folder dengan program dasar "Halo Dunia" yang sudah ditulis. Ini juga membuat file proyek C# bernama DotNetDebugging.csproj.
Di jendela terminal, salin dan tempel perintah berikut untuk menjalankan program "Halo Dunia".
```
dotnet run
```
Jendela terminal menampilkan "Halo Dunia!" sebagai output.

Menyiapkan Visual Studio Code untuk penelusuran kesalahan .NET

Buka Program.cs dengan memilihnya.
Saat pertama kali membuka file C# di Visual Studio Code, Anda akan menerima permintaan untuk menginstal ekstensi yang direkomendasikan untuk C#. Jika Anda melihat perintah ini, pilih tombol Instal di permintaan.
Visual Studio Code akan menginstal ekstensi C# dan menampilkan perintah lain untuk menambahkan aset yang diperlukan untuk membangun dan menelusuri kesalahan proyek Anda. Pilih tombol Ya.
Anda dapat menutup tab Ekstensi: C# untuk fokus pada kode yang akan kita telusuri kesalahannya.

Menambahkan logika program Fibonacci

Proyek kita saat ini menulis pesan "Halo Dunia" ke konsol, yang tidak memberi kita banyak hal untuk ditelusuri kesalahannya. Sebagai gantinya, Anda akan menggunakan program .NET singkat untuk menghitung nomor ke-N dari urutan Fibonacci.

Urutan Fibonacci adalah rangkaian angka yang dimulai dengan angka 0 dan 1, dengan setiap angka berikut lainnya adalah jumlah dari dua angka sebelumnya. Urutan berlanjut seperti yang ditunjukkan di sini:

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

Buka Program.cs dengan memilihnya.

Ganti konten Program.cs dengan kode berikut:

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

Catatan

Kode ini berisi kesalahan, yang akan kita telusuri nanti dalam modul ini. Kami tidak menyarankan Anda menggunakannya dalam aplikasi Fibonacci yang sangat penting sampai kita memperbaiki bug tersebut.

Simpan file dengan memilih Ctrl+S untuk Windows dan Linux. Pilih Cmd+S untuk Mac.
Mari kita lihat cara kerja kode yang diperbarui sebelum kita men-debugnya. Jalankan program dengan memasukkan perintah berikut di terminal:
```
dotnet run
```
Hasilnya, 3, ditunjukkan dalam output terminal. Saat Anda melihat bagan deret Fibonacci ini yang menunjukkan posisi deret berbasis nol untuk setiap nilai dalam tanda kurung, Anda akan melihat bahwa hasilnya seharusnya 5. Saatnya untuk membiasakan diri dengan debugger dan memperbaiki program ini.
```
0 (0), 1 (1), 1 (2), 2 (3), 3 (4), 5 (5), 8 (6), 13 (7), 21 (8)...
```

Analisis data

Mulai program dengan memilih tab Jalankan dan Debug di sebelah kiri, lalu pilih tombol Mulai penelusuran kesalahan . Anda mungkin perlu memilih tombol Jalankan dan Debug terlebih dahulu, lalu pilih file Program.cs .

Anda akan melihat program selesai dengan cepat. Itu normal karena Anda belum menambahkan titik henti apa pun.

Jika konsol debug tidak muncul, pilih Ctrl+Shift+Y untuk Windows dan Linux atau Cmd+Shift+Y untuk Mac. Anda akan melihat beberapa baris informasi diagnostik, diikuti oleh baris ini di akhir:

...
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).

Baris di bagian atas memberi tahu Anda bahwa pengaturan penelusuran kesalahan default mengaktifkan opsi "Hanya Kode Saya". Ini berarti debugger hanya akan menelusuri kesalahan kode Anda dan tidak akan melangkah ke kode sumber untuk .NET kecuali Anda menonaktifkan mode ini. Opsi ini memungkinkan Anda berfokus pada penelusuran kesalahan kode.

Di akhir output konsol debug, Anda akan melihat program menulis 3 ke konsol lalu keluar dengan kode 0. Biasanya kode keluar program 0 menunjukkan bahwa program berjalan dan keluar tanpa crash. Namun, ada perbedaan antara crash dan mengembalikan nilai yang benar. Dalam hal ini, kita meminta program untuk menghitung nilai kelima urutan Fibonacci:

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

Nilai kelima dalam daftar ini adalah 5, tetapi program kita mengembalikan 3. Mari kita gunakan debugger untuk mendiagnosis dan memperbaiki kesalahan ini.

Menggunakan titik henti dan eksekusi langkah demi langkah

Tambahkan titik henti dengan mengklik di margin kiri di baris 1 pada int result = Fibonacci(5);.
Mulai penelusuran kesalahan lagi. Program mulai dijalankan. Ini putus (menjeda eksekusi) pada baris 1 karena titik henti yang Anda tetapkan. Gunakan kontrol debugger untuk melangkah ke fungsi Fibonacci().

Memeriksa status variabel

Sekarang, luangkan waktu untuk memeriksa nilai variabel yang berbeda dengan menggunakan panel Variabel.

Cuplikan layar panel Variabel.

Apa nilai yang ditampilkan untuk parameter n?
Di awal eksekusi fungsi, apa nilai untuk variabel lokal n1, n2, dan sum?

Selanjutnya, kita akan melangkah ke perulangan for dengan menggunakan kontrol debugger Step Over.
Lanjutkan hingga Anda mencapai baris pertama dalam perulangan for, pada baris yang berbunyi:
```
sum = n1 + n2;
```

Catatan

Anda mungkin telah memperhatikan bahwa untuk berpindah melalui baris for(...) {} memerlukan beberapa langkah dalam perintah. Situasi ini terjadi karena ada beberapa pernyataan pada baris ini. Saat melangkah, Anda melanjutkan ke pernyataan berikutnya dalam kode. Biasanya, ada satu pernyataan per baris. Jika tidak demikian, Anda memerlukan beberapa langkah untuk melanjutkan ke baris berikutnya.

Menimbang kode

Bagian penting dari penelusuran kesalahan adalah menghentikan dan mengambil beberapa estimasi tebakan tentang apa yang mungkin dilakukan oleh bagian dari kode (baik fungsi maupun blok, seperti perulangan). Tidak apa-apa jika Anda tidak yakin, itu adalah bagian dari proses penelusuran kesalahan. Tetapi terlibat secara aktif dalam proses penelusuran kesalahan akan membantu Anda menemukan bug jauh lebih cepat.

Sebelum kita menggali lebih lanjut, mari kita ingat bahwa urutan Fibonacci adalah serangkaian angka yang dimulai dengan angka 0 dan 1, dengan setiap angka berikut lainnya adalah jumlah dari dua angka sebelumnya.

Itu berarti bahwa:

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)

Memahami definisi tersebut dan melihat perulangan for ini, kita dapat menyimpulkan bahwa:

Perulangan dihitung dari 2 hingga n (nomor urutan Fibonacci yang kita cari).
Jika n kurang dari 2, perulangan tidak akan pernah berjalan. Pernyataan return di akhir fungsi akan mengembalikan 0 jika n adalah 0, dan 1 jika n adalah 1 atau 2. Ini adalah nilai nol, pertama, dan kedua dalam seri Fibonacci, menurut definisi.
Kasus yang lebih menarik adalah saat n lebih besar dari 2. Dalam kasus tersebut, nilai saat ini didefinisikan sebagai jumlah dari dua nilai sebelumnya. Jadi untuk perulangan ini, n1 dan n2 merupakan dua nilai sebelumnya, dan sum merupakan nilai untuk perulangan saat ini. Karena itu, setiap kali kita mencari tahu jumlah dari dua nilai sebelumnya dan mengaturnya ke sum, kita memperbarui nilai n1 dan n2.

Baik, kita tidak perlu memikirkannya secara berlebihan. Kita dapat lebih mempercayai debugger. Tetapi kita perlu berpikir tentang kode untuk melihat jika kode melakukan apa yang kita harapkan dan memiliki lebih banyak informasi saat tidak berjalan sesuai semestinya.

Menemukan bug dengan titik henti

Menelusuri kode Anda dapat membantu tetapi melelahkan, terutama ketika Anda bekerja dengan perulangan atau kode lain yang disebut berulang kali. Daripada melangkah melalui perulangan lagi, kita dapat mengatur titik henti baru pada baris pertama perulangan.

Saat kita melakukan ini, penting untuk berpikir strategis tentang tempat kita menempatkan titik henti. Kami sangat tertarik pada nilai sum, karena mewakili nilai Fibonacci maksimum saat ini. Karena itu, mari kita letakkan titik henti kita pada baris setelahsum diatur.

Tambahkan titik henti kedua pada baris 13.

Catatan

Jika Anda melihat bahwa Anda terus menjalankan kode dan kemudian melangkah satu atau dua baris, Anda dapat dengan mudah memperbarui titik henti ke baris yang lebih efisien.
Kini setelah kita memiliki titik henti yang baik dan diatur dalam perulangan, gunakan kontrol debugger Lanjutkan untuk maju sampai titik henti tercapai. Melihat variabel lokal kita, kita melihat baris berikut:
```
n [int]: 5
n1 [int]: 0
n2 [int]: 1
sum [int]: 1
i [int]: 2
```
Semua baris ini tampak benar. Pertama kali melalui perulangan, sum dari dua nilai sebelumnya adalah 1. Daripada memeriksa baris demi baris, kita dapat memanfaatkan titik henti untuk melompat ke waktu berikutnya melalui perulangan.
Pilih Lanjutkan untuk melanjutkan alur program hingga titik henti berikutnya tercapai, yang akan berada di loop berikutnya.

Catatan

Jangan terlalu khawatir tentang melewati bug saat Anda menggunakan Lanjutkan. Anda akan melihat bahwa Anda akan sering menelusuri kesalahan melalui kode beberapa kali untuk menemukan masalah. Seringkali lebih cepat untuk menjalankannya beberapa kali dibandingkan dengan terlalu berhati-hati saat Anda melangkah.

Kali ini, kita melihat nilai berikut:
```
n [int]: 5
n1 [int]: 1
n2 [int]: 1
sum [int]: 2
i [int]: 3
```
Mari kita periksa hal ini. Apakah nilai-nilai ini masih masuk akal? Sepertinya masih masuk akal. Untuk nomor Fibonacci ketiga, kita berharap untuk melihat sum sama dengan 2, dan benar adanya.
Baik, mari kita pilih Lanjutkan untuk mengulanginya lagi.
```
n [int]: 5
n1 [int]: 1
n2 [int]: 2
sum [int]: 3
i [int]: 4
```
Sekali lagi, semuanya terlihat baik. Nilai keempat dalam seri diharapkan adalah 3.
Pada titik ini, Anda mungkin mulai bertanya-tanya apakah kode ini sebenarnya tidak bermasalah dan Anda hanya membayangkan adanya bug! Mari kita lakukan perulangan untuk terakhir kalinya. Pilih Lanjutkan sekali lagi.

Tunggu sebentar. Program selesai berjalan dan mencetak 3! Ini tidak benar.

Oke, jangan khawatir. Kita belum gagal, kita telah belajar. Kita sekarang tahu bahwa kode berjalan melalui perulangan dengan benar hingga i sama dengan 4, tetapi kemudian keluar sebelum menghitung nilai akhir. Saya mulai mendapatkan beberapa ide tentang di mana bug berada. Apakah Anda?
Mari kita atur satu titik henti lagi pada baris 17, yang berbunyi:
```
return n == 0 ? n1 : n2;
```
Titik henti ini akan memungkinkan kita memeriksa status program sebelum fungsi keluar. Kita telah mempelajari semua yang kita harapkan dari titik henti sebelumnya pada baris 1 dan 13, sehingga kita dapat menghapusnya.
Hapus titik henti sebelumnya pada baris 1 dan 13. Anda bisa melakukannya dengan mengkliknya di margin di samping nomor baris, atau dengan mengosongkan kotak centang titik henti untuk baris 1 dan 13 di panel Titik Henti di kiri bawah.

Sekarang setelah kita memahami dengan lebih baik terkait apa yang terjadi dan telah menetapkan titik henti yang dirancang untuk menangkap program saat melakukan tindakan perilaku yang salah, kita seharusnya dapat menangkap bug ini!
Mulai debugger untuk terakhir kalinya.
```
n [int]: 5
n1 [int]: 2
n2 [int]: 3
sum [int]: 3
```
Yah, itu tidak benar. Kita secara khusus meminta Fibonacci(5), dan kita mendapatkan Fibonacci(4). Fungsi ini mengembalikan n2, dan setiap iterasi perulangan menghitung nilai sum dan mengatur n2 sama dengan sum.

Berdasarkan informasi ini, dan eksekusi debug sebelumnya, kita dapat melihat bahwa perulangan keluar saat i adalah 4, bukan 5.

Mari kita lihat baris pertama perulangan for sedikit lebih dekat.
```
for (int i = 2; i < n; i++)
```
Oke, tunggu sebentar! Itu berarti bahwa itu akan keluar segera setelah bagian atas for loop melihat bahwa i tidak lebih dari n. Itu berarti bahwa kode perulangan tidak akan berjalan untuk kasus saat i sama dengan n. Sepertinya apa yang kita inginkan adalah menjalankan hingga i <= n, sebagai gantinya:
```
for (int i = 2; i <= n; i++)
```
Jadi dengan perubahan itu, program yang diperbarui akan terlihat seperti contoh ini:
```
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;
}
```
Hentikan sesi penelusuran kesalahan jika Anda belum melakukannya.
Selanjutnya, buat perubahan sebelumnya ke baris 10 dan tinggalkan titik henti kami di baris 17.
Mulai ulang debugger. Kali ini, saat kita mencapai titik henti pada baris 17, kita akan melihat nilai berikut:
```
n [int]: 5
n1 [int]: 3
n2 [int]: 5
sum [int]: 5
```
Hai! Sepertinya kita berhasil! Pekerjaan bagus, Anda telah menjadi penyelamat untuk Fibonacci, Inc.!
Pilih Lanjutkan hanya untuk memastikan program mengembalikan nilai yang benar.
```
5
The program '[105260] DotNetDebugging.dll' has exited with code 0 (0x0).
```
Dan itu mengembalikan output yang benar.

Anda berhasil! Anda telah menelusuri kesalahan beberapa kode yang tidak Anda tulis dengan menggunakan debugger .NET di Visual Studio Code.

Di unit berikutnya, Anda akan mempelajari cara membuat kode yang Anda tulis lebih mudah untuk ditelusuri kesalahannya dengan menggunakan fitur pengelogan dan pelacakan yang disertakan dalam .NET.

Saran dan Komentar

Apakah halaman ini membantu?