Type Casting ในภาษา C#

Type Casting หรือ “การแปลงชนิดข้อมูล” (การแปลงประเภทของตัวแปรจากชนิดหนึ่งไปเป็นอีกชนิดหนึ่ง) คือกระบวนการที่ช่วยให้โปรแกรมเมอร์สามารถนำข้อมูลชนิดหนึ่งไปใช้ร่วมกับอีกชนิดได้อย่างถูกต้อง เช่น การแปลงจาก int เป็น double, หรือจาก double เป็น int เป็นต้น

ภาษา C# เป็นภาษาที่มีระบบชนิดข้อมูลแบบ strongly typed หมายความว่าทุกค่าหรือตัวแปรต้องมีชนิดข้อมูลที่แน่นอนก่อนนำไปใช้งาน ดังนั้นเมื่อชนิดข้อมูลไม่ตรงกัน เราจำเป็นต้องทำ Type Casting เพื่อให้โปรแกรมทำงานได้ถูกต้องและปลอดภัย

ทำไมต้องมี Type Casting

ในโปรแกรมจริง เรามักต้องนำค่าจากหลายแหล่งมาคำนวณหรือแสดงผล เช่น การคำนวณตัวเลขระหว่างจำนวนเต็ม (int) กับทศนิยม (double), หรือการรับค่าจากผู้ใช้ในรูปของข้อความ (string) แล้วแปลงให้เป็นตัวเลขก่อนใช้งาน ซึ่งหากไม่แปลงชนิดข้อมูลให้ถูกต้อง โปรแกรมจะไม่สามารถทำงานได้ หรืออาจเกิดข้อผิดพลาดในการคำนวณได้

Type Casting จึงเป็นเครื่องมือสำคัญที่ทำให้เราสามารถ “เชื่อม” ข้อมูลต่างชนิดกันให้ทำงานร่วมกันได้อย่างถูกต้องและมีประสิทธิภาพ

ประเภทของ Type Casting ในภาษา C#

ในภาษา C# การแปลงชนิดข้อมูลแบ่งออกได้เป็น 2 ประเภทหลัก ได้แก่

1. Implicit Casting (การแปลงแบบอัตโนมัติ)
2. Explicit Casting (การแปลงแบบระบุเอง)

แต่ละแบบมีลักษณะการทำงานที่แตกต่างกัน และควรเลือกใช้ให้เหมาะกับบริบทของข้อมูล

Implicit Casting การแปลงชนิดข้อมูลแบบอัตโนมัติ

Implicit Casting คือการแปลงชนิดข้อมูลที่ ไม่ต้องเขียนโค้ดระบุชนิดใหม่ เพราะคอมไพเลอร์ของ C# จะทำให้โดยอัตโนมัติ เมื่อชนิดข้อมูลปลายทางกว้างกว่าชนิดข้อมูลต้นทาง

ตัวอย่างเช่น การแปลงจาก int ไป double เพราะ double สามารถเก็บค่าทศนิยมและขนาดข้อมูลได้มากกว่า int

namespace MyConsoleApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
            int num = 10;         // จำนวนเต็ม
            double result = num;  // แปลงอัตโนมัติจาก int → double
            Console.WriteLine($"ค่าหลังแปลง: {result}");
        }
    }
}

namespace MyConsoleApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
            int num = 10;         // จำนวนเต็ม
            double result = num;  // แปลงอัตโนมัติจาก int → double
            Console.WriteLine($"ค่าหลังแปลง: {result}");
        }
    }
}

• int num = 10; → สร้างตัวแปรจำนวนเต็มชื่อ num
• double result = num; → คอมไพเลอร์แปลงค่า num จาก int เป็น double โดยอัตโนมัติ
• Console.WriteLine(...) → แสดงผลค่าหลังการแปลง

ผลลัพธ์

ค่าหลังแปลง: 10

Implicit Casting จะเกิดขึ้นได้เฉพาะเมื่อไม่มีการสูญเสียข้อมูล เช่น จาก int → double, float → double, หรือ char → int เป็นต้น

Explicit Casting การแปลงชนิดข้อมูลแบบระบุเอง

Explicit Casting คือการแปลงชนิดข้อมูลที่ ต้องระบุชนิดใหม่ด้วยตนเอง โดยใช้วงเล็บ (type) ครอบค่าที่ต้องการแปลง เหมาะสำหรับกรณีที่คอมไพเลอร์ไม่สามารถแปลงได้อัตโนมัติ หรือกรณีที่อาจเกิดการ “สูญเสียข้อมูล” เช่น การแปลงจาก double เป็น int

namespace MyConsoleApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
            double price = 99.99;
            int roundedPrice = (int)price;  // แปลงจาก double → int
            Console.WriteLine($"ราคาหลังปัดเศษ: {roundedPrice}");
        }
    }
}

namespace MyConsoleApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
            double price = 99.99;
            int roundedPrice = (int)price;  // แปลงจาก double → int
            Console.WriteLine($"ราคาหลังปัดเศษ: {roundedPrice}");
        }
    }
}

• double price = 99.99; → สร้างตัวแปรทศนิยม
• (int)price → แปลงค่าเป็นจำนวนเต็มโดยตัดทศนิยมออก
• Console.WriteLine(...) → แสดงผลลัพธ์ที่แปลงแล้ว

ผลลัพธ์

ราคาหลังปัดเศษ: 99

Explicit Casting อาจทำให้เกิด “การสูญเสียข้อมูล” เช่น ทศนิยมจะหายไป หรือค่าล้น (overflow) หากเกินช่วงที่ชนิดปลายทางรองรับได้

การแปลงระหว่างชนิดข้อมูลที่ไม่ใช่ตัวเลข

นอกจากตัวเลขแล้ว เรายังสามารถแปลงชนิดข้อมูลอื่น ๆ ได้ เช่น string เป็น int หรือ int เป็น string โดยใช้คลาสช่วยเหลือใน .NET เช่น Convert, Parse, และ ToString()

namespace MyConsoleApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
            string input = "256";
            int number = Convert.ToInt32(input);     // string → int
            string text = number.ToString();         // int → string

            Console.WriteLine($"ค่าที่แปลงเป็น int: {number}");
            Console.WriteLine($"ค่าที่แปลงกลับเป็น string: {text}");
        }
    }
}

namespace MyConsoleApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
            string input = "256";
            int number = Convert.ToInt32(input);     // string → int
            string text = number.ToString();         // int → string

            Console.WriteLine($"ค่าที่แปลงเป็น int: {number}");
            Console.WriteLine($"ค่าที่แปลงกลับเป็น string: {text}");
        }
    }
}

• string input = "256"; → เก็บข้อความตัวเลขในรูป string
• Convert.ToInt32(input); → แปลง string เป็นจำนวนเต็ม
• number.ToString(); → แปลง int กลับเป็น string อีกครั้ง
• Console.WriteLine(...) → แสดงผลการแปลงทั้งสองแบบ

ผลลัพธ์

ค่าที่แปลงเป็น int: 256
ค่าที่แปลงกลับเป็น string: 256

ความแตกต่างระหว่างการใช้คลาส Convert และ Parse

• Convert.ToInt32() จะคืนค่า 0 หากแปลงไม่ได้ (ไม่เกิดข้อผิดพลาดร้ายแรง)
• int.Parse() จะเกิด FormatException หากค่าที่แปลงไม่ใช่ตัวเลข
• TryParse() จะปลอดภัยที่สุด เพราะไม่ทำให้โปรแกรมหยุดทำงานเมื่อแปลงไม่ได้

ตัวอย่าง

namespace MyConsoleApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
            string input = "abc";
            bool success = int.TryParse(input, out int value);
            Console.WriteLine($"สำเร็จหรือไม่: {success}, ค่า: {value}");
        }
    }
}

namespace MyConsoleApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
            string input = "abc";
            bool success = int.TryParse(input, out int value);
            Console.WriteLine($"สำเร็จหรือไม่: {success}, ค่า: {value}");
        }
    }
}

ผลลัพธ์

สำเร็จหรือไม่: False, ค่า: 0

การแปลงแบบ Boxing และ Unboxing

Boxing คือการแปลงชนิดข้อมูล Value Type (เช่น int, bool) ให้กลายเป็น Reference Type (object)

ส่วน Unboxing คือการแปลงกลับจาก object ไปเป็น Value Type อีกครั้ง

ตัวอย่าง

namespace MyConsoleApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
            int x = 100;
            object obj = x;       // Boxing: int → object
            int y = (int)obj;     // Unboxing: object → int
            Console.WriteLine($"ค่าเดิม: {x}, หลังแปลงกลับ: {y}");
        }
    }
}

namespace MyConsoleApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
            int x = 100;
            object obj = x;       // Boxing: int → object
            int y = (int)obj;     // Unboxing: object → int
            Console.WriteLine($"ค่าเดิม: {x}, หลังแปลงกลับ: {y}");
        }
    }
}

• Boxing จะเกิดขึ้นเมื่อเราเก็บค่าจำนวนเต็มไว้ในตัวแปรชนิด object
• Unboxing จะดึงค่ากลับมาใช้ในรูปแบบเดิม

ข้อควรระวังในการใช้ Type Casting

• การแปลงข้อมูลผิดชนิดอาจทำให้เกิด Runtime Error
• ควรใช้ TryParse() แทน Parse() เพื่อป้องกันการแปลงผิดพลาด
• การแปลงซ้ำซ้อนบ่อย ๆ จะส่งผลต่อประสิทธิภาพของโปรแกรม
• หลีกเลี่ยงการแปลงข้อมูลที่มีโอกาส “ล้นค่า” (Overflow)

สรุปภาพรวมของ Type Casting ในภาษา C#

Type Casting เป็นแนวคิดสำคัญในภาษา C# ที่ช่วยให้โปรแกรมสามารถสื่อสารระหว่างชนิดข้อมูลต่าง ๆ ได้อย่างปลอดภัยและยืดหยุ่น หากเข้าใจหลักการเลือกใช้การแปลงแต่ละแบบอย่างถูกต้อง จะช่วยลดข้อผิดพลาดในโปรแกรม และทำให้โค้ดดูเป็นมืออาชีพมากยิ่งขึ้น