C# Academy · บทเรียน

รูปแบบชนิดข้อมูลและคุณสมบัติ

จับคู่ตามรูปร่างและสมาชิก

รูปแบบชนิดข้อมูลและคุณสมบัติ เป็นบทเรียน C# Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน C# Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส C# Academy มีบทเรียนทั้งหมด 4 บทเรียน

รูปแบบชนิดข้อมูล

รูปแบบชนิดข้อมูลจะตรงกันเมื่อข้อมูลเข้าเป็นอินสแตนซ์ของชนิดข้อมูลที่กำหนด การเขียนเพียงชื่อชนิดข้อมูลไว้ในแขนงของสวิตช์จะเป็นการตรวจสอบชนิดข้อมูลขณะทำงานของค่า

วิธีนี้แทนที่สายโซ่การตรวจสอบ is และการแปลงชนิดที่ยุ่งยากด้วยการตรวจสอบในนิพจน์เดียวที่สะอาดกว่า และยังปรับชนิดข้อมูลให้แคบลงให้โดยอัตโนมัติ

object o = "hello";
string kind = o switch
{
    int    => "number",
    string => "text",
    _      => "unknown"
};
System.Console.WriteLine(kind);

รูปแบบการประกาศ

รูปแบบการประกาศจะเพิ่มชื่อตัวแปรต่อท้ายชนิดข้อมูล เช่น string s เมื่อรูปแบบตรงกัน ข้อมูลเข้าจะถูกแปลงชนิดและผูกไว้กับตัวแปรนั้น

จากนั้นคุณสามารถใช้ตัวแปรที่มีชนิดข้อมูลแล้วทางด้านขวาของแขนง เพื่อเข้าถึงสมาชิกเฉพาะของชนิดข้อมูลนั้นได้โดยไม่ต้องแปลงชนิดเพิ่มเติม

object o = "coddy";
string result = o switch
{
    string s => $"len {s.Length}",
    int n    => $"value {n}",
    _        => "other"
};
System.Console.WriteLine(result);

สวิตช์ตามชนิดข้อมูลที่ทำงานได้

รูปแบบชนิดข้อมูลเหมาะอย่างยิ่งสำหรับประมวลผลข้อมูลต่างชนิดกัน เช่น การแยกวิเคราะห์ค่าจากอาร์เรย์ object

ในที่นี้แต่ละองค์ประกอบจะถูกตรวจสอบตามชนิดข้อมูลขณะทำงาน แล้วจัดรูปแบบให้เหมาะสม ตัวแปรที่ผูกไว้จะนำชนิดข้อมูลที่แคบลงไปยังนิพจน์ผลลัพธ์

using System;

class Program {
    static string Describe(object o) => o switch {
        int i    => $"int {i}",
        double d => $"double {d}",
        string s => $"string '{s}'",
        _        => "?"
    };
    static void Main() {
        foreach (var x in new object[]{ 1, 2.5, "hi" })
            Console.WriteLine(Describe(x));
    }
}

รูปแบบคุณสมบัติ

รูปแบบคุณสมบัติจะตรวจสอบสมาชิกของออบเจ็กต์โดยใช้วงเล็บปีกกา เช่น { Property: value } รูปแบบนี้จะตรงกันเมื่อคุณสมบัติทุกตัวที่ระบุมีรูปแบบย่อยตรงกัน

วิธีนี้ช่วยให้คุณแตกแขนงตามโครงสร้างและเนื้อหาของออบเจ็กต์ได้โดยตรง โดยไม่ต้องเขียนการเปรียบเทียบสมาชิกด้วยตนเอง

record Person(string Name, int Age);

var p = new Person("Ada", 30);
string stage = p switch
{
    { Age: < 18 } => "minor",
    { Age: >= 65 } => "senior",
    _ => "adult"
};
System.Console.WriteLine(stage);

คุณสมบัติหลายรายการ

คุณสามารถตรวจสอบคุณสมบัติหลายรายการพร้อมกันได้ โดยคั่นแต่ละรายการด้วยจุลภาคภายในวงเล็บปีกกา ทุกคุณสมบัติต้องตรงกัน แขนงจึงจะทำงาน

วิธีนี้แสดงเงื่อนไขประกอบได้อย่างชัดเจน เช่น การตรวจสอบออบเจ็กต์ที่มีทั้งสถานะและจำนวนเฉพาะ

record Order(string Status, int Items);

var order = new Order("Open", 0);
string msg = order switch
{
    { Status: "Open", Items: 0 } => "empty cart",
    { Status: "Open" } => "shopping",
    _ => "closed"
};
System.Console.WriteLine(msg);

การรวมรูปแบบชนิดข้อมูลกับคุณสมบัติ

คุณสามารถรวมรูปแบบชนิดข้อมูลกับรูปแบบคุณสมบัติได้ โดยเขียนชนิดข้อมูลก่อน แล้วตามด้วยบล็อกคุณสมบัติในวงเล็บปีกกา แขนงจะตรงกันก็ต่อเมื่อข้อมูลเข้าเป็นชนิดข้อมูลนั้นและคุณสมบัติของข้อมูลตรงกัน

วิธีนี้มีประโยชน์มากเมื่อจัดการกับการอ้างอิงคลาสฐานหรืออินเทอร์เฟซ ซึ่งต้องการแตกแขนงตามทั้งชนิดย่อยที่เป็นรูปธรรมและสถานะของชนิดย่อยนั้น

using System;

abstract record Shape;
record Circle(double R) : Shape;
record Square(double Side) : Shape;

class Program {
    static string Big(Shape s) => s switch {
        Circle { R: > 10 } => "big circle",
        Square { Side: > 10 } => "big square",
        _ => "small"
    };
    static void Main() => Console.WriteLine(Big(new Circle(12)));
}

รูปแบบคุณสมบัติแบบซ้อน

รูปแบบคุณสมบัติสามารถซ้อนกันได้ หากคุณสมบัติเป็นออบเจ็กต์อีกตัวหนึ่ง คุณสามารถตรวจสอบสมาชิกของมันด้วยบล็อกวงเล็บปีกกาอีกชุด

ตัวอย่างเช่น { Address: { City: "Paris" } } จะตรวจสอบลึกลงไปสองระดับในนิพจน์เดียว วิธีนี้ช่วยหลีกเลี่ยงสายการเข้าถึงด้วยจุดที่เสี่ยงต่อค่า null

record Address(string City);
record User(string Name, Address Address);

var u = new User("Lin", new Address("Paris"));
bool inParis = u is { Address: { City: "Paris" } };
System.Console.WriteLine(inParis);

การเข้าถึงคุณสมบัติแบบขยาย

ตั้งแต่ C# 10 เป็นต้นมา คุณสามารถใช้เส้นทางที่คั่นด้วยจุดภายในรูปแบบคุณสมบัติได้ เช่น { Address.City: "Paris" } ซึ่งเป็นรูปแบบย่อของวงเล็บปีกกาที่ซ้อนกัน

วิธีนี้ทำให้การตรวจสอบที่ลึกหลายระดับถูกรวมเป็นบรรทัดเดียวที่อ่านง่าย และยังจัดการค่าระหว่างทางได้อย่างปลอดภัยขณะตรวจสอบรูปแบบ

record Address(string City);
record User(string Name, Address Address);

var u = new User("Lin", new Address("Rome"));
string where = u switch
{
    { Address.City: "Paris" } => "FR",
    { Address.City: "Rome" }  => "IT",
    _ => "??"
};
System.Console.WriteLine(where);

การเก็บค่าที่ตรงกันทั้งหมด

คุณสามารถผูกตัวแปรเข้ากับค่าที่ตรงกันทั้งหมดได้ โดยเพิ่มชื่อไว้หลังรูปแบบคุณสมบัติ เช่น { Age: > 18 } adult

จากนั้นตัวแปร adult จะอ้างอิงออบเจ็กต์ทั้งหมดภายในแขนง ทำให้คุณนำไปใช้ได้หลังจากยืนยันแล้วว่าคุณสมบัติของออบเจ็กต์ผ่านการตรวจสอบ

using System;

record Person(string Name, int Age);

class Program {
    static void Main() {
        Person p = new("Sam", 40);
        string r = p switch {
            { Age: >= 18 } adult => $"{adult.Name} can vote",
            _ => "too young"
        };
        Console.WriteLine(r);
    }
}

การจัดการค่า Null

รูปแบบคุณสมบัติจะไม่ตรงกับ null เพราะไม่มีออบเจ็กต์ให้ตรวจสอบ ดังนั้น { } หรือวงเล็บปีกกาว่าง จะตรงกับค่าที่ไม่ใช่ null ทุกค่า

ด้วยเหตุนี้ not null และ { } จึงเป็นรูปแบบที่มีประโยชน์สำหรับตรวจสอบค่า null และช่วยให้แขนงที่อิงคุณสมบัติข้ามข้อมูลเข้าแบบ null ได้อย่างปลอดภัย

string? maybe = null;
string state = maybe switch
{
    null => "missing",
    { Length: 0 } => "empty",
    _ => "has text"
};
System.Console.WriteLine(state);

เหตุผลที่รูปแบบดีกว่าการแปลงชนิด

ก่อนมีรูปแบบ การแตกแขนงตามชนิดข้อมูลต้องใช้การตรวจสอบ is ตามด้วยการแปลงชนิดและการดักค่า null รูปแบบชนิดข้อมูลและรูปแบบคุณสมบัติรวมทุกอย่างนี้ไว้ในนิพจน์เดียว

คอมไพเลอร์ยังติดตามความครอบคลุมทุกกรณีและความสามารถในการเข้าถึงแขนง ทำให้ตรวจพบแขนงที่ไม่มีทางทำงานและกรณีที่ขาดหาย ซึ่งสายโซ่ if ที่เขียนเองอาจมองข้ามไปโดยไม่แจ้งเตือน

object o = 42;
// Old: if (o is int) { int n = (int)o; ... }
// New:
if (o is int n) System.Console.WriteLine(n + 1);

ตรวจสอบความเข้าใจ

ทดสอบความเข้าใจเกี่ยวกับรูปแบบชนิดข้อมูลและรูปแบบคุณสมบัติ

สรุปทบทวน

รูปแบบชนิดข้อมูลจะตรวจสอบตามชนิดข้อมูลขณะทำงานและสามารถผูกตัวแปรที่มีชนิดข้อมูลได้ รูปแบบคุณสมบัติจะตรวจสอบสมาชิกด้วย { Prop: pattern } รองรับการซ้อนกันและเส้นทางที่คั่นด้วยจุด และจะไม่ตรงกับค่า null

นำรูปแบบทั้งสองมารวมกันเพื่อแตกแขนงตามทั้งโครงสร้างและสถานะ บทถัดไปเราจะศึกษาเรื่องรูปแบบเชิงสัมพันธ์และรูปแบบตรรกะ

คำถามที่พบบ่อย

บทเรียน “รูปแบบชนิดข้อมูลและคุณสมบัติ” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “รูปแบบชนิดข้อมูลและคุณสมบัติ” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส C# Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส C# Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “รูปแบบชนิดข้อมูลและคุณสมบัติ”

จับคู่ตามรูปร่างและสมาชิก คุณปฏิบัติ C# Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน C# Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน C# Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน

บทเรียน “รูปแบบชนิดข้อมูลและคุณสมบัติ” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน C# Academy นี้ได้ไหม

ได้ บทเรียน C# Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

← กลับไปที่ C# Academy