Type Casting in C#

في لغة C# واللغات اللي قريبة منها في التعامل مع الـ Memory، لما بنحتاج نغير نوع بيانات Variable معين لنوع بيانات تاني، بنعمل حاجة اسمها Casting أو Type Conversion. الموضوع ده ليه نوعين أساسيين:

• الـ Implicit Casting: وده بيحصل تلقائي من الـ Compiler. بيكون وأنت بتحول من نوع بيانات حجمه صغير في الـ Memory لنوع حجمه أكبر. الترتيب التقريبي للتحويل الآمن ده بيكون كالتالي: char → int → long → float → double

• الـ Explicit Casting: وده بتحتاج تعمله أنت يدويًا كـ Developer. بيكون وأنت بتحاول تحول من نوع بيانات حجمه كبير في الـ Memory لنوع حجمه أصغر. الترتيب التقريبي للتحويل ده بيكون عكس الـ Implicit Casting وممكن يحصل فيه فقدان للـ Data: double → float → long → int → char

الـ Type Conversion (سواء Implicit أو Explicit) بيكون ممكن بس لو نوعين الـ Data متوافقين مع بعض. لو مفيش توافق، غالبًا هيطلعلك Compiler Error.

Implicit Casting

النوع ده من الـ Casting بيحصل لوحده أوتوماتيك من غير ما تكتب أي حاجة زيادة في الـ Code. ده بيكون وأنت بتحول من نوع بيانات صغير (زي int) لنوع بيانات أكبر (زي double). الـ Compiler بيعمل ده لأن التحويل في الاتجاه ده بيكون آمن (Safe Casting)، ومش بيحصل فيه أي فقدان للـ Data ولا بتطلعلك RunTime Errors ليها علاقة بالموضوع ده.

int myInt = 9;
double myDouble = myInt; // Automatic casting: int to double
// Safe Casting, No RunTime Errors
Console.WriteLine(myDouble); // Output: 9

Explicit Casting

النوع ده بتحتاج تعمله أنت بنفسك في الـ Code باستخدام الـ Cast Operator اللي هو الأقواس () وبتحط جواها نوع البيانات اللي عايز تحول ليه. ده بيحصل غالبًا لما بتحول من نوع بيانات كبير لنوع بيانات أصغر. النوع ده يعتبر غير آمن (Unsafe Casting) لأن ممكن يحصل فيه فقدان للـ Data (Data Loss) لو القيمة اللي بتحولها أكبر من الـ Type الجديد يقدر يشيلها.

Memory

مع الـ Explicit Casting، خصوصًا لما بتحاول تحط قيمة كبيرة جوه Variable من نوع صغير، ممكن الـ Data Type ده ميقدرش يشيل القيمة كلها، وده اللي بيحصل مع الـ unsafe casting.

مثال يوضح مشكلة الـ Overflow:

int x;
double y = 50.5;
 
x = (int) y; // Converting double to int. Fractional part is lost.
Console.WriteLine(x); // Output: 50
 
long largeValue = long.MaxValue; // Max value for long
// largeValue = 9223372036854775807
 
int smallInt;
// Trying to put the large long value into an int
smallInt = (int) largeValue;
// Overflow occurs here. int cannot hold this value.
// CLR does not throw an exception by default. Result is garbage value.
Console.WriteLine(smallInt); // Output will be due to overflow

في المثال اللي فات، لما بنحاول نحط قيمة أكبر بكتير من اللي الـ int يقدر يشيلها (من الـ long.MaxValue)، بيحصل حاجة اسمها Overflow. الـ CLR (Common Language Runtime) في الحالة دي مش بيرمي Exception يوقف البرنامج، ودي حاجة ممكن تعمل مشاكل لو مش واخد بالك.

مثال تاني على الـ Overflow مع أنواع أصغر:

int x = 300;
// byte can hold values from 0 to 255
byte y = (byte) x; // Trying to put 300 into a byte. Overflow occurs.
// The value will wrap around based on byte's range (300 % 256 roughly)
Console.WriteLine(y); // Output: 44 (garbage value relative to original 300)

Checked

لو عايز تتأكد إن عملية الـ Explicit Casting مش هتسبب Overflow وتطلع Exception لو حصل Overflow فعلًا، ممكن تستخدم الـ Keyword اللي اسمها checked.

int x = 300;
try
{
    checked // Enable overflow checking
    {
        // CLR will check for overflow here
        byte y = (byte)x; // This will throw System.OverflowException
        Console.WriteLine(y);
    }
}
catch (OverflowException ex)
{
    Console.WriteLine($"An overflow occurred: {ex.Message}");
    // Handle the exception here
}
// Output: An overflow occurred: Arithmetic operation resulted in an overflow.

استخدام الـ checked مفيد لما تكون مش متأكد إن القيمة اللي بتحولها هتناسب الـ Type الجديد وعايز البرنامج يطلع Error واضح بدل ما يحط قيمة غلط.

Unchecked

الـ Keyword اللي اسمها unchecked بتعمل العكس تمامًا من checked. لو استخدمتها حوالين جزء من الـ Code، بتضمن إن الـ CLR مش هيتأكد لو فيه Overflow ومش هيرمي Exception حتى لو حصل. استخدامها الأساسي بيكون جوه checked block لو فيه جزء صغير جوه الـ Block ده مش عايز يتطبق عليه الـ Check بتاع الـ Overflow لأي سبب.

int x = 300;
checked // Outer checked block
{
    // checked behavior is active
    unchecked // Inner unchecked block
    {
        // No overflow check in this block
        byte y = (byte)x; // Overflow occurs, but no exception
        Console.WriteLine($"Inside unchecked: {y}"); // Output: Inside unchecked: 44
    }
    // checked behavior resumes here
}

Data Type

غير طريقة الـ Cast Operator اللي شفناها، فيه طرق تانية لتحويل الـ Data Types خصوصًا بين الأنواع اللي مش متوافقة مباشرة زي الـ string والأرقام.

C# Method (Parse)

لو عايز تحول string لنوع بيانات تاني (زي رقم صحيح int مثلاً)، مش هينفع تستخدم الـ Cast Operator العادي مباشرة. هنا بييجي دور الـ Parse Method. تقريبًا كل الـ Primitive Data Types (زي int, double, bool، وهكذا) بيكون فيهم static Parse Method بتاخد string كـ parameter وبتحاول تحولها للـ Type ده.

// Example: Reading console input (which is string) and converting to a number
// int a = Console.ReadLine(); // Compile-time ERROR: Cannot implicitly convert string to int
 
Console.Write("Enter a number: ");
string input = Console.ReadLine();
int a = int.Parse(input); // Use Parse to convert the input string to int
Console.WriteLine($"You entered: {a}");
 
// Example: Converting string to a boolean value
string boolString1 = "true";
bool b1 = bool.Parse(boolString1);
Console.WriteLine(b1); // Output: True
 
string boolString2 = "false";
bool b2 = bool.Parse(boolString2);
Console.WriteLine(b2); // Output: False
 
// Note: If the string cannot be parsed (e.g., int.Parse("Hello")),
// a Run-time Error (FormatException) will occur.

الـ Parse Method مفيدة جدًا لتحويل الـ input اللي بييجي على شكل string (زي من الـ Console أو ملفات الـ Text) للـ Data Type المناسب.

.NET Method (Convert)

الـ .NET Framework فيه Class اسمها Convert ودي فيها مجموعة كبيرة من الـ Static Methods اللي بتسهل عملية التحويل بين أنواع مختلفة من الـ Data Types، حتى لو مكانوش متوافقين بشكل مباشر زي الـ string والأرقام. أمثلة على الـ Methods دي: Convert.ToBoolean, Convert.ToDouble, Convert.ToString, Convert.ToInt32 (لـ int)، و Convert.ToInt64 (لـ long).

int myInt = 10;
double myDouble = 5.25;
bool myBool = true;
string myString = "123";
 
Console.WriteLine(Convert.ToString(myInt));    // convert int to string
Console.WriteLine(Convert.ToDouble(myInt));    // convert int to double
Console.WriteLine(Convert.ToInt32(myDouble));  // convert double to int (will lose the decimal part)
Console.WriteLine(Convert.ToString(myBool));   // convert bool to string (will output "True")
Console.WriteLine(Convert.ToInt32(myString));  // convert string "123" to int (will output 123)
 
// Note: Convert Methods can handle null values safely in some cases.
// For example, Convert.ToInt32(null) will result in 0 instead of an exception.
// However, if the string has invalid format (like letters), it will still throw an exception (e.g., FormatException).

الـ Convert Class بتوفر مرونة أكبر في التحويل بين أنواع مختلفة مقارنة بالـ Cast Operator أو الـ Parse Method لوحدها.

Info

بالنسبة لل Convert ففيها ميزة قوية جدًا وهي إن لو بتعمل convert ل int مثلًا والقيمة null فهو هيحطها ب zero هيهندل الدنيا لوحده

Using TryParse Method

زي ما شفنا، الـ Parse Method بترمي Exception لو الـ string اللي بنحاول نحولها مش format مناسب للـ Type اللي بنحول ليه. عشان نتجنب الـ Exceptions دي ونخلي الـ Code بتاعنا أأمن لما نحول من string، بنستخدم الـ TryParse Method.

الـ TryParse Method موجودة برضه كـ Static Method في معظم الـ Value Types (زي int.TryParse, double.TryParse, bool.TryParse). هي بتحاول تحول الـ string، ولو نجحت بترجع true وبتحط النتيجة في Variable بتحدده باستخدام الـ out Keyword. لو فشلت في التحويل، بترجع false والقيمة في الـ Variable بتاع الـ out بتكون القيمة الافتراضية للـ Type ده (زي 0 للأرقام، false للـ bool، وهكذا).

string str1 = "100";
int i1;
// Attempt to parse str1 into an int. Result goes into IsConverted1 (true/false), value into i1 if successful.
bool IsConverted1 = int.TryParse(str1, out i1);
 
if (IsConverted1)
{
    Console.WriteLine($"String \"{str1}\" was successfully converted to int: {i1}"); // Output: String "100" was successfully converted to int: 100
}
else
{
    Console.WriteLine($"Failed to convert string \"{str1}\" to int.");
}
 
string str2 = "Hello";
int i2;
// Attempt to parse str2 into an int. This will fail.
bool IsConverted2 = int.TryParse(str2, out i2);
 
if (IsConverted2)
{
    Console.WriteLine($"String \"{str2}\" was successfully converted to int: {i2}");
}
else
{
    Console.WriteLine($"Failed to convert string \"{str2}\" to int."); // Output: Failed to convert string "Hello" to int.
    Console.WriteLine($"Default value of i2 after failed TryParse: {i2}"); // Output: Default value of i2 after failed TryParse: 0
}

استخدام الـ TryParse أحسن في أغلب الأوقات من الـ Parse لو مش متأكد من الـ format بتاع الـ string اللي جاي، لأنه بيخليك تتعامل مع حالة الفشل من غير ما البرنامج يضرب بـ Exception.