Pernyataan using di C#: IDisposable, Dispose, dan using var

Beberapa objek memegang resource yang tidak dikelola oleh garbage collector: file yang terbuka, socket jaringan, koneksi database, handle sistem operasi. Objek seperti itu mengimplementasikan IDisposable, dan kamu melepas resource-nya dengan memanggil Dispose(). Pernyataan using memanggilnya untukmu di titik yang pasti, bahkan kalau exception dilempar.

Halaman ini membahas pernyataan using. Baris using System; di bagian atas file adalah fitur yang berbeda, yaitu using directive, yang mengimpor sebuah namespace.

Blok using

using (declaration) { body } membuat objek, menjalankan isi blok, lalu memanggil Dispose. Class kecil yang mencetak sesuatu dari Dispose menunjukkan dengan tepat kapan itu terjadi:

using System;

class Connection : IDisposable
{
    private readonly string name;

    public Connection(string name)
    {
        this.name = name;
        Console.WriteLine("open " + name);
    }

    public void Send(string msg)
    {
        Console.WriteLine(name + " sends " + msg);
    }

    public void Dispose()
    {
        Console.WriteLine("close " + name);
    }
}

class Program
{
    static void Main()
    {
        using (var db = new Connection("db"))
        {
            db.Send("SELECT 1");
        } // db.Dispose() runs here

        try
        {
            using (var api = new Connection("api"))
            {
                api.Send("GET /orders");
                throw new InvalidOperationException();
            } // api.Dispose() still runs, before the catch
        }
        catch (InvalidOperationException)
        {
            Console.WriteLine("error handled");
        }
    }
}

Output:

open db
db sends SELECT 1
close db
open api
api sends GET /orders
close api
error handled

Blok kedua melempar exception, dan "close api" tetap tercetak, sebelum catch menangani exception-nya. Jaminan inilah alasan memakai using alih-alih memanggil Dispose() sendiri di baris terakhir: pemanggilan manual akan terlewati oleh exception apa pun yang dilempar sebelumnya.

Hasil kompilasi using

Compiler mengembangkan blok using menjadi try/finally. Dua kode ini setara:

using (var writer = new StreamWriter("log.txt"))
{
    writer.WriteLine("started");
}

// is compiled as:
{
    var writer = new StreamWriter("log.txt");
    try
    {
        writer.WriteLine("started");
    }
    finally
    {
        if (writer != null) ((IDisposable)writer).Dispose();
    }
}

Ada tiga detail yang mengikuti dari hasil pengembangan itu. Variabelnya hanya berlaku di dalam blok dan bersifat read-only di sana (kamu tidak bisa mengisi ulang writer). Objeknya harus mengimplementasikan IDisposable, kalau tidak kodenya tidak bisa dikompilasi. Dan nilai null diizinkan: Dispose cukup dilewati, yang berguna saat sebuah factory mungkin tidak mengembalikan apa pun.

File dan stream

Class file dan stream adalah kasus sehari-hari. StreamWriter menampung teks di buffer memori, dan Dispose menulis isi buffer itu ke disk lalu menutup file handle:

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string path = Path.Combine(Path.GetTempPath(), "orders.csv");

        using (var writer = new StreamWriter(path))
        {
            writer.WriteLine("id,total");
            writer.WriteLine("1001,59.90");
            writer.WriteLine("1002,12.50");
        } // flushed and closed here

        using (var reader = new StreamReader(path))
        {
            string line;
            while ((line = reader.ReadLine()) != null)
            {
                Console.WriteLine(line);
            }
        }

        File.Delete(path); // allowed: nothing holds the file open
    }
}

Output:

id,total
1001,59.90
1002,12.50

Tanpa Dispose, baris terakhir yang ditulis writer mungkin masih tertahan di buffer-nya, dan di Windows handle yang masih terbuka mencegah program lain (dan File.Delete milikmu sendiri berikutnya) menyentuh file itu. Helper seperti File.WriteAllText dan File.ReadAllLines membuka dan melakukan dispose di dalamnya, jadi tidak butuh using. Lihat file untuk penjelasan lebih lanjut.

Beberapa resource: urutan dispose

Tumpuk pernyataan using tanpa kurung kurawal di antaranya untuk membuka beberapa resource dalam satu blok. Semuanya di-dispose dalam urutan kebalikan dari pembuatannya:

using System;

class Resource : IDisposable
{
    private readonly string name;
    public Resource(string name) { this.name = name; Console.WriteLine("acquire " + name); }
    public void Dispose() { Console.WriteLine("release " + name); }
}

class Program
{
    static void Main()
    {
        using (var file = new Resource("file"))
        using (var buffer = new Resource("buffer"))
        using (var writer = new Resource("writer"))
        {
            Console.WriteLine("working");
        }

        // Several of the same type can share one statement:
        using (Resource a = new Resource("a"), b = new Resource("b"))
        {
            Console.WriteLine("both open");
        }
    }
}

Output:

acquire file
acquire buffer
acquire writer
working
release writer
release buffer
release file
acquire a
acquire b
both open
release b
release a

Urutan terbalik inilah yang dibutuhkan resource berlapis: writer membungkus buffer yang membungkus file, jadi writer harus menulis isinya ke buffer sebelum buffer menulis ke file, sebelum file ditutup.

Using declaration (C# 8)

C# 8 menambahkan bentuk tanpa kurung kurawal. Variabelnya di-dispose saat scope di sekitarnya berakhir, biasanya di akhir method:

static void ExportReport(string path, IEnumerable<string> rows)
{
    using var writer = new StreamWriter(path);
    writer.WriteLine("Report");

    foreach (string row in rows)
    {
        writer.WriteLine(row);
    }
} // writer.Dispose() runs here, at the end of the method

Bentuk ini menghilangkan satu tingkat indentasi, yang terasa manfaatnya saat sebuah method memakai dua atau tiga resource. Aturan urutan dispose-nya sama: deklarasi dalam satu scope di-dispose dalam urutan terbalik. Konsekuensinya, resource tetap terbuka sampai scope berakhir, jadi saat sebuah file perlu ditutup sebelum method melakukan pekerjaan lain, tetap pakai bentuk blok atau letakkan deklarasinya di blok { } tersendiri.

Untuk objek yang pembersihannya asynchronous (IAsyncDisposable, seperti banyak koneksi database dan stream), C# 8 juga punya await using, yang menunggu DisposeAsync() di tempat yang sama.

Mengimplementasikan IDisposable di class milikmu sendiri

Implementasikan IDisposable saat class-mu memiliki sesuatu yang disposable (class itu membuat stream, timer, atau koneksi) sehingga harus ikut melakukan dispose. Untuk kasus yang umum, cukup sebuah method pendek:

using System;
using System.IO;

class AuditLog : IDisposable
{
    private readonly StringWriter output = new StringWriter(); // an owned IDisposable
    private bool disposed;
    private int count;

    public void Write(string entry)
    {
        if (disposed) throw new ObjectDisposedException(nameof(AuditLog));
        output.WriteLine(++count + ". " + entry);
    }

    public string Contents => output.ToString();

    public void Dispose()
    {
        if (disposed) return; // calling Dispose twice must be harmless
        output.Dispose();
        disposed = true;
        Console.WriteLine("AuditLog disposed");
    }
}

class Program
{
    static void Main()
    {
        var log = new AuditLog();
        using (log)
        {
            log.Write("user ana logged in");
            log.Write("order 1001 created");
            Console.Write(log.Contents);
        }

        log.Dispose(); // second call: no effect

        try
        {
            log.Write("too late");
        }
        catch (ObjectDisposedException e)
        {
            Console.WriteLine("Caught " + e.GetType().Name);
        }
    }
}

Output:

1. user ana logged in
2. order 1001 created
AuditLog disposed
Caught ObjectDisposedException

Aturan yang diikuti kode ini: Dispose melakukan dispose pada semua yang dimiliki objek; memanggilnya lebih dari sekali tidak berpengaruh pada pemanggilan kedua; dan memakai objek setelah di-dispose melempar ObjectDisposedException. using (log) juga menunjukkan bahwa blok bisa menerima variabel yang sudah ada, bukan hanya deklarasi.

"Dispose pattern" yang lebih panjang, dengan method protected virtual void Dispose(bool disposing) dan finalizer, hanya dibutuhkan saat sebuah class langsung memegang handle unmanaged (pointer mentah dari kode native). Di .NET modern, bungkus handle seperti itu dalam subclass SafeHandle, dan versi sederhana di atas sudah cukup untuk class-mu.

Kesalahan umum

• Mengembalikan objek yang dibuat di blok using. Objek itu di-dispose saat blok selesai, jadi pemanggil menerima stream yang sudah ditutup. Kembalikan datanya, atau biarkan pemanggil yang memegang using.
• Lupa using pada stream dan writer. Data di buffer bisa hilang dan file tetap terkunci.
• Melakukan dispose pada objek yang dipakai bersama. Dispose hanya yang kamu miliki. HttpClient yang berumur panjang, misalnya, memang dimaksudkan untuk dipakai bersama dan dipakai ulang, bukan dibuat lalu di-dispose di setiap request.
• Memakai objek setelah bloknya selesai. Method pada objek yang sudah di-dispose melempar ObjectDisposedException.
• Mengandalkan garbage collector. Garbage collector membebaskan memori, bukan file atau socket, dan tidak pernah memanggil Dispose.