Struct di C#: Value Type, Struct vs Class dan Kapan Memakainya

Struct adalah value type yang kamu definisikan sendiri. Bentuknya mirip class, dengan field, property, method, dan constructor, tetapi variabel bertipe struct berisi datanya secara langsung, bukan referensi ke sebuah object. Satu perbedaan itu mengubah perilaku assignment, pemanggilan method, kesamaan, dan null.

Semantik nilai: assignment menyalin

Tipe numerik bawaan, bool, char, DateTime, TimeSpan, dan Guid semuanya adalah struct. Struct buatanmu sendiri bekerja dengan cara yang sama:

using System;

struct PointS
{
    public int X;
    public int Y;
    public PointS(int x, int y) { X = x; Y = y; }
}

class PointC
{
    public int X;
    public int Y;
    public PointC(int x, int y) { X = x; Y = y; }
}

class Program
{
    static void Move(PointS p) { p.X += 100; }   // changes a copy
    static void Move(PointC p) { p.X += 100; }   // changes the caller's object

    static void Main()
    {
        var s1 = new PointS(1, 2);
        var s2 = s1;          // copies the whole value
        s2.X = 50;

        var c1 = new PointC(1, 2);
        var c2 = c1;          // copies the reference
        c2.X = 50;

        Console.WriteLine($"struct: s1.X = {s1.X}, s2.X = {s2.X}");
        Console.WriteLine($"class:  c1.X = {c1.X}, c2.X = {c2.X}");

        Move(s1);
        Move(c1);
        Console.WriteLine($"after Move: s1.X = {s1.X}, c1.X = {c1.X}");
    }
}

Output:

struct: s1.X = 1, s2.X = 50
class:  c1.X = 50, c2.X = 50
after Move: s1.X = 1, c1.X = 150

Dengan struct, s2 adalah salinan yang berdiri sendiri, dan Move juga bekerja pada salinannya sendiri. Agar sebuah method bisa mengubah struct milik pemanggil, teruskan by reference dengan ref (lihat ref dan out). Untuk menghindari penyalinan struct besar tanpa mengizinkan perubahan, C# 7.2 menambahkan parameter in.

Konsekuensi lain dari value type:

• Variabel struct tidak pernah bisa null. PointS p = null; tidak bisa dikompilasi. Pakai PointS? (nullable value type) jika "tidak ada nilai" punya arti.
• Struct yang belum diinisialisasi berisi nol semua: field numerik 0, field bool bernilai false, field reference bernilai null.
• Struct tidak bisa mewarisi struct atau class lain, dan tidak ada yang bisa mewarisi struct. Struct bisa mengimplementasikan interface.
• Variabel struct lokal biasanya berada di stack atau di dalam object yang memuatnya, jadi membuatnya tidak mengalokasikan memori di heap.

Jebakan List berisi struct: CS1612

Karena membaca struct menghasilkan salinan, baris yang terlihat polos ini tidak bisa dikompilasi:

var points = new List<PointS> { new PointS(1, 2) };
points[0].X = 10;
// error CS1612: Cannot modify the return value of 'List<PointS>.this[int]' because it is not a variable

Indexer List<T> adalah method yang mengembalikan salinan elemennya. Mengisi X pada salinan sementara itu tidak akan mengubah apa pun, jadi compiler menghentikanmu. Error yang sama muncul saat sebuah property mengembalikan struct: order.Location.X = 10. Salin, ubah, lalu tulis kembali:

using System;
using System.Collections.Generic;

struct Stock
{
    public string Sku;
    public int Quantity;
}

class Program
{
    static void Main()
    {
        var list = new List<Stock> { new Stock { Sku = "PEN-01", Quantity = 40 } };
        var item = list[0];     // a copy
        item.Quantity -= 5;
        list[0] = item;         // write the copy back
        Console.WriteLine(list[0].Quantity);

        var array = new Stock[] { new Stock { Sku = "INK-02", Quantity = 12 } };
        array[0].Quantity -= 5; // arrays give direct access to the element
        Console.WriteLine(array[0].Quantity);

        foreach (var s in array)
        {
            // s.Quantity = 0; // error CS1654: the foreach variable is a read-only copy
        }
    }
}

Output:

35
7

Array adalah pengecualiannya: array[0] adalah elemen itu sendiri, bukan salinan. Masalah yang terus berulang ini adalah alasan di balik saran standar untuk membuat struct immutable: jika struct tidak bisa diubah, tidak ada yang hilang saat mengubah sebuah salinan.

Constructor dan nilai default

Di C# 7 sampai 9, aturan untuk constructor struct cukup ketat:

• Kamu tidak bisa mendeklarasikan constructor tanpa parameter. new PointS() selalu ada dan mengisi setiap field dengan nol.
• Constructor yang kamu deklarasikan wajib mengisi setiap field (dan auto-property) sebelum selesai.
• Field initializer (public int X = 1;) tidak diizinkan pada field instance.

using System;

struct Money
{
    public decimal Amount { get; }
    public string Currency { get; }

    public Money(decimal amount, string currency)
    {
        Amount = amount;       // leaving either one unassigned is a compile error
        Currency = currency;
    }

    public override string ToString() => $"{Amount:F2} {Currency ?? "(none)"}";
}

class Program
{
    static void Main()
    {
        var price = new Money(19.9m, "EUR");
        var zero = new Money();          // always available: all fields zeroed
        var alsoZero = default(Money);   // same thing

        Console.WriteLine(price);
        Console.WriteLine(zero);
        Console.WriteLine(alsoZero);
        var slots = new Money[2];        // arrays of structs start zeroed too
        Console.WriteLine(slots[1]);
    }
}

Output:

19.90 EUR
0.00 (none)
0.00 (none)
0.00 (none)

Money juga menunjukkan kenapa nilai default itu penting: Money yang bernilai nol punya currency null, dan kodemu harus menanganinya, karena array, default(T), dan field yang belum diinisialisasi semuanya menghasilkan nilai seperti itu.

Versi yang lebih baru melonggarkan aturan ini:

// C# 10: explicit parameterless constructors and field initializers
public struct Settings
{
    public int Retries = 3;
    public Settings() { }
}

// C# 11: fields you do not assign in a constructor are zeroed automatically,
// instead of being a compile error.

Constructor tanpa parameter di C# 10 dijalankan untuk new Settings(), tetapi tidak untuk default(Settings) atau elemen array, yang tetap berisi nol semua. Perbedaan ini sering mengejutkan orang, jadi pakailah dengan hati-hati.

readonly struct (C# 7.2)

Menandai struct itu sendiri sebagai readonly membuat compiler menegakkan sifat immutable: setiap field harus readonly dan setiap auto-property harus get-only.

public readonly struct Temperature
{
    public double Celsius { get; }
    public Temperature(double celsius) { Celsius = celsius; }

    public Temperature WarmerBy(double delta) => new Temperature(Celsius + delta);   // returns a new value
}

Selain mendokumentasikan maksudnya, ini membantu performa: saat struct yang tidak readonly disimpan di field readonly atau diteruskan sebagai parameter in, compiler menyalinnya sebelum setiap pemanggilan method (compiler tidak bisa tahu bahwa method itu tidak akan mengubahnya). readonly struct tidak butuh defensive copy seperti itu. Di C# 7.0 kamu tetap bisa membuat setiap field readonly, seperti yang dilakukan Money dengan property get-only: itu memberimu sifat immutable, tetapi tidak menghemat salinan, karena compiler hanya memercayai struct yang dideklarasikan readonly.

Kesamaan

Secara default, Equals pada struct membandingkan field demi field, dan itulah perilaku nilai yang kamu inginkan. Tetapi implementasi default-nya (ValueType.Equals) bisa memakai reflection dan lambat, dan operator == sama sekali tidak didefinisikan: a == b pada struct buatanmu adalah error CS0019. Implementasikan keduanya jika struct itu akan dibandingkan:

using System;

struct GridCell : IEquatable<GridCell>
{
    public readonly int Row, Col;
    public GridCell(int row, int col) { Row = row; Col = col; }

    public bool Equals(GridCell other) => Row == other.Row && Col == other.Col;
    public override bool Equals(object obj) => obj is GridCell c && Equals(c);
    public override int GetHashCode() => (Row, Col).GetHashCode();

    public static bool operator ==(GridCell a, GridCell b) => a.Equals(b);
    public static bool operator !=(GridCell a, GridCell b) => !a.Equals(b);
}

class Program
{
    static void Main()
    {
        var a = new GridCell(2, 3);
        var b = new GridCell(2, 3);
        Console.WriteLine(a == b);
        Console.WriteLine(a.Equals(b));

        var visited = new System.Collections.Generic.HashSet<GridCell> { a };
        Console.WriteLine(visited.Contains(b));
    }
}

Output:

True
True
True

Mengimplementasikan IEquatable<T> penting untuk collection: HashSet<T>, Dictionary<TKey, TValue>, dan List<T>.Contains memanggil Equals(GridCell) secara langsung alih-alih melakukan boxing pada setiap nilai untuk memanggil Equals(object). Record struct (di bawah) membuat semua ini untukmu.

Boxing

Mengonversi struct menjadi object atau menjadi tipe interface akan melakukan boxing: runtime menyalin nilainya ke object baru di heap. Setelah itu, box dan nilai aslinya tidak saling bergantung:

using System;

struct Counter
{
    public int Count;
    public void Increment() => Count++;
}

class Program
{
    static void Main()
    {
        var c = new Counter();
        object boxed = c;       // copy into a heap object
        c.Increment();
        c.Increment();

        Console.WriteLine(c.Count);
        Console.WriteLine(((Counter)boxed).Count);   // unboxing copies it back out
    }
}

Output:

2
0

Boxing butuh satu alokasi setiap kali terjadi, itulah sebabnya collection lama yang non-generic seperti ArrayList lambat untuk value type, dan itulah sebabnya generic menggantikannya. Ini juga berarti struct yang bisa diubah dan diakses lewat interface akan berubah di box-nya, bukan di nilai aslinya, satu alasan lagi untuk menjaga struct tetap immutable.

Struct vs class

Kapan memakai struct

Pilih struct jika semua hal ini terpenuhi: tipe itu adalah satu nilai logis (koordinat, jumlah uang, warna, rentang tanggal), ukurannya kecil (panduan Microsoft sekitar 16 byte, kira-kira empat int), immutable, dan kamu tidak butuh pewarisan. Struct menguntungkan saat kamu membuatnya dalam jumlah sangat banyak, misalnya jutaan titik di dalam array, karena struct menghindari satu alokasi heap dan satu entri garbage collector untuk setiap item.

Pilih class untuk apa pun yang punya identitas (pelanggan, pesanan), apa pun yang besar, apa pun yang diubah dari beberapa tempat, dan setiap kali kamu ragu. Struct besar yang bisa diubah memberimu biaya penyalinan plus kebingungan karena mengubah salinan.

record struct (C# 10)

C# 10 menambahkan record struct, yang membuat value equality, ==, ToString, dan dukungan with untuk sebuah struct dalam satu baris:

public readonly record struct Coordinate(double Lat, double Lng);

var home = new Coordinate(38.72, -9.14);
var same = new Coordinate(38.72, -9.14);
Console.WriteLine(home == same);            // True
Console.WriteLine(home);                    // Coordinate { Lat = 38.72, Lng = -9.14 }
var north = home with { Lat = 38.80 };

record struct biasa punya property posisional yang bisa diubah; readonly record struct membuatnya init-only, dan biasanya itulah yang kamu inginkan. Halaman record membahas versi class-nya dan menunjukkan member yang ditulis oleh compiler.

Kesalahan umum

• Mengubah struct lewat salinan. list[0].X = 1 (CS1612), variabel foreach (CS1654), hasil dari getter sebuah property. Tulis kembali salinan yang sudah diubah, atau buat struct-nya immutable.
• Struct yang besar. Setiap assignment dan pemanggilan menyalin seluruh isinya. Jika sudah lebih dari beberapa field, class biasanya lebih cepat.
• Lupa nilai default yang berisi nol. Array dan default(T) membuat nilai struct tanpa menjalankan constructor-mu, jadi field yang kamu validasi di sana tetap bisa bernilai nol atau null.
• Membandingkan dengan == tanpa mendefinisikannya. CS0019. Implementasikan IEquatable<T> dan operator-operatornya, atau pakai record struct.
• Struct yang bisa diubah di balik interface. Boxing berarti perubahan terjadi pada salinan yang tidak sedang kamu lihat.