0Pricing
C# Academy · Pelajaran

Praktik Terbaik Pembebanan Operator

Jaga agar operator yang dibebani tetap intuitif.

Praktik Terbaik Pembebanan Operator adalah pelajaran C# Academy gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar C# Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus C# Academy mencakup 4 pelajaran total.

Praktik Terbaik untuk Pembebanan Operator

Pembebanan operator adalah alat yang ampuh. Jika digunakan dengan baik, pembebanan ini membuat tipe nilai terasa intuitif; jika digunakan dengan buruk, kode menjadi sulit dipahami. Pelajaran ini membahas prinsip-prinsip yang membuat operator berbeban tetap mudah diprediksi.

Hanya Gunakan Pembebanan Saat Maknanya Jelas

Lakukan pembebanan operator hanya jika maknanya tidak ambigu untuk tipe Anda. + pada vektor jelas berarti penjumlahan per komponen; + pada Order justru akan membingungkan pembaca.

using System;

public struct Vector2
{
    public int X, Y;
    public Vector2(int x, int y) { X = x; Y = y; }
    // + means adding components: obvious and expected
    public static Vector2 operator +(Vector2 a, Vector2 b)
        => new Vector2(a.X + b.X, a.Y + b.Y);
    public override string ToString() => "(" + X + ", " + Y + ")";
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine(new Vector2(1, 2) + new Vector2(3, 4));
    }
}

Pertahankan Ekspektasi Matematis

Jaga agar operator tetap sesuai dengan intuisi: a + b harus sama dengan b + a ketika matematika yang digunakan bersifat komutatif, dan + tidak boleh diam-diam melakukan pengurangan. Kejutan seperti ini menyebabkan kesalahan yang sulit dilacak.

using System;

public struct Money
{
    public decimal Amount;
    public Money(decimal a) { Amount = a; }
    public static Money operator +(Money a, Money b) => new Money(a.Amount + b.Amount);
    public override string ToString() => "$" + Amount;
}

public class Program
{
    public static void Main()
    {
        var x = new Money(3);
        var y = new Money(5);
        Console.WriteLine((x + y).Amount == (y + x).Amount); // commutative
    }
}

Jaga Kesimetrian dan Pasangan

Bahasa tersebut memasangkan operator tertentu, tetapi Anda juga harus menjaga kesimetrian logis: jika menambahkan +, pertimbangkan -; jika menambahkan <, sediakan juga > dan varian yang sesuai untuk kesamaan. Kumpulan operator yang tidak lengkap membuat pengguna frustrasi.

using System;

public struct Length
{
    public int Mm;
    public Length(int mm) { Mm = mm; }
    public static Length operator +(Length a, Length b) => new Length(a.Mm + b.Mm);
    public static Length operator -(Length a, Length b) => new Length(a.Mm - b.Mm);
    public override string ToString() => Mm + "mm";
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine(new Length(50) + new Length(20));
        Console.WriteLine(new Length(50) - new Length(20));
    }
}

Jangan Mengubah Operan

Operator harus murni: hitung dan kembalikan nilai baru, tanpa mengubah operan. Mengubah operan di dalam + melanggar semua ekspektasi pembaca.

using System;

public struct Vector2
{
    public int X, Y;
    public Vector2(int x, int y) { X = x; Y = y; }
    public static Vector2 operator +(Vector2 a, Vector2 b)
        => new Vector2(a.X + b.X, a.Y + b.Y); // returns new, mutates nothing
    public override string ToString() => "(" + X + ", " + Y + ")";
}

public class Program
{
    public static void Main()
    {
        var a = new Vector2(1, 1);
        var unused = a + new Vector2(9, 9);
        Console.WriteLine("a is still " + a);
    }
}

Jaga Konsistensi == dengan Equals

Praktik terbaik yang penting: setiap kali Anda membebani ==, timpa Equals dan GetHashCode agar semua jalur pemeriksaan kesamaan memberikan hasil yang sama. Ketidakkonsistenan di sini adalah salah satu kesalahan operator yang paling umum.

using System;

public struct Point
{
    public int X, Y;
    public Point(int x, int y) { X = x; Y = y; }
    public override bool Equals(object obj) => obj is Point p && p.X == X && p.Y == Y;
    public override int GetHashCode() => HashCode.Combine(X, Y);
    public static bool operator ==(Point a, Point b) => a.Equals(b);
    public static bool operator !=(Point a, Point b) => !a.Equals(b);
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine(new Point(1, 1) == new Point(1, 1));
    }
}

Sediakan Alternatif Bernama

Beberapa bahasa dan alat analisis tidak dapat menggunakan operator. Menawarkan metode bernama seperti Add di samping + meningkatkan keterhubungan dan kemudahan penemuan.

using System;

public struct Vector2
{
    public int X, Y;
    public Vector2(int x, int y) { X = x; Y = y; }
    public Vector2 Add(Vector2 other) => new Vector2(X + other.X, Y + other.Y);
    public static Vector2 operator +(Vector2 a, Vector2 b) => a.Add(b);
    public override string ToString() => "(" + X + ", " + Y + ")";
}

public class Program
{
    public static void Main()
    {
        var v = new Vector2(1, 2);
        Console.WriteLine(v.Add(new Vector2(3, 4)));
        Console.WriteLine(v + new Vector2(3, 4));
    }
}

Utamakan Operator pada Tipe Mirip Nilai

Operator terasa alami pada tipe yang tidak dapat diubah dan mirip nilai, seperti struct atau kelas yang menyerupai record. Untuk tipe yang dapat diubah dan sangat bergantung pada identitas, metode bernama biasanya menyampaikan maksud dengan lebih baik.

using System;

public readonly struct Rational
{
    public readonly int Num, Den;
    public Rational(int n, int d) { Num = n; Den = d; }
    public static Rational operator *(Rational a, Rational b)
        => new Rational(a.Num * b.Num, a.Den * b.Den);
    public override string ToString() => Num + "/" + Den;
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine(new Rational(1, 2) * new Rational(2, 3));
    }
}

Dokumentasikan Kasus Khusus

Jelaskan secara eksplisit cara operator menangani nilai khusus: pembagian dengan nol, operan null pada kelas, atau luapan. Penanganan yang dapat diprediksi mencegah pemanggil terkejut.

using System;

public struct SafeDiv
{
    public int Value;
    public SafeDiv(int v) { Value = v; }
    // Documented behavior: dividing by zero yields zero
    public static SafeDiv operator /(SafeDiv a, SafeDiv b)
        => new SafeDiv(b.Value == 0 ? 0 : a.Value / b.Value);
    public override string ToString() => Value.ToString();
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine(new SafeDiv(10) / new SafeDiv(0));
        Console.WriteLine(new SafeDiv(10) / new SafeDiv(2));
    }
}

Kumpulan Operator yang Teratur

Tipe numerik yang baik menggabungkan beberapa operator intuitif, kesamaan yang konsisten, dan sifat tidak dapat diubah. Hasilnya berperilaku seperti bilangan bawaan dan menyenangkan untuk digunakan.

using System;

public readonly struct Vec
{
    public readonly double X, Y;
    public Vec(double x, double y) { X = x; Y = y; }
    public static Vec operator +(Vec a, Vec b) => new Vec(a.X + b.X, a.Y + b.Y);
    public static Vec operator -(Vec a, Vec b) => new Vec(a.X - b.X, a.Y - b.Y);
    public static Vec operator *(Vec a, double k) => new Vec(a.X * k, a.Y * k);
    public override string ToString() => "(" + X + ", " + Y + ")";
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine((new Vec(1, 2) + new Vec(3, 4)) * 2);
    }
}

Coba Sendiri

Gabungkan semua praktik tersebut: tipe nilai yang tidak dapat diubah, operator intuitif, alternatif bernama, dan kesamaan yang konsisten.

using System;

public readonly struct Meters : IEquatable<Meters>
{
    public readonly double Value;
    public Meters(double v) { Value = v; }
    public Meters Add(Meters other) => new Meters(Value + other.Value);
    public static Meters operator +(Meters a, Meters b) => a.Add(b);
    public bool Equals(Meters other) => Value == other.Value;
    public override bool Equals(object obj) => obj is Meters m && Equals(m);
    public override int GetHashCode() => Value.GetHashCode();
    public static bool operator ==(Meters a, Meters b) => a.Equals(b);
    public static bool operator !=(Meters a, Meters b) => !a.Equals(b);
    public override string ToString() => Value + "m";
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine(new Meters(3) + new Meters(4));
        Console.WriteLine(new Meters(7) == new Meters(7));
    }
}

Pemeriksaan Singkat

Terapkan praktik terbaik operator.

Rangkuman

Pembebanan operator yang baik dilakukan secara teratur dan dapat diprediksi.

  • Lakukan pembebanan hanya jika maknanya jelas.
  • Pertahankan ekspektasi matematis dan kesimetrian.
  • Tetap murni: kembalikan nilai baru dan jangan pernah mengubah operan.
  • Jaga konsistensi == dengan Equals/GetHashCode.
  • Sediakan alternatif bernama dan utamakan tipe yang mirip nilai.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Praktik Terbaik Pembebanan Operator” gratis?

Ya — teks lengkap “Praktik Terbaik Pembebanan Operator” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus C# Academy, upgrade ke CoddyKit PRO. Kursus C# Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Praktik Terbaik Pembebanan Operator”?

Jaga agar operator yang dibebani tetap intuitif. Kamu berlatih C# Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai C# Academy?

Tidak diperlukan pengalaman sebelumnya. C# Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.

Berapa lama pelajaran “Praktik Terbaik Pembebanan Operator” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran C# Academy ini?

Ya. Setiap pelajaran C# Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Membebani Operator Aritmetika
  2. Membebani Operator Perbandingan
  3. Konversi yang Didefinisikan Pengguna
  4. Praktik Terbaik Pembebanan Operator
← Kembali ke C# Academy