Mengenal C# dan .NET
Kenali bahasa C#, cara kerjanya, dan alat untuk menulisnya.
Mengenal C#
- 01Pahami konsepnya · 3
- 02Coba contoh kode · 2
Kenali bahasa C#, cara kerjanya, dan alat untuk menulisnya.
C# (dibaca "si sharp") adalah bahasa pemrograman modern buatan Microsoft yang berjalan di atas platform .NET. Ia kuat, bertipe ketat, dan serba bisa: aplikasi Windows, layanan web dengan ASP.NET Core, sampai game Unity semuanya ditulis dengan C#. Bagi pemula, C# ramah karena aturannya jelas dan pesan kesalahannya membimbing — kompiler menunjuk baris yang salah alih-alih diam.
Cara kerjanya dua tahap: kode sumber yang kamu tulis dikompilasi menjadi bahasa perantara, lalu dijalankan oleh runtime .NET. Artinya, program perlu dibangun dulu sebelum dijalankan — berbeda dari skrip yang langsung dieksekusi. Proses ini membuat kesalahan tertangkap lebih awal, tepat saat kamu membangun.
Untuk menulis C# kamu butuh .NET SDK. Penulisannya bisa di Visual Studio (lengkap dan khusus Windows/Mac) atau Visual Studio Code dengan ekstensi C# — pilihan kedua lebih ringan dan lintas platform. Perintah dotnet di terminal menjadi pegangan: membuat proyek, menjalankan, dan menguji semuanya dari satu kata.
Kode ini mencetak satu sapaan. using System membawa pustaka dasar berisi Console; class Program membungkus kode; dan Main adalah titik mulai — tempat runtime .NET memulai eksekusi. Lima belas baris template dotnet modern bahkan lebih ringkas lagi; strukturnya tetap ini.
Empat perintah ini seluruh siklus hari pertamamu: cek SDK terpasang, cetak proyek baru bernama halo, masuk foldernya, jalankan. Setiap kali mengubah kode, cukup dotnet run lagi — bangun dan eksekusi digabung satu perintah.
Jalankan program console dan pahami setiap barisnya.
Program console adalah tempat paling sederhana untuk berlatih sintaks. Buat proyeknya dengan dotnet new console, tulis perintah di Program.cs, lalu jalankan dengan dotnet run. Titik masuknya modern bernama top-level statements: apa pun yang kamu tulis langsung di berkas itu dieksekusi berurutan seperti naskah.
Console.WriteLine menampilkan nilai lalu berpindah baris; saudaranya Console.Write menampilkan tanpa pindah baris — berguna untuk label yang menempel pada hasil. Keduanya menerima teks, angka, ataupun hasil hitungan: WriteLine(2 + 3) mencetak 5 karena ekspresi dihitung lebih dulu.
Tiga kesalahan klasik hari pertama: lupa titik koma di akhir pernyataan, salah kapital (console kecil ditolak — C# peduli huruf besar-kecil), dan kurung kurawal yang tidak berpasangan. Kompilator menunjuk semuanya dengan nomor baris; bacalah pesannya, ia lebih ramah dari reputasinya.
WriteLine menghitung ekspresi angka sebelum mencetak — keluaran kedua adalah 5. Write pada baris ketiga tidak menurunkan baris sehingga teks keempat menyambung rapat. Simpan sebagai Program.cs lalu dotnet run: empat baris keluaran menjadi tiga karena dua teks terakhir menyatu.
Uji: program harus mencetak dua baris persis: `Halo!` lalu `46` (hasil 2026 - 1980).
Sandbox Judge0 memakai Mono 6.6. Contoh C# modern seperti switch expression memerlukan .NET SDK yang lebih baru di komputermu.
Console.WriteLine("Halo dari C#!");
Console.WriteLine(2 + 3);
Console.Write("Tanpa pindah baris, ");
Console.WriteLine("menyambung di sini.");Baca ketikan pengguna dan ubah menjadi angka.
Program baru hidup ketika membaca ketikan. Console.ReadLine() menunggu pengguna mengetik satu baris lalu menyerahkannya sebagai string — selalu teks, walau yang diketik angka. Menampilkan pertanyaan lebih dulu dengan Console.Write("... ") memberi tahu pengguna apa yang diminta; ReadLine mengambil barisnya setelah Enter ditekan.
Karena hasilnya string, berhitung perlu pengubahan: int.Parse mengubah teks menjadi bilangan bulat, double.Parse menjadi desimal. Pola lengkapnya tiga langkah — tanya, baca, ubah: Console.Write("Tinggi (cm) = "); double tinggi = double.Parse(Console.ReadLine());. Perhatikan pemakaian titik sebagai tanda desimal saat mengetik (175.5), mengikuti format bawaan pemrograman.
Menggabungkan input dengan hitungan melahirkan program sungguhan pertamamu: konversi satuan, luas bangun, sampai rekap diskon. Jika pengguna mengetik huruf padahal diminta angka, Parse akan berhenti dengan kesalahan — pelajaran try-catch di akhir kursus ini menuntaskan persis masalah itu.
Program luas tanah ini memakai pola tanya-baca-ubah dua kali, lalu menghitung langsung di dalam teks $"...". Tanda dolar memungkinkan variabel disisipkan dalam kurung kurawal — lebih bersih daripada merangkai dengan tanda tambah. Jalankan, masukkan nama dan dua ukuran, dan luasnya tercetak personalised.
Format :F1 di dalam interpolation membulatkan tampilan ke satu desimal tanpa mengubah nilai hitungannya — trik kecil yang dipakai sepanjang karier saat hasil mentah terlalu panjang. Coba 36.6 dan lihat 97.9 yang rapi.
Uji: masukkan `60` lalu `1.7` di kotak masukan — program harus mencetak persis `IMT: 20.76`.
Sandbox Judge0 memakai Mono 6.6. Contoh C# modern seperti switch expression memerlukan .NET SDK yang lebih baru di komputermu.
Console.Write("Namamu siapa? ");
string nama = Console.ReadLine();
Console.Write("Panjang (m) = ");
double panjang = double.Parse(Console.ReadLine());
Console.Write("Lebar (m) = ");
double lebar = double.Parse(Console.ReadLine());
Console.WriteLine($"Halo {nama}, luasnya {panjang * lebar} m2");Simpan nilai dalam kotak bernama bertipe yang tepat.
Variabel adalah kotak bernama di memori program. Deklarasinya menyebut tipe lalu nama: int umur; double berat; string nama; — dan pemberian nilai mengisinya: umur = 17;. Keduanya bisa sekali jalan (int umur = 17;) atau dibiarkan kosong dulu. Kata kunci var meminta kompiler menebak tipenya dari nilai awal: var skor = 95.5; menjadi double — asalkan langsung diisi, var tak boleh telanjang.
Tipe yang sering kamu jumpai: int untuk bilangan bulat, double untuk desimal umum, decimal untuk uang (presisinya dirancang khusus agar hitungan rupiah tidak berosilasi), string untuk teks, char untuk satu karakter dalam kutip satu ('L'), dan bool untuk benar-salah. Tipe yang tepat bukan formalitas: memakai double untuk uang bisa menampilkan 49999.999999 di struk belanja.
Nama variabel adalah kontrak kecil dengan dirimu sendiri: boleh huruf, angka, dan garis bawah, tak boleh diawali angka atau memakai kata kunci. Konvensi C# memakai camelCase (hargaSatuan) dan nama yang membaca seperti kalimat — totalHarga lebih jujur daripada x. Nilainya boleh diganti kapan saja; isi lama tertimpa dan hilang.
Enam kotak dengan tipe yang honor kegunaannya masing-masing. Umur bertambah satu karena isi variabel boleh ditimpa. Akhiran m menandai decimal — dan format :C0 mencetak mata uang utuh sesuai culture; contoh mengatur id-ID agar tampil sebagai Rupiah. Perhatikan char memakai kutip satu sementara string kutip dua; menukarnya adalah kesalahan klasik yang kompiler segera bisikkan.
double menyimpan pecahan biner yang tak selalu pas untuk desimal — 0.1 + 0.2 bocor jadi 0.30000...004. decimal dirancang khusus untuk desimal basis sepuluh sehingga struk, pajak, dan saldo tetap wajar. Aturan praktis: hitung fisik pakai double, hitung uang pakai decimal.
Uji: cetak kelima variabel dalam satu baris — harus persis `Kopi Susu | 24 | 18500 | K | True`.
Sandbox Judge0 memakai Mono 6.6. Contoh C# modern seperti switch expression memerlukan .NET SDK yang lebih baru di komputermu.
System.Threading.Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.GetCultureInfo("id-ID");
string nama = "Ari";
int umur = 17;
double tinggi = 168.5;
char kelas = 'A';
bool lulus = true;
umur = umur + 1; // ulang tahun!
var saldo = 125000m; // m = decimal, untuk uang
Console.WriteLine($"{nama} kelas {kelas}, umur {umur}, saldo {saldo:C0}");Hitung dengan + - * / % dan tampilkan hasil yang rapi.
Operator aritmetika C# mengikuti matematika sekolah: + - * / % (sisa pembagian). Prioritasnya juga sama — kali dan bagi dikerjakan sebelum tambah dan kurang, dan tanda kurung mengubah segalanya: 2 + 3 * 4 bernilai 14, (2 + 3) * 4 bernilai 20. Kala ragu, kurung murah dan membuat niatmu terbaca.
Satu jebakan wajib diingat: pembagian dua int memotong desimalnya — 7 / 2 bernilai 3, bukan 3.5. Salah satu sisi harus menjadi double dulu (7.0 / 2 atau (double)total / n) agar hasil pecahan selamat. Operator % justru bersinar di sini: n % 2 == 0 menguji genap, n % 10 mengambil digit terakhir.
Menampilkan hasil juga punya seni. Interpolation $"..." menyisipkan nilai langsung, dan format di dalamnya mempercantik: {x:F2} dua desimal, {x:C0} mata uang tanpa sen, {x:N0} pemisah ribuan. Dengan culture id-ID seperti di contoh, 1234567.891 menjadi "Rp1.234.568" — pembaca berterima kasih tanpa tahu harus pada siapa.
Program struk mini ini mengalir dari dua input ke rekap tiga baris rapi ber-format :C0. Perhatikan 0.11m — angka PPN ditulis sebagai decimal dengan akhiran m agar senada dengan totalnya. Coba harga 25000 jumlah 4: total Rp100.000, PPN Rp11.000, bayar Rp111.000.
Tiga baris ini merangkum seluruh jebakan: int / int memotong, konversi salah satu sisi menyelamatkan pecahan, dan % menyerahkan sisanya. Rata-rata pun aman selama ingat mengubah total ke double sebelum membagi jumlah data.
Uji: masukkan total `100000` dan `4` orang — program harus mencetak persis `25000.00`.
Sandbox Judge0 memakai Mono 6.6. Contoh C# modern seperti switch expression memerlukan .NET SDK yang lebih baru di komputermu.
System.Threading.Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.GetCultureInfo("id-ID");
Console.Write("Harga satuan = ");
decimal harga = decimal.Parse(Console.ReadLine());
Console.Write("Jumlah = ");
int jumlah = int.Parse(Console.ReadLine());
decimal total = harga * jumlah;
decimal ppn = total * 0.11m;
Console.WriteLine($"Total : {total:C0}");
Console.WriteLine($"PPN 11%: {ppn:C0}");
Console.WriteLine($"Bayar : {total + ppn:C0}");Bercabang lewat perbandingan, else-if, dan kenali lingkup variabel.
Perbandingan menghasilkan bool: == sama dengan, != tidak sama, < > <= >= seperti matematika. Blok if menjalankan kodenya hanya bila kondisi true; else menampung sisanya; dan rangkaian else if menguji beberapa kemungkinan berurutan — yang pertama cocok menang, sisanya dilewati. Kurung kurawal wajib membungkus blok, sekalipun isinya satu baris.
Hal yang kerap menjegal pemula: variabel yang dideklarasikan di dalam blok hanya hidup di blok itu — lingkup (scope)-nya berakhir saat kurung penutup. Memakainya di luar berarti kompilasi gagal. Bila sebuah nilai dibutuhkan lintas cabang, deklarasikan sebelum if dan isi di dalamnya.
Berkenalanlah juga dengan debugger, sahabat terbaik saat logika melenceng: klik di pinggir baris untuk pasang breakpoint, jalankan mode debug, dan program berhenti tepat di titik itu — periksa nilai variabel saat itu, lalu melangkah baris demi baris melihat cabang mana yang sebenarnya diambil. Setengah bug logika selesai hanya dengan melihat nilai yang tak sesuai dugaan.
Rantai else if diuji dari atas: nilai 85 gagal di >= 90, lolos di >= 80, dan dua cabang sisanya tak pernah disentuh. Variabel predikat sengaja dideklarasikan SEBELUM if agar tetap hidup sesudahnya — pindahkan deklarasinya ke dalam blok pertama dan kompiler menolak pemakaiannya di baris terakhir. Inilah pelajaran lingkup dalam satu contoh.
Sisa bagi dua menjadi penentu: nol berarti pas berpasangan (genap), satu berarti ada yang menganggang (ganjil). Pola n % 2 ini muncul di mana-mana — dari selang-seling warna baris tabel sampai memilah data.
Uji: dengan tahun `2024` harus mencetak `kabisat`; ganti ke `1900` dan harus mencetak `bukan`.
Sandbox Judge0 memakai Mono 6.6. Contoh C# modern seperti switch expression memerlukan .NET SDK yang lebih baru di komputermu.
Console.Write("Nilai ujian = ");
int nilai = int.Parse(Console.ReadLine());
string predikat;
if (nilai >= 90)
{
predikat = "A — luar biasa";
}
else if (nilai >= 80)
{
predikat = "B — bagus";
}
else if (nilai >= 70)
{
predikat = "C — cukup";
}
else
{
predikat = "D — ayo remedial";
}
Console.WriteLine($"Predikatmu: {predikat}");Gabungkan beberapa syarat jadi satu keputusan.
Kehidupan nyata jarang bersyarat tunggal: diskon untuk pelanggan baru DAN belanja di atas seratus ribu; masuk kalau punya tiket ATAU nama tamu. Operator logika menjahit syarat-syarat itu: && (dan) menuntut keduanya benar, || (atau) cukup salah satu, dan ! membalik kebenaran. Prioritasnya && lebih rapat daripada ||, jadi a || b && c dibaca a || (b && c) — kurung tetap penyelamat keraguan.
Jalan lain adalah if bersarang: if di dalam if, masing-masing menguji satu lapis syarat. Ia sah dan kadang lebih jelas bertingkat, tapi sering bisa diratakan — dua if bersarang setara satu if dengan &&. Pilih yang terbaca paling alami: bertingkat untuk proses dua tahap, gabungan untuk satu pertanyaan majemuk.
Trik membaca kondisi panjang: ucapkan dengan "dan"/"atau" manusiawi. umur < 12 && pendamping berlebih dari dua dibaca "usianya di bawah 12 dan pendampingnya lebih dari dua" — kalimat yang terbaca aneh menandakan logikanya perlu dirapikan, bukan sekadar diketik.
Kondisi utamanya majemuk sungguhan: kelompok (umur < 12 ATAU >= 60) DAN hari kerja — kurung mengelompokkan "atau" sebelum "dan" bekerja. Coba tiga kombinasi berbeda dan bandingkan harganya; lalu coba tukar posisi kurungnya dan rasakan bagaimana makna ikut berubah.
Dua versi ini identik hasilnya — pilih sesuai selera keterbacaan. Versi bersarang bercerita dua tahap ("periksa sandi dulu, baru hitung percobaan"), versi gabungan bertanya sekali jadi. Bila kelak perlu aksi berbeda per tahap (pesan salah sandi vs pesan terkunci), bersarang menang karena bisa menyisipkan else di tiap tingkat.
Uji: dengan `tidak`, `ya`, `2` harus mencetak `masuk`; ganti buku ke `0` dan harus mencetak `ditolak`.
Sandbox Judge0 memakai Mono 6.6. Contoh C# modern seperti switch expression memerlukan .NET SDK yang lebih baru di komputermu.
System.Threading.Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.GetCultureInfo("id-ID");
Console.Write("Umur = ");
int umur = int.Parse(Console.ReadLine());
Console.Write("Hari (kerja/akhir) = ");
string hari = Console.ReadLine();
double tiket = 50000;
if ((umur < 12 || umur >= 60) && hari == "kerja")
{
tiket *= 0.5; // diskon 50%: rentan usia di hari kerja
}
else if (hari == "akhir")
{
tiket *= 0.9; // akhir pekan selalu -10%
}
Console.WriteLine($"Tiketmu: {tiket:C0}");Satu nilai, banyak cabang — lebih rapi dari else-if panjang.
Ketika satu nilai menghadapi banyak kemungkinan — angka pilihan menu, kode hari, huruf nilai — else-if berantai mulai terasa berdebu. switch lahir untuk itu: nilainya ditulis sekali, tiap case menyandingkan satu kemungkinan, dan default menampung sisanya. Setiap cabang wajib ditutup break; C# melarang jatuh menerus ke case berikutnya seperti bahasa lain.
Kecocokannya presisi dan terbatas: angka, char, string, atau enum — bukan rentang. Artinya switch tidak menggantikan if, melainkan melengkapinya: if untuk pertanyaan rentan ("lebih dari 80?"), switch untuk pertanyaan tepat ("pilihan 1, 2, atau 3?"). Beberapa nilai boleh berbagi cabang dengan ditumpuk case per baris.
Versi modernnya bahkan lebih manis: switch sebagai ekspresi yang mengembalikan nilai. int diskon = hari switch { "senin" => 20, "jumat" => 15, _ => 0 }; — tanda garis bawah adalah defaultnya. Bentuk panjang dan pendek ini pilih sesuai beratnya keputusan; keduanya membaca seperti menu.
Satu variabel pilih, empat cabang bersih. Ketik 2 dan "Teh (Rp8.000)" tercetak; ketik 9 dan default menahan agar program tidak jatuh tanpa jawaban. Bandingkan versi else-if-nya — semakin banyak menu, semakin jelas keunggulan keterbacaan switch.
Bentuk ekspresi mengembalikan nilai tanpa break. Pola "senin" or "selasa" menggabung dua nilai; garis bawah menampung sisanya. Contoh ini memerlukan C# 9+ dan tidak bisa dijalankan di compiler Mono situs; jalankan dengan .NET SDK lokal.
Uji: pilihan `3` harus mencetak `C`; pilihan `9` harus mencetak `-`.
Sandbox Judge0 memakai Mono 6.6. Contoh C# modern seperti switch expression memerlukan .NET SDK yang lebih baru di komputermu.
System.Threading.Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.GetCultureInfo("id-ID");
Console.WriteLine("=== KAFE KODE ===");
Console.WriteLine("1. Kopi Rp15000");
Console.WriteLine("2. Teh Rp8000");
Console.WriteLine("3. Susu Rp12000");
Console.Write("Pilihanmu: ");
int pilih = int.Parse(Console.ReadLine());
string menu;
int harga;
switch (pilih)
{
case 1:
menu = "Kopi"; harga = 15000; break;
case 2:
menu = "Teh"; harga = 8000; break;
case 3:
menu = "Susu"; harga = 12000; break;
default:
menu = "-"; harga = 0; break;
}
Console.WriteLine($"Kamu memesan {menu} ({harga:C0})");Ulangi blok kode sejumlah yang kamu tentukan.
Komputer unggul pada satu hal: mengulang tanpa lelah dan tanpa salah. Perulangan for mengulang blok sejumlah yang kamu tentukan lewat tiga bagian dalam kurungnya — nilai awal, syarat lanjut, dan langkah: for (int i = 1; i <= 10; i++). Variabel i menjadi hitungan putaran: lahir di 1, naik satu tiap putaran, dan begitu syaratnya palsu, loop berhenti.
Titik mulai dan langkah bebas kamu atur: i = 0 dengan i < n adalah konvensi berbasis nol (warisan indeks array), i = n dengan i-- menghitung mundur, i += 2 melompat dua-dua. Yang penting syaratnya suatu saat menjadi palsu — bila tak pernah, loop berputar selamanya.
Pola paling produktif di dalam loop adalah akumulator: variabel total yang dideklarasikan sebelum loop, lalu ditambah di tiap putaran. Jumlahkan 1 sampai 100, rekap nilai siswa, hitung total belanja — semuanya pola yang sama: nol di awal, tambah di dalam, baca di akhir. Bila perlu input berulang, ReadLine pun boleh hidup di dalam loop.
Akumulator total lahir nol, menyerap tiap i sepanjang putaran, dan dibaca setelah loop usai. Untuk n = 100 hasilnya 5050 — ditebak Gauss kecil tanpa loop, tapi programmu tak perlu cerdik, cukup rajin. Ubah langkahnya jadi i += 2 dan kamu menghitung jumlah bilangan ganjil saja.
Contoh pertama memakai i langsung dalam cetakan — {i,2} meratakan kolom dua karakter. Contoh kedua menggabung tiga pelajaran sekaligus: input di dalam loop, akumulator, dan pembagian double untuk rata-rata berformat dua desimal.
Uji: dengan n = 5 program harus mencetak persis `120` (5 faktorial).
Sandbox Judge0 memakai Mono 6.6. Contoh C# modern seperti switch expression memerlukan .NET SDK yang lebih baru di komputermu.
Console.Write("Sampai angka berapa? ");
int n = int.Parse(Console.ReadLine());
int total = 0;
for (int i = 1; i <= n; i++)
{
total += i;
}
Console.WriteLine($"Jumlah 1 sampai {n} = {total}");Loop dalam loop: koordinat baris dan kolom.
Loop bersarang adalah loop di dalam loop — dan intuisinya sederhana: untuk TIAP putaran loop luar, loop dalam menyelesaikan seluruh putarannya lebih dulu. Kalau luar berputar 5 kali dan dalam 10, isi dijalankan 50 kali total. Bayangkan jam: jarum menit menunggu jarum detik menuntaskan putaran penuhnya.
Pola khasnya dua variabel berperan sebagai koordinat: i untuk baris, j untuk kolom. Iterasi pertama lahir dari kombinasi keduanya — baris ke-2 kolom ke-3, baris ke-4 kolom ke-1 — menjadikan loop bersarang mesin cetak alami untuk tabel, kotak, dan segitiga ASCII. String builder kecil di dalam loop luar merangkai satu baris utuh sebelum WriteLine mencetaknya.
Menggambar figur menajamkan nalarnya: segitiga bintang berarti j bergantung pada i (kolom bertambah tiap baris), persegi berarti j tetap rentangnya, dan bentuk cekung memakai i untuk batas atas dan bawah sekaligus. Latihan klasik ini melatih mata melihat pola — keterampilan sesungguhnya dari bab ini.
Baris pertama dibangun saat i = 1: loop dalam hanya berputar sekali karena batasnya j <= i. Tiap baris berikut kolomnya bertambah — segitiga tumbuh. Kunci ubahannya ada di batas loop dalam: ganti j <= i dengan j <= tinggi dan segitiga melurus menjadi persegi.
Dua figur memakai rangka loop yang persis sama — bedanya hanya isi cetakan: bintang tetap versus hasil i*j berkolom rata {,4}. Inilah pelajaran sejatinya: loop bersarang menyediakan kisi baris-kolom, kamu yang memutuskan apa yang ditulis di tiap selnya.
Uji: gambar persegi tepi 5×5 — baris pertama/terakhir penuh bintang, tiga baris tengah hanya `*` di ujung.
Sandbox Judge0 memakai Mono 6.6. Contoh C# modern seperti switch expression memerlukan .NET SDK yang lebih baru di komputermu.
Console.Write("Tinggi segitiga: ");
int tinggi = int.Parse(Console.ReadLine());
for (int i = 1; i <= tinggi; i++)
{
string baris = "";
for (int j = 1; j <= i; j++)
{
baris += "* ";
}
Console.WriteLine(baris);
}Ulangi selama syarat benar — bahkan ketika jumlahnya tak diketahui.
for pas ketika jumlah putaran sudah terbet. while lahir untuk sisanya: ulangi selama syaratnya benar, berapa kali pun itu. Sintaksnya telanjang — while (syarat) { ... } — dan seluruh kendali ada di tanganmu: variabel penghitung (bila perlu) kamu siapkan sendiri sebelum loop dan maju sendiri di dalamnya. Lupa maju berarti berputar selamanya, kesalahan paling terkenal di dunia loop.
do-while membalik urutan uji: badannya dijalankan dulu sekali, barulah syarat diperiksa. Hasilnya minimal satu putaran — pas untuk menu yang harus tampil sekencang apa pun keadaannya, atau pertanyaan yang wajib dijawab sebelum boleh lanjut.
break keluar dari loop seketika, dan kombinasi klasiknya adalah loop sengaja tanpa henti: while (true) membaca input terus, dan break menghentikannya begitu pengguna mengetik tanda berhenti seperti "selesai" atau angka 0. Pola "baca sampai tanda stop" ini adalah bentuk paling alami memproses data yang panjangnya ditentukan pengguna.
Loop sengaja abadi while (true) dijaga oleh break: angka 0 tak pernah masuk hitungan, hanya memutus loop. Akumulator ganda (total dan banyak) memungkinkan rata-rata di akhir — coba 10, 20, 30, lalu 0. Bila ketukan pertama saja 0, pembaginya nol-nol — pelajaran try-catch dan pemeriksaan menyusul menuntaskan kasus ini.
Menu tampil dulu sekali tanpa syarat — itulah janji do-while — lalu terus berulang selama pilihan bukan "3". Bandingkan versi while-nya: ia harus memeriksa pilihan SEBELUM loop pertama, dan menu tak akan tampil bila variabelnya kebetulan "3" sejak awal.
Uji: masukkan `4050` — program harus mencetak persis `4` (jumlah digitnya).
Sandbox Judge0 memakai Mono 6.6. Contoh C# modern seperti switch expression memerlukan .NET SDK yang lebih baru di komputermu.
Console.WriteLine("Ketik angka untuk dijumlahkan, 0 untuk berhenti.");
double total = 0;
int banyak = 0;
while (true)
{
Console.Write("> ");
double angka = double.Parse(Console.ReadLine());
if (angka == 0) break;
total += angka;
banyak++;
}
Console.WriteLine($"Total {total} dari {banyak} angka, rata-rata {total / banyak:F2}");Tangkap ketikan rusak agar program tidak mati mendadak.
Ketik "abc" saat program meminta angka dan int.Parse melempar pengecualian (exception) — sinyal darurat yang menghentikan program seketika dengan pesan merah yang menakutkan. try-catch adalah jaring penyelamatnya: bungkus kode yang berisiko dalam blok try, dan catch menangkap gangguan itu sebelum mematikan program, memberimu kesempatan merespons dengan santun.
Bentuk lengkapnya menangkap tipe yang tepat: FormatException untuk teks yang tak terbaca sebagai angka, OverflowException untuk angka yang terlalu besar. Di dalam catch, cukup sampaikan pesan yang manusiawi ("Angka saja ya") — program tetap hidup dan boleh melanjutkan.
Kombinasi paling ampuh: try-catch di dalam loop baca-ulang. Baca gagal? Tampilkan pesan, loop berputar lagi, pengguna mencoba lagi — baca berhasil? break keluar. Hasilnya input yang divalidasi tanpa program pernah mati, pola yang dipakai setiap aplikasi serius di dunia nyata untuk data yang tak boleh rusak.
Dua lapis pertahanan bekerja bersama: catch menangkap ketikan non-angka, dan pemeriksaan rentang menolak angka yang tak masuk akal — keduanya membuat loop berputar ulang, dan hanya kombinasi sah yang lolos lewat break. Ketik "abc", lalu 500, lalu 17 untuk merasakan ketiganya bekerja.
TryParse adalah adik santai Parse: ia tak pernah melempar pengecualian — mengembalikan bool saja, dan hasil konversinya keluar lewat parameter out. if-else biasa cukup menanganinya. Dua gaya ini hidup berdampingan: try-catch untuk melindungi blok besar, TryParse untuk satu pembacaan bersih.
Uji: ketik `abc` lalu `60` — setelah pesan peringatan, program harus berakhir mencetak persis `60`.
Sandbox Judge0 memakai Mono 6.6. Contoh C# modern seperti switch expression memerlukan .NET SDK yang lebih baru di komputermu.
int umur;
while (true)
{
Console.Write("Umurmu (1-120): ");
try
{
umur = int.Parse(Console.ReadLine());
if (umur >= 1 && umur <= 120) break;
Console.WriteLine("Di luar rentang wajar, coba lagi.");
}
catch (FormatException)
{
Console.WriteLine("Itu bukan angka — angka saja ya.");
}
}
Console.WriteLine($"Tercatat: {umur} tahun.");Kemas langkah bernama yang bisa dipanggil ulang dan mengembalikan hasil.
Method adalah potongan kode bernama yang menjalankan satu tugas — dipanggil cukup dengan namanya, kapan pun, berapa kali pun. Ia menerima bekal lewat parameter, dan boleh mengembalikan hasil lewat return. Deklarasinya menyebut tipe hasilnya (atau void bila tak mengembalikan apa pun), namanya, lalu daftar parameternya: double Diskon(double harga, int persen).
return sekaligus menutup panggung: baris itu berada, method selesai, dan nilai setelahnya diserahkan kepada pemanggil. Dalam method void, return telanjang hanya berperan sebagai pintu keluar darurat. Data masuk lewat parameter, keluar lewat return — jalur yang jernih inilah yang membuat method mudah dipakai ulang dan dites.
Dua pemanis lanjutan: overloading membolehkan beberapa method bernama sama selama parameternya berbeda — Print(int) dan Print(string) hidup damai, kompiler memilih yang pas menurut argumenmu. Dan satu method boleh mengembalikan beberapa nilai sekaligus lewat tuple: (int min, int maks) — dibongkar langsung ke dua variabel. Aturan penamaannya sama seperti variabel: kata kerja jelas untuk aksi (HitungTotal, CekLogin), dan satu method satu tanggung jawab.
Dua method kecil bekerja untuk satu program: Diskon menghitung dan mengembalikan angka, Kategori memutuskan dan mengembalikan teks — return-nya bahkan tiga cabang, masing-masing menutup method ketika giliran. Panggilannya terbaca seperti kalimat: harga dikurangi Diskon(harga, 20). Inilah kenaikan level: logika diberi nama, lalu disusun.
Dua Sapa hidup berdampingan karena parameternya berbeda — kompiler memilih sesuai jumlah argumen yang kamu kirim. Method Rentang mengembalikan dua nilai sekaligus sebagai tuple bernama, dibongkar langsung ke kecil dan besar. Multi-return tanpa ceremony seperti variabel cadangan.
Uji: lengkapi HitungPajak (5%) — dengan gaji `2000000` program harus mencetak persis `Pajak: 100000`.
Sandbox Judge0 memakai Mono 6.6. Contoh C# modern seperti switch expression memerlukan .NET SDK yang lebih baru di komputermu.
using System;
class Program
{
static double Diskon(double harga, int persen)
{
return harga * persen / 100;
}
static string Kategori(double imt)
{
if (imt < 18.5) return "Kurus";
if (imt < 25) return "Ideal";
return "Berlebih";
}
static void Main()
{
System.Threading.Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.GetCultureInfo("id-ID");
Console.Write("Harga = ");
double harga = double.Parse(Console.ReadLine());
double bayar = harga - Diskon(harga, 20);
Console.WriteLine($"Setelah diskon 20%: {bayar:C0}");
Console.Write("IMT = ");
double imt = double.Parse(Console.ReadLine());
Console.WriteLine($"Kategori: {Kategori(imt)}");
}
}Kelola kumpulan nilai dan pecah logika menjadi method.
Array berukuran tetap; List<T> tumbuh sesuai kebutuhan — tambah dengan Add, lepas dengan Remove, dan hitung isinya lewat Count. Huruf T adalah tipe isinya: List<int> untuk angka, List<string> untuk teks. Menyusurinya paling enak dengan foreach: untuk tiap elemen, jalankan blok — tanpa indeks, tanpa risiko meleset batas.
Nilai terkumpul menjadi hidup lewat operasi ringkasan: total (akumulator di foreach), rata-rata (total dibagi Count), nilai terbesar dan terkecil (jaga sementara di variabel penampung, perbarui tiap elemen). Tiga pola ini menuntaskan mayoritas laporan data harian.
Saat program membesar, method menjadi lantai penyusunnya: satu method mengumpulkan input (loop + Add), satu menghitung ringkasan (loop + akumulator), satu mencetak laporan. Main menyerhana menjadi daftar panggilan yang terbaca seperti daftar isi — inilah cara kode besar tetap terkelola: potongan kecil bernama, masing-masing satu tugas.
Dua method statis menerima List<int> sebagai parameter dan mengembalikan hasilnya. Main mengatur alur, foreach mengolah setiap nilai, dan using System.Collections.Generic menyediakan List<T>.
Add menambah di akhir, Remove menghapus nilai yang cocok. Bentuk new List<string> { ... } mengisi nilai awal sekaligus tanpa Add berulang. Untuk daftar dari pengguna, gabungkan dengan loop baca-sampai-selesai pelajaran while.
Uji: masukkan kopi/12000, teh/8000, lalu selesai — baris terakhir harus `Termahal: kopi (12000)`.
Sandbox Judge0 memakai Mono 6.6. Contoh C# modern seperti switch expression memerlukan .NET SDK yang lebih baru di komputermu.
using System;
using System.Collections.Generic;
class Program
{
static int Terbesar(List<int> data)
{
int maks = data[0];
foreach (int n in data)
if (n > maks) maks = n;
return maks;
}
static double Rata(List<int> data)
{
double total = 0;
foreach (int n in data) total += n;
return total / data.Count;
}
static void Main()
{
List<int> nilai = new List<int> { 80, 90, 75, 95, 68 };
foreach (int n in nilai) Console.WriteLine($"Nilai: {n}");
Console.WriteLine($"Terbesar: {Terbesar(nilai)}");
Console.WriteLine($"Rata-rata: {Rata(nilai):F2}");
}
}