Kiểu dữ liệu C#: int, double, decimal, char, bool và phạm vi

C# là ngôn ngữ kiểu tĩnh: mọi biến, field và biểu thức đều có kiểu được biết lúc biên dịch. Ngôn ngữ có một tập kiểu có sẵn (built-in type) với từ khóa riêng (int, double, string...). Mỗi từ khóa là bí danh của một kiểu trong namespace System, nên int và System.Int32 là cùng một kiểu, string và System.String cũng là cùng một kiểu.

Các kiểu có sẵn

Literal số nguyên không có hậu tố là int, hoặc nếu quá lớn so với int thì là kiểu đầu tiên trong uint, long và ulong chứa được nó, còn literal có dấu chấm thập phân là double. Đó là lý do float f = 2.5; và decimal d = 2.5; không biên dịch được: literal là double, và không có phép chuyển đổi ngầm từ double sang float hay decimal. Hãy thêm hậu tố: 2.5f, 2.5m.

Mọi kiểu số đều cung cấp giới hạn của mình dưới dạng hằng số:

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine($"byte:  {byte.MinValue} to {byte.MaxValue}");
        Console.WriteLine($"short: {short.MinValue} to {short.MaxValue}");
        Console.WriteLine($"int:   {int.MinValue} to {int.MaxValue}");
        Console.WriteLine($"long:  {long.MinValue} to {long.MaxValue}");
        Console.WriteLine($"decimal max: {decimal.MaxValue}");
        Console.WriteLine($"double max:  {double.MaxValue:E3}");
        Console.WriteLine($"sizes: int {sizeof(int)}, long {sizeof(long)}, double {sizeof(double)}, char {sizeof(char)}");

        int hex = 0xFF;             // hexadecimal
        int bits = 0b1010_0001;     // binary (C# 7)
        long big = 3_000_000_000;   // digit separators (C# 7)
        Console.WriteLine($"{hex} {bits} {big}");
    }
}

Đầu ra:

byte:  0 to 255
short: -32768 to 32767
int:   -2147483648 to 2147483647
long:  -9223372036854775808 to 9223372036854775807
decimal max: 79228162514264337593543950335
double max:  1.798E+308
sizes: int 4, long 8, double 8, char 2
255 161 3000000000

Trong thực tế, phần lớn code dùng bốn kiểu: int cho số đếm và chỉ số, long cho ID và tổng lớn, double cho số đo và toán học, và decimal cho tiền.

decimal và double

double (và float) lưu số ở dạng nhị phân. Hầu hết phân số thập phân, kể cả 0,1, không có dạng nhị phân chính xác, nên chúng được lưu bằng giá trị biểu diễn được gần nhất và sai số nhỏ cộng dồn lại. decimal lưu một số nguyên hệ 10 kèm hệ số tỷ lệ, nên 0,1 đúng là 0,1.

using System;

class Program
{
    static void Main()
    {
        double a = 0.1 + 0.2;
        decimal b = 0.1m + 0.2m;
        Console.WriteLine(a == 0.3);          // False
        Console.WriteLine(b == 0.3m);         // True
        Console.WriteLine(a.ToString("G17")); // 17 significant digits
        Console.WriteLine(b);

        double dsum = 0;
        decimal msum = 0;
        for (int i = 0; i < 10; i++)
        {
            dsum += 0.1;
            msum += 0.1m;
        }
        Console.WriteLine($"double sum == 1.0: {dsum == 1.0}");
        Console.WriteLine($"decimal sum == 1.0: {msum == 1.0m}");

        decimal price = 19.99m;
        int quantity = 3;
        decimal total = price * quantity;
        Console.WriteLine($"Total: {total}");
        Console.WriteLine($"Split three ways: {total / 3}");
    }
}

Đầu ra:

False
True
0.30000000000000004
0.3
double sum == 1.0: False
decimal sum == 1.0: True
Total: 59.97
Split three ways: 19.99

Dùng decimal cho tiền, giá, thuế và bất cứ thứ gì mà một người sẽ cộng tay và so sánh. Nó giữ các số 0 ở cuối từ đầu vào (1.50m in ra 1.50) và có từ 28 đến 29 chữ số có nghĩa.

Dùng double cho số đo vật lý, thống kê, hình học và game. Nó nhanh hơn vài lần, dùng một nửa bộ nhớ, và phạm vi cực lớn. Đừng bao giờ so sánh hai giá trị double đã tính toán bằng ==; hãy so hiệu của chúng với một sai số cho phép: Math.Abs(x - y) < 1e-9.

decimal không phải phép màu: 1m / 3m vẫn là 0.3333333333333333333333333333, và phép tính double không ném lỗi khi chia cho 0 (nó cho ra vô cực, hoặc NaN với 0.0 / 0.0), trong khi phép chia cho 0 với decimal và số nguyên ném ra DivideByZeroException.

Tràn số nguyên và checked

Phép tính số nguyên vượt quá phạm vi của kiểu sẽ quay vòng theo mặc định, một cách âm thầm. Trình biên dịch bắt được tràn số trong biểu thức hằng, nhưng không bắt được khi giá trị đến từ biến:

using System;

class Program
{
    static void Main()
    {
        int max = int.MaxValue;
        int wrapped = max + 1;           // no error: wraps around
        Console.WriteLine(wrapped);

        try
        {
            int safe = checked(max + 1); // throws instead of wrapping
            Console.WriteLine(safe);
        }
        catch (OverflowException)
        {
            Console.WriteLine("OverflowException");
        }

        long views = 3_000_000_000;
        int truncated = unchecked((int)views); // explicit narrowing keeps low 32 bits
        Console.WriteLine(truncated);

        long total = (long)max + 1;       // widen first to get the right answer
        Console.WriteLine(total);
    }
}

Đầu ra:

-2147483648
OverflowException
-1294967296
2147483648

checked(...) hoặc khối checked { ... } biến tràn số thành OverflowException. Bạn cũng có thể bật cho cả dự án bằng <CheckForOverflowUnderflow>true</CheckForOverflowUnderflow>. Viết int x = int.MaxValue + 1; với hằng số là lỗi biên dịch (CS0220), vì trình biên dịch nhìn thấy được tràn số.

Dòng cuối cho thấy cách sửa phần lớn lỗi tràn số: chuyển sang kiểu rộng hơn trước phép tính. (long)(max + 1) sẽ sai, vì phép cộng đã quay vòng trước khi phép ép kiểu chạy.

Kiểu giá trị và kiểu tham chiếu

Mọi kiểu trong C# hoặc là kiểu giá trị (value type), hoặc là kiểu tham chiếu (reference type), và khác biệt này quyết định phép gán làm gì.

• Kiểu giá trị: mọi kiểu số, bool, char, DateTime, enum và mọi struct. Biến chứa dữ liệu; phép gán sao chép dữ liệu.
• Kiểu tham chiếu: string, mảng, object và mọi class. Biến chứa tham chiếu đến một đối tượng; phép gán sao chép tham chiếu, nên cả hai biến cùng thấy một đối tượng.

using System;

class Program
{
    static void Main()
    {
        int a = 10;
        int b = a;      // copy of the value
        b = 99;
        Console.WriteLine($"a={a} b={b}");

        int[] first = { 1, 2, 3 };
        int[] second = first;   // copy of the reference
        second[0] = 99;
        Console.WriteLine($"first[0]={first[0]}");

        string s1 = "cat";
        string s2 = s1;
        s2 += "s";              // strings are immutable: s2 now refers to a new string
        Console.WriteLine($"s1={s1} s2={s2}");
    }
}

Đầu ra:

a=10 b=99
first[0]=99
s1=cat s2=cats

string là kiểu tham chiếu nhưng trong thực tế hoạt động như giá trị: nó bất biến, và == so sánh văn bản chứ không so sánh tham chiếu. Xem thêm về kiểu giá trị do người dùng định nghĩa ở trang struct.

char và bool

Một char là một đơn vị mã UTF-16, viết trong dấu nháy đơn. Bên dưới nó là một kiểu số, nên nó chuyển được sang int và hỗ trợ phép tính:

using System;

class Program
{
    static void Main()
    {
        char grade = 'B';
        Console.WriteLine((int)grade);           // 66
        Console.WriteLine((char)(grade + 1));    // C
        Console.WriteLine(char.IsLetter(grade));
        Console.WriteLine(char.IsDigit('7'));
        Console.WriteLine('7' - '0');             // digit char to its value
        Console.WriteLine(char.ToLower(grade));

        bool isOpen = true;
        bool hasStock = false;
        Console.WriteLine(isOpen && !hasStock);
    }
}

Đầu ra:

66
C
True
True
7
b
True

bool có đúng hai giá trị và không chuyển đổi qua lại với số: if (count) là lỗi biên dịch, không phải phép kiểm tra khác 0. Hãy viết if (count != 0). Ký tự nằm ngoài Basic Multilingual Plane, như phần lớn emoji, chiếm hai giá trị char (một cặp surrogate), nên Length của một string đếm đơn vị UTF-16, không phải ký tự nhìn thấy được.

Giá trị mặc định

Field, phần tử mảng và default(T) nhận giá trị mặc định của kiểu: 0 với số, false với bool, '\0' với char, và null với kiểu tham chiếu. Biến cục bộ không có giá trị mặc định và phải được gán trước khi dùng.

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine(default(int));
        Console.WriteLine(default(decimal));
        Console.WriteLine(default(bool));
        Console.WriteLine(default(string) == null);
        Console.WriteLine(default(DateTime).ToString("yyyy-MM-dd"));

        var counts = new int[3];
        Console.WriteLine(string.Join(",", counts));
    }
}

Đầu ra:

0
0
False
True
0001-01-01
0,0,0

Từ C# 7.1, bạn có thể viết literal default mà không cần kiểu khi trình biên dịch suy ra được (int x = default;). Kiểu giá trị không thể là null, và đó là việc của int? (kiểu giá trị nullable); xem kiểu nullable.

Số nguyên theo kích thước nền tảng và số nguyên lớn

Còn hai kiểu số nữa cho các trường hợp đặc biệt. nint và nuint (C# 9) là số nguyên có kích thước bằng con trỏ, 32 hoặc 64 bit tùy nền tảng, dùng trong interop và code cấp thấp. System.Numerics.BigInteger chứa số nguyên lớn tùy ý, đổi lại là tốc độ chậm hơn:

using System.Numerics;
BigInteger factorial = 1;
for (int i = 2; i <= 30; i++) factorial *= i;
// 265252859812191058636308480000000