Akademi C# · Pelajaran

Penukaran Ditakrifkan Pengguna

Tambahkan operator penukaran implisit dan eksplisit.

Pelajaran 3 daripada 413 langkah

Penukaran Ditakrifkan Pengguna ialah pelajaran Akademi C# percuma di CoddyKit. Ini ialah pelajaran 3 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Akademi C#, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Akademi C# merangkumi sejumlah 4 pelajaran.

Penukaran Ditakrifkan Pengguna

C# membolehkan sesuatu jenis menentukan cara ia menukar kepada atau daripada jenis lain menggunakan operator implicit dan explicit. Penukaran tersirat berlaku secara automatik; penukaran jelas memerlukan penukaran jenis.

Penukaran implicit

Gunakan implicit operator apabila penukaran sentiasa selamat dan tidak kehilangan maklumat. Pengkompil akan menggunakannya secara automatik di mana-mana jenis sasaran dijangkakan.

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

Penukaran explicit

Gunakan explicit operator apabila penukaran boleh kehilangan maklumat atau gagal. Pemanggil mesti menulis penukaran jenis, menandakan bahawa 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);
    }
}

Menukar kepada Jenis Anda

Penukaran juga boleh berlaku ke arah yang bertentangan: daripada jenis lain kepada jenis anda. Di sini, operator implicit membina Celsius daripada 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);
    }
}

Tersirat vs Eksplisit: Membuat Pilihan

Peraturan mudah: jadikan ia tersirat hanya jika tiada data hilang dan tiada pengecualian dicetuskan. Jika ia boleh kehilangan ketepatan, mengalami limpahan atau gagal, jadikan ia 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);
    }
}

Penukaran antara Jenis Tersuai

Penukaran tidak terhad kepada jenis terbina dalam. Anda boleh menukar antara dua jenis anda sendiri, contohnya daripada koordinat Polar kepada 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);
    }
}

Penukaran Bergabung dengan Operator

Setelah wujud penukaran, nilai itu boleh mengambil bahagian dalam ungkapan jenis sasaran. Penukaran tersirat kepada double membolehkan jenis anda digunakan terus dalam pengiraan.

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

Elakkan Penukaran Tersirat yang Mengejutkan

Penukaran tersirat yang tidak jelas selamat boleh menyembunyikan pepijat kerana pengkompil menggunakannya secara senyap. Jika ragu-ragu, utamakan penukaran eksplisit supaya niatnya kelihatan dalam kod.

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 Penukaran ialah static

Seperti operator lain, operator penukaran ialah public static. Tepat satu daripada jenis yang terlibat mestilah jenis yang mengisytiharkan 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);
    }
}

Jenis Pembungkus Praktikal

Penukaran sangat berguna untuk jenis pembungkus nipis yang menguatkan sistem jenis tanpa menyusahkan. Di sini, NonEmptyString ditukar secara tersirat kepada string tetapi memerlukan penukaran eksplisit untuk dicipta.

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

Cuba Sendiri

Takrifkan pembungkus dengan penukaran keluar tersirat (selamat) dan penukaran masuk eksplisit (disahkan). Perhatikan arah yang memerlukan penukaran eksplisit.

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 + "%");
    }
}

Semakan Pantas

Pilih jenis penukaran yang betul.

Jawab dalam pelajaran interaktif

Ringkasan

Penukaran yang ditakrifkan pengguna membolehkan jenis anda saling beroperasi dengan kemas.

implicit operator untuk penukaran yang sentiasa selamat dan tidak kehilangan data.
explicit operator apabila data boleh hilang atau penukaran boleh gagal.
Penukaran boleh menyasarkan jenis terbina dalam atau jenis tersuai, dalam mana-mana arah.
Penukaran ialah public static dan diisytiharkan oleh salah satu jenis yang terlibat.

Percuma untuk bermula

Pelajari C# dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 93
Pelajaran: 346

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Penukaran Ditakrifkan Pengguna” percuma?

Ya — teks penuh “Penukaran Ditakrifkan Pengguna” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Akademi C#, tingkat taraf kepada CoddyKit PRO. Kursus Akademi C# merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Penukaran Ditakrifkan Pengguna”?

Tambahkan operator penukaran implisit dan eksplisit. Anda berlatih Akademi C# menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Akademi C#?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Akademi C# di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 3 daripada 4.

Berapa lamakah pelajaran “Penukaran Ditakrifkan Pengguna” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Akademi C# ini?

Ya. Setiap pelajaran Akademi C# menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Akademi C#