C# Academy · Pelajaran

Konversi yang Didefinisikan Pengguna

Tambahkan operator konversi implisit dan eksplisit.

Konversi yang Didefinisikan Pengguna adalah pelajaran C# Academy gratis di CoddyKit. Ini adalah pelajaran 3 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.

Konversi yang Ditentukan Pengguna

C# memungkinkan suatu tipe menentukan cara mengonversi dirinya ke atau dari tipe lain menggunakan operator implicit dan explicit. Konversi implisit berlangsung otomatis; konversi eksplisit memerlukan penentuan tipe secara langsung.

Konversi Implisit

Gunakan implicit operator ketika konversi selalu aman dan tidak kehilangan informasi. Kompilator menerapkannya secara otomatis di mana pun tipe tujuan diharapkan.

using System;

public struct Celsius
{
    public double Degrees;
    public Celsius(double d) { Degrees = d; }

    // Always safe: a Celsius is just a number
    public static implicit operator double(Celsius c) => c.Degrees;
}

public class Program
{
    public static void Main()
    {
        Celsius temp = new Celsius(21.5);
        double d = temp; // implicit, no cast needed
        Console.WriteLine(d);
    }
}

Konversi Eksplisit

Gunakan explicit operator ketika konversi dapat kehilangan informasi atau gagal. Pemanggil harus menuliskan konversi tipe, yang menandakan bahwa mereka menerima risikonya.

using System;

public struct Money
{
    public decimal Amount;
    public Money(decimal a) { Amount = a; }

    // Loses the fractional cents, so make it explicit
    public static explicit operator int(Money m) => (int)m.Amount;
}

public class Program
{
    public static void Main()
    {
        var m = new Money(19.99m);
        int dollars = (int)m; // explicit cast required
        Console.WriteLine(dollars);
    }
}

Mengonversi Menjadi Tipe Anda

Konversi juga dapat berlangsung ke arah sebaliknya: dari tipe lain menjadi tipe Anda. Di sini, operator implicit membuat Celsius dari double mentah.

using System;

public struct Celsius
{
    public double Degrees;
    public Celsius(double d) { Degrees = d; }

    public static implicit operator Celsius(double d) => new Celsius(d);

    public override string ToString() => Degrees + "C";
}

public class Program
{
    public static void Main()
    {
        Celsius t = 18.0; // double implicitly becomes Celsius
        Console.WriteLine(t);
    }
}

Implisit vs Eksplisit: Memilih

Aturan praktisnya: jadikan konversi implisit hanya jika konversi itu tidak pernah kehilangan data dan tidak pernah menimbulkan kesalahan. Jika konversi dapat mengurangi presisi, menyebabkan luapan, atau gagal, jadikan konversi itu eksplisit.

using System;

public struct Percentage
{
    public double Value; // 0..1
    public Percentage(double v) { Value = v; }

    // Safe and lossless -> implicit
    public static implicit operator double(Percentage p) => p.Value;
    // Could be out of range -> explicit
    public static explicit operator Percentage(double v) => new Percentage(v);
}

public class Program
{
    public static void Main()
    {
        double d = new Percentage(0.25);
        var p = (Percentage)0.5;
        Console.WriteLine(d + " " + p.Value);
    }
}

Konversi Antar Tipe Kustom

Konversi tidak terbatas pada tipe bawaan. Anda dapat melakukan konversi antara dua tipe buatan Anda sendiri, misalnya dari koordinat Polar ke koordinat Cartesian.

using System;

public struct Cartesian
{
    public double X, Y;
    public Cartesian(double x, double y) { X = x; Y = y; }
    public override string ToString() => "(" + Math.Round(X, 2) + ", " + Math.Round(Y, 2) + ")";
}

public struct Polar
{
    public double R, Theta;
    public Polar(double r, double theta) { R = r; Theta = theta; }
    public static explicit operator Cartesian(Polar p)
        => new Cartesian(p.R * Math.Cos(p.Theta), p.R * Math.Sin(p.Theta));
}

public class Program
{
    public static void Main()
    {
        var c = (Cartesian)new Polar(1.0, 0.0);
        Console.WriteLine(c);
    }
}

Konversi Berpadu dengan Operator

Setelah suatu konversi tersedia, nilai tersebut dapat digunakan dalam ekspresi bertipe tujuan. Konversi implisit ke double memungkinkan tipe Anda digunakan langsung dalam operasi aritmetika.

using System;

public struct Meters
{
    public double Value;
    public Meters(double v) { Value = v; }
    public static implicit operator double(Meters m) => m.Value;
}

public class Program
{
    public static void Main()
    {
        var distance = new Meters(5);
        double doubled = distance * 2; // uses implicit conversion to double
        Console.WriteLine(doubled);
    }
}

Hindari Konversi Implisit yang Mengejutkan

Konversi implisit yang keamanannya tidak jelas dapat menyembunyikan kesalahan karena kompiler menerapkannya secara diam-diam. Jika ragu, pilih konversi eksplisit agar maksudnya terlihat dalam kode.

using System;

public struct UserId
{
    public int Value;
    public UserId(int v) { Value = v; }
    // Explicit on purpose: an int is not always a valid id
    public static explicit operator UserId(int v) => new UserId(v);
    public static explicit operator int(UserId id) => id.Value;
}

public class Program
{
    public static void Main()
    {
        var id = (UserId)42;
        int raw = (int)id;
        Console.WriteLine(raw);
    }
}

Operator Konversi Bersifat static

Seperti operator lainnya, operator konversi bersifat public static. Tepat satu dari tipe yang terlibat harus menjadi tipe yang mendeklarasikan operator tersebut.

using System;

public struct Fahrenheit
{
    public double Degrees;
    public Fahrenheit(double d) { Degrees = d; }
    public static implicit operator Fahrenheit(double d) => new Fahrenheit(d);
    public static implicit operator double(Fahrenheit f) => f.Degrees;
    public override string ToString() => Degrees + "F";
}

public class Program
{
    public static void Main()
    {
        Fahrenheit f = 98.6;
        double d = f;
        Console.WriteLine(f + " = " + d);
    }
}

Tipe Pembungkus Praktis

Konversi sangat berguna untuk tipe pembungkus sederhana yang memperkuat sistem tipe tanpa menambah kerumitan. Di sini, NonEmptyString dikonversi secara implisit menjadi string, tetapi memerlukan konversi tipe eksplisit untuk membuatnya.

using System;

public struct NonEmptyString
{
    public string Value;
    public NonEmptyString(string v)
    {
        if (string.IsNullOrEmpty(v)) throw new ArgumentException("empty");
        Value = v;
    }
    public static explicit operator NonEmptyString(string s) => new NonEmptyString(s);
    public static implicit operator string(NonEmptyString s) => s.Value;
}

public class Program
{
    public static void Main()
    {
        var name = (NonEmptyString)"Ada";
        string s = name;
        Console.WriteLine(s);
    }
}

Coba Sendiri

Tentukan pembungkus dengan konversi implisit ke luar (aman) dan konversi eksplisit ke dalam (tervalidasi). Perhatikan arah mana yang memerlukan konversi tipe.

using System;

public struct Ratio
{
    public double Value;
    public Ratio(double v)
    {
        if (v < 0 || v > 1) throw new ArgumentOutOfRangeException(nameof(v));
        Value = v;
    }
    public static implicit operator double(Ratio r) => r.Value; // always safe
    public static explicit operator Ratio(double v) => new Ratio(v); // may throw
}

public class Program
{
    public static void Main()
    {
        var half = (Ratio)0.5;   // explicit, validated
        double d = half;          // implicit, safe
        Console.WriteLine(d * 100 + "%");
    }
}

Pemeriksaan Singkat

Pilih jenis konversi yang tepat.

Rangkuman

Konversi yang ditentukan pengguna memungkinkan tipe Anda saling berinteraksi dengan rapi.

implicit operator untuk konversi yang selalu aman dan tanpa kehilangan data.
explicit operator ketika data dapat hilang atau konversi dapat gagal.
Konversi dapat menargetkan tipe bawaan atau kustom, ke arah mana pun.
Konversi tersebut bersifat public static dan dideklarasikan oleh salah satu tipe yang terlibat.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Konversi yang Didefinisikan Pengguna” gratis?

Ya — teks lengkap “Konversi yang Didefinisikan Pengguna” 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 “Konversi yang Didefinisikan Pengguna”?

Tambahkan operator konversi implisit dan eksplisit. 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 3 dari 4.

Berapa lama pelajaran “Konversi yang Didefinisikan Pengguna” 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

← Kembali ke C# Academy