تحويل string إلى int والتحويل بين الأنواع في C#: Parse وTryParse وConvert

لا تحوّل C# بين أنواع غير مترابطة من تلقاء نفسها أبدًا. النص الذي يحتوي على أرقام يبقى نصًا، وdouble لا يصير int بصمت. أنت تحوّل صراحة، والأداة التي تستخدمها تعتمد على ما تحوّله: نص إلى رقم (القراءة أو parsing)، أو نوع رقمي إلى آخر (casting)، أو كائن إلى نوع أكثر تحديدًا (as وis).

من string إلى int: Parse وTryParse وConvert

هناك ثلاث طرق قياسية لتحويل نص إلى 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"));
    }
}

المخرجات:

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

تعيد int.TryParse قيمة bool وتكتب النتيجة في متغيّر out، الذي يُضبط على 0 عند الفشل. ولأن المدخلات السيئة أمر طبيعي في كل ما يكتبه المستخدم، فإن TryParse هي الخيار الافتراضي للمدخلات والملفات وسلاسل الاستعلام. الدوال نفسها موجودة في كل نوع رقمي: long.TryParse وdouble.TryParse وdecimal.Parse وهكذا.

ماذا تفعل كل منها بالمدخلات السيئة

لا تختلف الدوال الثلاث إلا في طريقة فشلها:

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

المخرجات:

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 الرسالة المألوفة "Input string was not in a correct format" (في .NET 8 وما بعده "The input string '12.5' was not in a correct format" مع اقتباس النص)، وهو من أشيع أخطاء وقت التشغيل في C#: "12.5" ليست int، ولا "1,000" كذلك. لقبولهما اقرأ القيمة كـ decimal، أو أخبر المحلّل بالأنماط المسموحة:

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

المخرجات:

1000
255
13
10

الثقافة: لماذا قد تصبح "1.5" هي 15

تستخدم القراءة الثقافة الحالية افتراضيًا، والثقافات تختلف في الفواصل. في الألمانية وعدة ثقافات أوروبية أخرى الفاصلة العشرية فاصلة، والنقطة تجمع الآلاف. النص نفسه يعطي أرقامًا مختلفة:

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

المخرجات:

1.5
15
1.5

الشيفرة التي تقرأ ملفات بيانات أو JSON أو إعدادات أو أي شيء تولّده الآلة يجب أن تمرّر دائمًا CultureInfo.InvariantCulture، عند القراءة وعند التنسيق. وإلا فإن البرنامج نفسه يعمل على جهاز المطوّر ويسيء قراءة كل رقم على خادم مضبوط على لغة أخرى. استخدم الثقافة الحالية فقط للنص الذي كتبه شخص أو سيقرؤه.

التحويلات الرقمية الضمنية والصريحة

التحويلات الموسِّعة تحدث ضمنيًا: int إلى long، وint إلى double، وfloat إلى double، وint إلى decimal. أما التحويل الذي قد يفقد مقدار القيمة أو جزأها الكسري فيتطلب تحويلًا صريحًا (type)value. استثناء يجب تذكّره: التحويل من int أو long إلى float، ومن long إلى double، ضمني مع أنه قد يفقد الدقة: float f = 16_777_217; تُترجم وتخزّن 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}");
    }
}

المخرجات:

9 -9
10
2
4
705032704
9.99
7 7.0 7

ثلاثة أمور يجب تذكّرها. التحويل من عدد عشري عائم إلى عدد صحيح يقتطع؛ ولا يقرّب. أما Convert.ToInt32(double) فتقرّب، بتقريب المصرفيين (تذهب الأنصاف إلى الجار الزوجي). والتحويل الصحيح الذي لا يتّسع يلتفّ بصمت ما لم يعمل في سياق checked، حيث يرمي OverflowException (راجع أنواع البيانات).

int x = 3.7; خطأ ترجمة (CS0266: cannot implicitly convert type 'double' to 'int', an explicit conversion exists)، وهذا المترجم يطلب منك الاختيار بين التحويل الصريح ودالة تقريب.

الأرقام والأنواع الأخرى إلى string

لكل نوع الدالة ToString()، والأنواع الرقمية تقبل نص تنسيق. ويستدعي استيفاء النصوص التنسيق نفسه:

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

المخرجات:

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

رموز التنسيق (D وF وN وC وX وP وE) والأنماط المخصصة مثل "0.00" مشروحة في استيفاء النصوص.

المحارف والقيم المنطقية

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

المخرجات:

7
55
7
7
A
True
False
1
False

(int)'7' تساوي 55، رمز المحرف لا 7. هذا يوقع كل من يجمع أرقام عدد؛ اطرح '0' أو استخدم char.GetNumericValue. تقبل bool.Parse النصين "true" و"false" بأي حالة أحرف، ولا شيء غيرهما ("yes" و"1" ترميان استثناءً).

التحويلات المرجعية: التحويل الصريح وas وis

في أنواع الأصناف يفحص التحويل النوع الفعلي للكائن وقت التشغيل. التحويل صعودًا إلى صنف أساس ضمني. أما التحويل نزولًا إلى صنف مشتق فيحتاج إلى تحويل صريح، يرمي InvalidCastException حين يكون الكائن شيئًا آخر:

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

المخرجات:

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

فضّل is مع متغيّر حين تحتاج إلى التفرّع بحسب النوع؛ فهو فحص واحد، ولا يمكن أن يرمي استثناءً، والمتغيّر الجديد لا يكون في النطاق إلا حيث نجح الاختبار. واستخدم التحويل الصريح العادي حين يكون النوع المختلف خطأً يجب أن يفشل بوضوح. حالة int المغلّف توقع من يقرأ الأرقام من مجموعات object أو خلايا DataRow: فكّ التغليف إلى النوع الدقيق أولًا ((long)(int)boxed)، أو استخدم Convert.ToInt64(boxed)، التي تتعامل مع أي نوع رقمي.