0Pricing
C# Academy · Ders

Kullanıcı Tanımlı Dönüşümler

Örtük ve açık dönüşüm işleçleri ekleyin.

Kullanıcı Tanımlı Dönüşümler, CoddyKit'te ücretsiz bir C# Academy dersidir. Bu, 4 dersinin 3. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, C# Academy öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. C# Academy kursu toplamda 4 dersten oluşur.

Kullanıcı Tanımlı Dönüşümler

C#, bir türün implicit ve explicit işleçlerini kullanarak başka bir türe nasıl dönüştürüleceğini veya başka bir türden nasıl dönüştürüleceğini tanımlamasına izin verir. Örtük dönüşümler otomatik gerçekleşir; açık dönüşler ise tür dönüşümü gerektirir.

Örtük Dönüşüm

Bir dönüşüm her zaman güvenli ve kayıpsızsa implicit operator kullanınız. Derleyici, hedef türün beklendiği her yerde bunu otomatik olarak uygular.

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

Açık Dönüşüm

Bir dönüşüm bilgi kaybına yol açabiliyor veya başarısız olabiliyorsa explicit operator kullanınız. Çağıranlar bir tür dönüşümü yazmalıdır; bu, riski kabul ettiklerini belirtir.

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

Türünüze Dönüştürme

Dönüşümler ters yönde de olabilir: başka bir türden sizin türünüze. Burada bir implicit işleci, ham bir double değerinden Celsius oluşturur.

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

Örtük mü, Açık mı: Seçim

Pratik kural şudur: veriyi hiçbir zaman kaybetmiyor ve hiçbir zaman istisna fırlatmıyorsa örtük yapın. Kesinlik kaybı, taşma veya başarısızlık olabiliyorsa açık yapın.

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

Özel Türler Arasında Dönüştürmeler

Dönüştürmeler yerleşik türlerle sınırlı değildir. Örneğin kutupsal koordinatlardan Kartezyen koordinatlara olmak üzere, kendi türleriniz arasında dönüştürme yapabilirsiniz.

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

Dönüştürmeler İşleçlerle Birleşir

Bir dönüştürme tanımlandıktan sonra değer, hedef türün ifadelerinde kullanılabilir. double türüne örtük dönüştürme, türünüzün aritmetik işlemlerde doğrudan kullanılmasını sağlar.

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

Şaşırtıcı Örtük Dönüştürmelerden Kaçının

Açıkça güvenli olmayan örtük dönüştürmeler, derleyici bunları sessizce uyguladığı için hataları gizleyebilir. Emin olmadığınızda açık dönüştürmeyi tercih edin; böylece amaç kodda görünür olur.

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

Dönüştürme İşleçleri Statiktir

Diğer işleçler gibi dönüştürme işleçleri public static olur. İlgili türlerden tam olarak biri, işleci bildiren tür olmalıdır.

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

Pratik Bir Sarmalayıcı Türü

Dönüştürmeler, tür sistemini herhangi bir zorluk çıkarmadan güçlendiren ince sarmalayıcı türlerde özellikle kullanışlıdır. Burada NonEmptyString, string türüne örtük olarak dönüştürülür, ancak oluşturulması için açık bir tür dönüştürmesi gerekir.

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

Kendiniz Deneyin

Güvenli bir dışa doğru örtük dönüştürmeye ve doğrulanmış bir içe doğru açık dönüştürmeye sahip bir sarmalayıcı tanımlayın. Hangi yönde tür dönüştürmesi gerektiğine dikkat edin.

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

Hızlı Kontrol

Uygun dönüştürme türünü seçin.

Özet

Kullanıcı tanımlı dönüştürmeler, türlerinizin sorunsuz biçimde birlikte çalışmasını sağlar.

  • Her zaman güvenli ve veri kaybı olmayan dönüştürmeler için implicit operator.
  • Veri kaybolabildiğinde veya dönüştürme başarısız olabildiğinde explicit operator.
  • Dönüştürmeler, yerleşik ya da özel türleri her iki yönde de hedefleyebilir.
  • Bunlar public static olur ve ilgili türlerden biri tarafından bildirilir.

Sıkça Sorulan Sorular

“Kullanıcı Tanımlı Dönüşümler” dersi ücretsiz mi?

Evet — “Kullanıcı Tanımlı Dönüşümler” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve C# Academy kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. C# Academy kursu toplamda 4 dersten oluşur.

“Kullanıcı Tanımlı Dönüşümler” dersinde ne öğreneceğim?

Örtük ve açık dönüşüm işleçleri ekleyin. C# Academy ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

C# Academy öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te C# Academy, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 3. dersidir.

“Kullanıcı Tanımlı Dönüşümler” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu C# Academy dersinde kod yazıp çalıştırabilir miyim?

Evet. Her C# Academy dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

  1. Aritmetik İşleçleri Aşırı Yükleme
  2. Karşılaştırma İşleçlerini Aşırı Yükleme
  3. Kullanıcı Tanımlı Dönüşümler
  4. İşleç Aşırı Yükleme için En İyi Uygulamalar
← C# Academy Sayfasına Dön