أنواع البيانات في C#: int وdouble وdecimal وchar وbool ونطاقاتها

C# ثابتة الأنواع: لكل متغيّر وحقل وتعبير نوع معروف وقت الترجمة. في اللغة مجموعة من الأنواع المدمجة لها كلماتها المحجوزة الخاصة (int وdouble وstring...). كل كلمة محجوزة اسم مستعار لنوع في فضاء الأسماء System، فـ int وSystem.Int32 النوع نفسه، وstring وSystem.String النوع نفسه.

الأنواع المدمجة

القيمة الحرفية الصحيحة بلا لاحقة من نوع int، أو أول نوع من uint وlong وulong يتّسع لها إن كانت أكبر من int، والقيمة الحرفية ذات الفاصلة العشرية من نوع double. لهذا تفشل ترجمة float f = 2.5; وdecimal d = 2.5;: القيمة الحرفية double، ولا يوجد تحويل ضمني من double إلى float أو decimal. أضف اللاحقة: 2.5f و2.5m.

يكشف كل نوع رقمي حدوده كثوابت:

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

المخرجات:

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

عمليًا تستخدم معظم الشيفرات أربعة منها: int للعدّ والفهارس، وlong للمعرّفات والمجاميع الكبيرة، وdouble للقياسات والرياضيات، وdecimal للمال.

decimal مقابل double

يخزّن double (وfloat) الأرقام بالنظام الثنائي. معظم الكسور العشرية، ومنها 0.1، ليس لها شكل ثنائي دقيق، فتُخزَّن كأقرب قيمة قابلة للتمثيل وتتراكم أخطاء صغيرة. أما decimal فيخزّن عددًا صحيحًا بالنظام العشري مع مقياس، فتكون 0.1 هي 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}");
    }
}

المخرجات:

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

استخدم decimal للمال والأسعار والضرائب وكل ما سيجمعه شخص يدويًا ويقارنه. يحتفظ بالأصفار اللاحقة من مدخلاته (1.50m تُطبع 1.50) وله 28 إلى 29 رقمًا معنويًا.

واستخدم double للقياسات الفيزيائية والإحصاء والهندسة والألعاب. هو أسرع بعدة مرات، ويستخدم نصف الذاكرة، ونطاقه هائل. لا تقارن قيمتين محسوبتين من نوع double بـ == أبدًا؛ قارن الفرق بهامش سماح: Math.Abs(x - y) < 1e-9.

decimal ليس سحرًا: 1m / 3m ما زالت 0.3333333333333333333333333333، وحساب double لا يرمي استثناءً عند القسمة على صفر (ينتج ما لا نهاية، أو NaN لـ 0.0 / 0.0)، بينما ترمي قسمة decimal والأعداد الصحيحة على صفر استثناء DivideByZeroException.

تجاوز سعة الأعداد الصحيحة وchecked

الحساب الصحيح الذي يتجاوز نطاق النوع يلتفّ افتراضيًا، بصمت. يلتقط المترجم التجاوز في التعابير الثابتة، لكن لا حين تأتي القيم من متغيّرات:

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

المخرجات:

-2147483648
OverflowException
-1294967296
2147483648

تحوّل checked(...) أو كتلة checked { ... } التجاوز إلى استثناء OverflowException. ويمكنك أيضًا تفعيله للمشروع كله بـ <CheckForOverflowUnderflow>true</CheckForOverflowUnderflow>. كتابة int x = int.MaxValue + 1; بالثوابت خطأ ترجمة (CS0220)، لأن المترجم يرى التجاوز.

يُظهر السطر الأخير الحل لمعظم أخطاء التجاوز: حوّل إلى نوع أوسع قبل العملية الحسابية. أما (long)(max + 1) فخطأ، لأن الجمع يكون قد التفّ حين يُنفَّذ التحويل.

أنواع القيم والأنواع المرجعية

كل نوع في C# إما نوع قيمة أو نوع مرجعي، والفرق يحدد ما يفعله الإسناد.

• أنواع القيم: كل الأنواع الرقمية، وbool وchar وDateTime والتعدادات وكل struct. يحتوي المتغيّر على البيانات؛ والإسناد ينسخها.
• الأنواع المرجعية: string والمصفوفات وobject وكل class. يحتوي المتغيّر على مرجع إلى كائن؛ والإسناد ينسخ المرجع، فيرى المتغيّران الكائن نفسه.

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

المخرجات:

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

string نوع مرجعي يتصرف عمليًا كقيمة: غير قابل للتغيير، و== تقارن النص لا المراجع. المزيد عن أنواع القيم المعرّفة من المستخدم في البنى.

char وbool

char وحدة ترميز UTF-16 واحدة، تُكتب بين علامتي اقتباس مفردتين. هو نوع رقمي في الأساس، فيتحوّل إلى int ويدعم العمليات الحسابية:

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

المخرجات:

66
C
True
True
7
b
True

لـ bool قيمتان بالضبط ولا يتحوّل من الأرقام أو إليها: if (count) خطأ ترجمة، لا اختبار لعدم الصفر. اكتب if (count != 0). المحارف خارج المستوى متعدد اللغات الأساسي، مثل معظم الرموز التعبيرية، تأخذ قيمتي char (زوجًا بديلًا)، لذا تعدّ Length في string وحدات UTF-16 لا المحارف المرئية.

القيم الافتراضية

تحصل الحقول وعناصر المصفوفات وdefault(T) على القيمة الافتراضية للنوع: الصفر للأرقام، وfalse لـ bool، و'\0' لـ char، وnull للأنواع المرجعية. أما المتغيّرات المحلية فلا تحصل على قيمة افتراضية ويجب الإسناد إليها قبل الاستخدام.

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

المخرجات:

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

منذ C# 7.1 يمكنك كتابة القيمة الحرفية default دون النوع حين يستطيع المترجم استنتاجه (int x = default;). لا يمكن لنوع القيمة أن يكون null، ولهذا وُجد int? (نوع قيمة قابل لـ null)؛ راجع الأنواع القابلة لـ null.

الأعداد الصحيحة بحجم المنصة والأعداد الكبيرة

يوجد نوعان رقميان آخران لحالات خاصة. nint وnuint (C# 9) عددان صحيحان بحجم المؤشر، 32 أو 64 بت بحسب المنصة، يُستخدمان في التشغيل البيني والشيفرة منخفضة المستوى. ويحمل System.Numerics.BigInteger أعدادًا صحيحة بأي حجم، على حساب السرعة:

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