Chuyển string sang int, ép kiểu trong C#: Parse, TryParse, Convert

C# không bao giờ tự chuyển đổi giữa các kiểu không liên quan. Một chuỗi chứa chữ số vẫn là chuỗi, và một double không lặng lẽ biến thành int. Bạn phải chuyển đổi tường minh, và công cụ cần dùng tùy vào thứ bạn đang chuyển: văn bản sang số (parse), kiểu số này sang kiểu số khác (ép kiểu, casting), hay một đối tượng sang một kiểu cụ thể hơn (as, is).

Chuyển string sang int: Parse, TryParse và Convert

Có ba cách chuẩn để biến văn bản thành một 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"));
    }
}

Đầu ra:

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

int.TryParse trả về một bool và ghi kết quả vào một biến out, biến này được đặt về 0 khi thất bại. Vì đầu vào sai là chuyện bình thường với bất cứ thứ gì người dùng gõ, TryParse là lựa chọn mặc định cho đầu vào, tệp và query string. Mọi kiểu số đều có các phương thức tương tự: long.TryParse, double.TryParse, decimal.Parse, và cứ thế.

Mỗi cách xử lý đầu vào sai ra sao

Ba phương thức chỉ khác nhau ở cách chúng thất bại:

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

Đầu ra:

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 mang thông báo quen thuộc "Input string was not in a correct format" (trên .NET 8 trở lên là "The input string '12.5' was not in a correct format", có trích lại văn bản), và đây là một trong những lỗi lúc chạy phổ biến nhất của C#: "12.5" không phải là int, "1,000" cũng vậy. Để chấp nhận những chuỗi đó, hãy parse thành decimal, hoặc cho trình parse biết những định dạng nào được phép:

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

Đầu ra:

1000
255
13
10

Culture: vì sao "1.5" có thể thành 15

Mặc định việc parse dùng culture hiện tại, mà các culture lại không thống nhất về dấu phân cách. Trong tiếng Đức và một số culture châu Âu khác, dấu thập phân là dấu phẩy còn dấu chấm dùng để nhóm hàng nghìn (tiếng Việt cũng vậy). Cùng một chuỗi cho ra những con số khác nhau:

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

Đầu ra:

1.5
15
1.5

Code đọc tệp dữ liệu, JSON, cấu hình hay bất cứ thứ gì do máy tạo ra nên luôn truyền CultureInfo.InvariantCulture, cả khi parse lẫn khi định dạng. Nếu không, cùng một chương trình chạy đúng trên máy lập trình viên nhưng lại đọc sai mọi con số trên một máy chủ đặt ngôn ngữ khác. Chỉ dùng culture hiện tại cho văn bản do người gõ vào hoặc người sẽ đọc.

Chuyển đổi số ngầm định và tường minh

Các phép chuyển đổi mở rộng diễn ra ngầm định: int sang long, int sang double, float sang double, int sang decimal. Một phép chuyển đổi có thể làm mất độ lớn của giá trị hoặc phần thập phân thì cần ép kiểu tường minh (type)value. Có một ngoại lệ cần nhớ: int hoặc long sang float, và long sang double, là ngầm định dù có thể mất độ chính xác: float f = 16_777_217; vẫn biên dịch được và lưu giá trị 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}");
    }
}

Đầu ra:

9 -9
10
2
4
705032704
9.99
7 7.0 7

Có ba điều cần nhớ. Ép từ số thực sang số nguyên sẽ cắt bỏ phần thập phân; nó không làm tròn. Convert.ToInt32(double) thì làm tròn, theo kiểu làm tròn ngân hàng (số .5 làm tròn về số chẵn gần nhất). Và một phép ép kiểu số nguyên không vừa sẽ lặng lẽ quay vòng giá trị, trừ khi nó chạy trong ngữ cảnh checked, nơi nó ném OverflowException (xem kiểu dữ liệu).

int x = 3.7; là lỗi biên dịch (CS0266: cannot implicitly convert type 'double' to 'int', an explicit conversion exists), tức là trình biên dịch đang yêu cầu bạn chọn giữa ép kiểu và một phương thức làm tròn.

Chuyển số và các kiểu khác sang string

Mọi kiểu đều có ToString(), và các kiểu số nhận thêm một chuỗi định dạng. String interpolation gọi đến cùng cơ chế định dạng đó:

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

Đầu ra:

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

Các mã định dạng (D, F, N, C, X, P, E) và các mẫu tự định nghĩa như "0.00" được giải thích ở trang string interpolation.

Ký tự và 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));
    }
}

Đầu ra:

7
55
7
7
A
True
False
1
False

(int)'7' là 55, tức mã của ký tự, không phải 7. Điều này hay làm vấp những ai cộng các chữ số của một số; hãy trừ đi '0' hoặc dùng char.GetNumericValue. bool.Parse nhận "true" và "false" ở bất kỳ kiểu chữ hoa thường nào, và không nhận gì khác ("yes" và "1" đều ném ngoại lệ).

Chuyển đổi kiểu tham chiếu: ép kiểu, as và is

Với kiểu lớp, phép ép kiểu kiểm tra kiểu thực của đối tượng lúc chạy. Ép lên lớp cha (upcast) là ngầm định. Ép xuống lớp con (downcast) cần ép kiểu tường minh, và sẽ ném InvalidCastException khi đối tượng thuộc kiểu khác:

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

Đầu ra:

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

Hãy ưu tiên is kèm một biến khi bạn cần rẽ nhánh theo kiểu; đó là một lần kiểm tra, không thể ném ngoại lệ, và biến mới chỉ nằm trong phạm vi nơi phép kiểm tra thành công. Dùng ép kiểu thông thường khi một kiểu khác là bug và cần báo lỗi thật rõ. Trường hợp int bị boxing hay làm vấp những ai đọc số từ collection kiểu object hoặc ô của DataRow: hãy unbox về đúng kiểu trước ((long)(int)boxed), hoặc dùng Convert.ToInt64(boxed), hàm này xử lý được mọi kiểu số.