String ke Int di C#, Casting, dan Konversi Tipe: Parse, TryParse, Convert

C# tidak pernah mengonversi antartipe yang tidak berhubungan dengan sendirinya. String yang berisi angka tetaplah string, dan double tidak diam-diam berubah menjadi int. Kamu melakukan konversi secara eksplisit, dan alat yang dipakai tergantung pada apa yang dikonversi: teks ke angka (parsing), satu tipe numerik ke tipe numerik lain (casting), atau objek ke tipe yang lebih spesifik (as, is).

String ke int: Parse, TryParse, dan Convert

Ada tiga cara standar untuk mengubah teks menjadi int:

using System;

class Program
{
    static void Main()
    {
        string text = "1250";

        int a = int.Parse(text);
        int b = Convert.ToInt32(text);
        Console.WriteLine(a + b);

        if (int.TryParse(text, out int c))
        {
            Console.WriteLine($"TryParse ok: {c}");
        }

        if (!int.TryParse("12 apples", out int d))
        {
            Console.WriteLine($"TryParse failed, d = {d}");
        }

        Console.WriteLine(int.Parse("  42 "));   // surrounding spaces are allowed
        Console.WriteLine(int.Parse("-17"));
    }
}

Output:

2500
TryParse ok: 1250
TryParse failed, d = 0
42
-17

int.TryParse mengembalikan bool dan menulis hasilnya ke variabel out, yang diisi 0 kalau gagal. Karena input yang salah itu normal untuk apa pun yang diketik pengguna, TryParse adalah pilihan default untuk input, file dan query string. Method yang sama tersedia di setiap tipe numerik: long.TryParse, double.TryParse, decimal.Parse, dan seterusnya.

Apa yang dilakukan masing-masing pada input yang salah

Ketiga method itu hanya berbeda dalam cara gagalnya:

using System;

class Program
{
    static void Try(string label, Func<int> parse)
    {
        try
        {
            Console.WriteLine($"{label} = {parse()}");
        }
        catch (Exception e)
        {
            Console.WriteLine($"{label} throws {e.GetType().Name}");
        }
    }

    static void Main()
    {
        string empty = null;
        Try("int.Parse(null)", () => int.Parse(empty));
        Try("Convert.ToInt32(null)", () => Convert.ToInt32(empty));
        Try("int.Parse(\"abc\")", () => int.Parse("abc"));
        Try("int.Parse(\"12.5\")", () => int.Parse("12.5"));
        Try("int.Parse(\"1,000\")", () => int.Parse("1,000"));
        Try("int.Parse(\"9999999999\")", () => int.Parse("9999999999"));
        Try("int.Parse(\"\")", () => int.Parse(""));
    }
}

Output:

int.Parse(null) throws ArgumentNullException
Convert.ToInt32(null) = 0
int.Parse("abc") throws FormatException
int.Parse("12.5") throws FormatException
int.Parse("1,000") throws FormatException
int.Parse("9999999999") throws OverflowException
int.Parse("") throws FormatException

FormatException membawa pesan yang sudah akrab, "Input string was not in a correct format" (di .NET 8 dan sesudahnya, "The input string '12.5' was not in a correct format", dengan teks yang dikutip), dan ini adalah salah satu error runtime C# yang paling umum: "12.5" bukan int, begitu juga "1,000". Untuk menerimanya, parse sebagai decimal, atau beri tahu parser gaya apa saja yang diizinkan:

using System;
using System.Globalization;

class Program
{
    static void Main()
    {
        var inv = CultureInfo.InvariantCulture;

        int withCommas = int.Parse("1,000", NumberStyles.AllowThousands, inv);
        int fromHex = int.Parse("FF", NumberStyles.HexNumber);
        decimal price = decimal.Parse("12.5", inv);
        int rounded = (int)Math.Round(price, MidpointRounding.AwayFromZero);

        Console.WriteLine(withCommas);
        Console.WriteLine(fromHex);
        Console.WriteLine(rounded);
        Console.WriteLine(Convert.ToInt32("1010", 2));  // from binary
    }
}

Output:

1000
255
13
10

Culture: kenapa "1.5" bisa menjadi 15

Secara default, parsing memakai culture saat ini, dan setiap culture punya aturan pemisah yang berbeda. Di culture Jerman dan beberapa culture Eropa lain, pemisah desimalnya adalah koma dan titik dipakai untuk mengelompokkan ribuan. String yang sama menghasilkan angka yang berbeda:

using System;
using System.Globalization;

class Program
{
    static void Main()
    {
        var german = new CultureInfo("de-DE");
        var inv = CultureInfo.InvariantCulture;

        decimal a = decimal.Parse("1.5", inv);
        decimal b = decimal.Parse("1.5", german);   // "." is a group separator here
        decimal c = decimal.Parse("1,5", german);

        Console.WriteLine(a.ToString(inv));
        Console.WriteLine(b.ToString(inv));
        Console.WriteLine(c.ToString(inv));
    }
}

Output:

1.5
15
1.5

Kode yang membaca file data, JSON, konfigurasi atau apa pun yang dibuat mesin sebaiknya selalu mengirim CultureInfo.InvariantCulture, baik saat parsing maupun saat memformat. Kalau tidak, program yang sama berjalan baik di komputer developer tetapi salah membaca setiap angka di server yang diatur ke bahasa lain. Pakai culture saat ini hanya untuk teks yang diketik atau akan dibaca manusia.

Konversi numerik implisit dan eksplisit

Konversi pelebaran terjadi secara implisit: int ke long, int ke double, float ke double, int ke decimal. Konversi yang bisa menghilangkan besaran nilai atau bagian pecahannya butuh cast eksplisit (type)value. Satu pengecualian yang perlu diingat: int atau long ke float, dan long ke double, bersifat implisit walaupun bisa kehilangan presisi: float f = 16_777_217; bisa dikompilasi dan menyimpan 16777216.

using System;

class Program
{
    static void Main()
    {
        int items = 7;
        long bigItems = items;       // implicit: always fits
        double ratio = items;        // implicit
        decimal money = items;       // implicit

        double price = 9.99;
        int whole = (int)price;      // explicit: truncates toward zero
        int negative = (int)-9.99;
        Console.WriteLine($"{whole} {negative}");

        Console.WriteLine(Convert.ToInt32(9.99));   // rounds
        Console.WriteLine(Convert.ToInt32(2.5));    // halves go to even: 2
        Console.WriteLine(Convert.ToInt32(3.5));    // 4

        long large = 5_000_000_000;
        int wrapped = (int)large;    // keeps the low 32 bits
        Console.WriteLine(wrapped);

        decimal amount = (decimal)price;  // double to decimal: explicit
        Console.WriteLine(amount);
        Console.WriteLine($"{bigItems} {ratio:F1} {money}");
    }
}

Output:

9 -9
10
2
4
705032704
9.99
7 7.0 7

Ada tiga hal yang perlu diingat. Cast dari floating point ke integer memotong; cast tidak membulatkan. Convert.ToInt32(double) membulatkan, dengan banker's rounding (nilai tengah ke tetangga yang genap). Dan cast integer yang tidak muat akan berputar balik tanpa peringatan, kecuali dijalankan di konteks checked, yang melempar OverflowException (lihat tipe data).

int x = 3.7; adalah error kompilasi (CS0266: cannot implicitly convert type 'double' to 'int', an explicit conversion exists), yaitu compiler yang memintamu memilih antara cast dan method pembulatan.

Angka dan tipe lain ke string

Setiap tipe punya ToString(), dan tipe numerik menerima format string. Interpolasi string memanggil pemformatan yang sama:

using System;
using System.Globalization;

class Program
{
    static void Main()
    {
        int orderId = 42;
        decimal total = 1234.5m;
        var us = new CultureInfo("en-US");

        Console.WriteLine(orderId.ToString());
        Console.WriteLine(orderId.ToString("D6"));        // 000042
        Console.WriteLine(total.ToString("F2"));          // 1234.50
        Console.WriteLine(total.ToString("N2", us));      // 1,234.50
        Console.WriteLine(total.ToString("C", us));       // $1,234.50
        Console.WriteLine(255.ToString("X"));             // FF
        Console.WriteLine(Convert.ToString(10, 2));       // 1010
        Console.WriteLine(true.ToString());
        Console.WriteLine($"Order {orderId:D6}: {total:F2}");
    }
}

Output:

42
000042
1234.50
1,234.50
$1,234.50
FF
1010
True
Order 000042: 1234.50

Kode format (D, F, N, C, X, P, E) dan pola kustom seperti "0.00" dibahas di interpolasi string.

Karakter dan boolean

using System;

class Program
{
    static void Main()
    {
        char digit = '7';
        Console.WriteLine(digit);            // the character
        Console.WriteLine((int)digit);       // its code: 55
        Console.WriteLine(digit - '0');      // its value: 7
        Console.WriteLine(char.GetNumericValue(digit));
        Console.WriteLine((char)65);         // A

        Console.WriteLine(bool.Parse("True"));
        Console.WriteLine(bool.Parse("false"));
        Console.WriteLine(Convert.ToInt32(true));
        Console.WriteLine(Convert.ToBoolean(0));
    }
}

Output:

7
55
7
7
A
True
False
1
False

(int)'7' bernilai 55, yaitu kode karakternya, bukan 7. Ini sering menjebak siapa pun yang menjumlahkan digit sebuah angka; kurangkan dengan '0' atau pakai char.GetNumericValue. bool.Parse menerima "true" dan "false" dengan huruf besar atau kecil, dan tidak menerima yang lain ("yes" dan "1" melempar exception).

Konversi reference: cast, as, dan is

Untuk tipe class, cast memeriksa tipe asli objek saat program berjalan. Upcast ke base class bersifat implisit. Downcast ke class turunan butuh cast eksplisit, yang melempar InvalidCastException saat objeknya ternyata tipe lain:

using System;

class Payment { public decimal Amount = 50m; }
class CardPayment : Payment { public string Last4 = "4242"; }
class CashPayment : Payment { }

class Program
{
    static void Main()
    {
        Payment p = new CardPayment();       // upcast: implicit

        CardPayment card = (CardPayment)p;   // downcast: works, it is a card
        Console.WriteLine(card.Last4);

        Payment cash = new CashPayment();
        CardPayment maybe = cash as CardPayment;  // as: null instead of an exception
        Console.WriteLine(maybe == null);

        if (p is CardPayment c)              // is pattern (C# 7): test and convert
        {
            Console.WriteLine($"Card ending {c.Last4}, {c.Amount:F2}");
        }

        try
        {
            var wrong = (CardPayment)cash;
        }
        catch (InvalidCastException)
        {
            Console.WriteLine("InvalidCastException");
        }

        object boxed = 5;                    // an int boxed as object
        int unboxed = (int)boxed;            // fine
        Console.WriteLine(unboxed);
        try
        {
            long wrongUnbox = (long)boxed;   // must unbox to the exact type
        }
        catch (InvalidCastException)
        {
            Console.WriteLine("cannot unbox int as long");
        }
    }
}

Output:

4242
True
Card ending 4242, 50.00
InvalidCastException
5
cannot unbox int as long

Utamakan is dengan variabel saat kamu perlu bercabang berdasarkan tipe; itu hanya satu pemeriksaan, tidak bisa melempar exception, dan variabel barunya hanya berlaku di bagian tempat pengujian berhasil. Pakai cast biasa saat tipe yang berbeda berarti bug yang harus gagal dengan jelas. Kasus int yang di-box sering menjebak orang yang membaca angka dari collection object atau sel DataRow: lakukan unbox ke tipe yang persis sama dulu ((long)(int)boxed), atau pakai Convert.ToInt64(boxed), yang bisa menangani tipe numerik apa pun.