String to int ב-C#: המרת טיפוסים, casting, Parse, TryParse ו-Convert

C# אף פעם לא ממירה בעצמה בין טיפוסים שאינם קשורים. מחרוזת שמכילה ספרות היא עדיין מחרוזת, ו-double לא הופך בשקט ל-int. ממירים במפורש, והכלי תלוי במה שממירים: טקסט למספר (פענוח), טיפוס מספרי אחד לאחר (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 היא בחירת ברירת המחדל לקלט, לקבצים ול-query strings. אותן מתודות קיימות בכל טיפוס מספרי: 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), וזה הקומפיילר שמבקש מכם לבחור בין המרה לבין מתודת עיגול.

מספרים וטיפוסים אחרים למחרוזת

לכל טיפוס יש 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" זורקים).

המרות הפניה: casts, 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 ארוז (boxed) מכשיל אנשים שקוראים מספרים מאוספי object או מתאי DataRow: פרקו קודם לטיפוס המדויק ((long)(int)boxed), או השתמשו ב-Convert.ToInt64(boxed), שמטפלת בכל טיפוס מספרי.