เจเนอริกใน C#

ยินดีต้อนรับสู่บทเรียนแรกในหัวข้อ "คุณลักษณะขั้นสูงของ C#"! ในบทเรียนนี้ คุณจะได้เรียนรู้เกี่ยวกับเจเนอริก ซึ่งเป็นคุณลักษณะที่มีประสิทธิภาพใน C# ที่ช่วยให้คุณสร้างโค้ดที่ยืดหยุ่นและนำกลับมาใช้ใหม่ได้ มาเริ่มกันเลย!

เจเนอริกคืออะไร

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

ตัวอย่าง: รายการเจเนอริก (List<T>) สามารถจัดเก็บองค์ประกอบชนิดใดก็ได้ พร้อมทั้งรับประกันความปลอดภัยของชนิดข้อมูล

การสร้างคลาสเจเนอริก

คุณสามารถกำหนดคลาสเจเนอริกโดยใช้ไวยากรณ์ <T> โดยที่ T แทนพารามิเตอร์ชนิดข้อมูล ตัวอย่าง:

ประเด็นสำคัญ: ใช้เจเนอริกเพื่อสร้างคลาสที่ทำงานกับชนิดข้อมูลใดก็ได้ โดยยังคงรักษาความปลอดภัยของชนิดข้อมูลไว้

using System;

class GenericBox<T> {
    public T Value { get; set; }

    public void Display() {
        Console.WriteLine("Value: " + Value);
    }
}

class Program {
    static void Main() {
        GenericBox<int> intBox = new GenericBox<int> { Value = 42 };
        intBox.Display(); // Outputs: Value: 42

        GenericBox<string> stringBox = new GenericBox<string> { Value = "Hello, Generics!" };
        stringBox.Display(); // Outputs: Value: Hello, Generics!
    }
}

การสร้างเมธอดเจเนอริก

คุณสามารถกำหนดเมธอดเจเนอริกภายในคลาสได้ ตัวอย่าง:

เคล็ดลับ: ใช้เมธอดเจเนอริกสำหรับการดำเนินการที่ใช้ได้กับชนิดข้อมูลหลายชนิด

using System;

class Program {
    static void Main() {
        PrintValue(42);
        PrintValue("Generics are powerful!");
    }

    static void PrintValue<T>(T value) {
        Console.WriteLine("Value: " + value);
    }
}

ข้อจำกัดของเจเนอริก

ข้อจำกัดจะจำกัดชนิดข้อมูลที่สามารถใช้เป็นพารามิเตอร์ชนิดข้อมูลได้ ตัวอย่าง:

• where T : struct - T ต้องเป็นชนิดค่า
• where T : class - T ต้องเป็นชนิดอ้างอิง
• where T : new() - T ต้องมีตัวสร้างที่ไม่มีพารามิเตอร์

ตัวอย่าง:

ประเด็นสำคัญ: ข้อจำกัดทำให้เจเนอริกมีความยืดหยุ่นและเหมาะกับสถานการณ์เฉพาะมากขึ้น

using System;

class Program {
    static void Main() {
        DisplayDefault<int>();
        DisplayDefault<string>();
    }

    static void DisplayDefault<T>() where T : new() {
        T instance = new T();
        Console.WriteLine("Created instance of: " + typeof(T));
    }
}

คอลเลกชันเจเนอริก

C# มีคอลเลกชันเจเนอริกที่มาพร้อมระบบหลายรูปแบบ:

• List<T>: จัดเก็บคอลเลกชันขององค์ประกอบในอาร์เรย์แบบไดนามิก
• Dictionary<TKey, TValue>: จัดเก็บคู่คีย์-ค่าเพื่อให้ค้นหาได้อย่างรวดเร็ว
• Queue<T>: ใช้โครงสร้างเข้าก่อนออกก่อน (FIFO)

ตัวอย่าง: การใช้รายการเจเนอริก:

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        List<string> names = new List<string> { "Alice", "Bob", "Charlie" };
        names.Add("Diana");

        foreach (string name in names) {
            Console.WriteLine(name);
        }
    }
}

โจทย์ฝึกปฏิบัติ

สร้างคลาสเจเนอริก Pair<TKey, TValue> ที่จัดเก็บคู่คีย์-ค่า และสร้างเมธอดเจเนอริก Swap() ที่สลับคีย์กับค่า ตัวอย่าง:

using System;

class Pair<TKey, TValue> {
    public TKey Key { get; set; }
    public TValue Value { get; set; }

    public void Swap() {
        (Key, Value) = ((TKey)(object)Value, (TValue)(object)Key);
    }

    public void Display() {
        Console.WriteLine($"Key: {Key}, Value: {Value}");
    }
}

class Program {
    static void Main() {
        Pair<string, int> pair = new Pair<string, int> { Key = "Age", Value = 30 };
        pair.Display();
        pair.Swap();
        pair.Display();
    }
}

แนวปฏิบัติที่ดีสำหรับการใช้เจเนอริก

ต่อไปนี้คือแนวปฏิบัติที่ดี:

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

เคล็ดลับ: ใช้ชื่อพารามิเตอร์ชนิดข้อมูลที่สื่อความหมาย เช่น T สำหรับชนิดข้อมูล หรือ TKey และ TValue สำหรับคู่คีย์-ค่า

ยอดเยี่ยม!

ขอแสดงความยินดีด้วย! คุณได้เรียนรู้วิธีใช้ชนิดข้อมูลทั่วไปเพื่อสร้างโค้ดที่นำกลับมาใช้ใหม่ได้และยืดหยุ่นใน C# แล้ว ในบทเรียนถัดไป เราจะสำรวจการเขียนโปรแกรมแบบอะซิงโครนัสด้วย async และ await มาเขียนโค้ดกันต่อไป!