C# Academy · บทเรียน

อินเทอร์เฟซแบบ泛用

สร้างนามธรรมเหนือชนิดข้อมูล

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

อินเทอร์เฟซแบบทั่วไปคืออะไร

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

คลังโปรแกรมของ .NET ใช้อินเทอร์เฟซเหล่านี้อยู่ทั่วไป เช่น IEnumerable<T> และ IComparable<T>

interface IRepository<T>
{
    void Add(T item);
    T Get(int id);
}

การนำอินเทอร์เฟซแบบทั่วไปไปใช้

คลาสสามารถนำอินเทอร์เฟซแบบทั่วไปไปใช้ได้โดยระบุอาร์กิวเมนต์ชนิดข้อมูลจริง จากนั้นลายเซ็นเมธอดจะใช้ชนิดข้อมูลจริงนั้น

วิธีนี้สร้างสัญญาที่นำกลับมาใช้ใหม่ได้และปลอดภัยด้านชนิดข้อมูลโดยไม่ต้องแปลงชนิด

using System.Collections.Generic;

class IntStore : IRepository<int>
{
    private readonly List<int> data = new();
    public void Add(int item) => data.Add(item);
    public int Get(int id) => data[id];
}

interface IRepository<T>
{
    void Add(T item);
    T Get(int id);
}

การคงความเป็นแบบทั่วไปในคลาสที่นำไปใช้

คลาสสามารถนำอินเทอร์เฟซแบบทั่วไปไปใช้พร้อมกับยังคงเป็นคลาสแบบทั่วไป โดยส่งต่อพารามิเตอร์ชนิดข้อมูลของตนเองไปยังอินเทอร์เฟซ

วิธีนี้ทำให้การนำไปใช้สามารถนำกลับมาใช้ใหม่กับชนิดข้อมูลสมาชิกใดก็ได้

using System.Collections.Generic;

class Store<T> : IRepository<T>
{
    private readonly List<T> data = new();
    public void Add(T item) => data.Add(item);
    public T Get(int id) => data[id];
}

interface IRepository<T> { void Add(T item); T Get(int id); }

IComparable<T> ในการใช้งาน

IComparable<T> เป็นอินเทอร์เฟซแบบทั่วไปในตัว การนำไปใช้ช่วยให้ชนิดข้อมูลของคุณกำหนดวิธีจัดลำดับอินสแตนซ์ได้ และทำให้สามารถเรียงลำดับได้

เมธอด CompareTo จะส่งคืนค่าลบ ศูนย์ หรือค่าบวก

class Money : IComparable<Money>
{
    public int Cents;
    public int CompareTo(Money? other)
        => Cents.CompareTo(other?.Cents ?? 0);
}

การนำ IEnumerable<T> ไปใช้

IEnumerable<T> เป็นหัวใจของ LINQ และ foreach ชนิดข้อมูลที่นำอินเทอร์เฟซนี้ไปใช้จะสามารถวนซ้ำได้ โดยบ่อยครั้งจะมอบหมายงานต่อให้ตัววนซ้ำของชุดข้อมูลภายใน

เมธอดตัววนซ้ำที่ใช้ yield return ทำให้เรื่องนี้ทำได้ง่าย

using System.Collections;
using System.Collections.Generic;

class Bag<T> : IEnumerable<T>
{
    private readonly List<T> items = new();
    public void Add(T x) => items.Add(x);
    public IEnumerator<T> GetEnumerator() => items.GetEnumerator();
    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}

อินเทอร์เฟซแบบทั่วไปที่ทำงานได้จริง

โปรแกรมสมบูรณ์นี้กำหนด IPrinter<T> แบบทั่วไปและนำไปใช้กับสตริง จากนั้นจึงเรียกใช้งาน

อินเทอร์เฟซรับรองว่าจะมีเมธอด Print ไม่ว่าชนิดข้อมูลจริงจะเป็นอะไร

using System;

interface IPrinter<T> { void Print(T value); }

class ConsolePrinter<T> : IPrinter<T>
{
    public void Print(T value) => Console.WriteLine(value);
}

class Program
{
    static void Main()
    {
        IPrinter<string> p = new ConsolePrinter<string>();
        p.Print("hello generics");
    }
}

โคเวเรียนซ์ด้วย out

พารามิเตอร์ของอินเทอร์เฟซแบบทั่วไปที่ทำเครื่องหมายด้วย out จะเป็นโคเวเรียนซ์ โดยปรากฏเฉพาะในตำแหน่งผลลัพธ์ วิธีนี้ทำให้สามารถใช้ IEnumerable<Cat> ในตำแหน่งที่คาดว่าจะเป็น IEnumerable<Animal> ได้

โคเวเรียนซ์จะรักษาความเข้ากันได้ในการกำหนดค่าตามลำดับชั้นการสืบทอด

interface IProducer<out T>
{
    T Produce();
}

คอนทราเวเรียนซ์ด้วย in

พารามิเตอร์ที่ทำเครื่องหมายด้วย in จะเป็นคอนทราเวเรียนซ์ โดยปรากฏเฉพาะในตำแหน่งข้อมูลเข้า วิธีนี้ทำให้สามารถใช้ IComparer<Animal> ในตำแหน่งที่ต้องการ IComparer<Cat> ได้

คอนทราเวเรียนซ์จะกลับทิศทางของความสามารถในการกำหนดค่าสำหรับตัวรับข้อมูล

interface IConsumer<in T>
{
    void Consume(T item);
}

พารามิเตอร์ชนิดข้อมูลหลายตัว

อินเทอร์เฟซแบบเจเนริกสามารถรับพารามิเตอร์ได้มากกว่าหนึ่งตัว ตัวอย่างที่คุ้นเคยคือ IDictionary<TKey, TValue> ซึ่งแยกชนิดข้อมูลของคีย์และค่าออกจากกัน

พารามิเตอร์แต่ละตัวสามารถเป็นแบบไม่แปรผัน แบบแปรผันร่วม หรือแบบแปรผันสวนได้อย่างอิสระ

interface IMapper<TIn, TOut>
{
    TOut Map(TIn input);
}

การเขียนโปรแกรมโดยใช้อินเทอร์เฟซ

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

พารามิเตอร์ของเมธอดที่กำหนดชนิดเป็น IEnumerable<T> สามารถรับทั้งรายการ อาร์เรย์ และผลลัพธ์จากการสืบค้นได้เหมือนกัน

using System.Collections.Generic;
using System.Linq;

int Total(IEnumerable<int> values) => values.Sum();

ข้อจำกัดโดยใช้อินเทอร์เฟซแบบเจเนริก

อินเทอร์เฟซแบบเจเนริกมักปรากฏในฐานะข้อจำกัด where T : IComparable<T> ช่วยให้เมธอดจัดเรียงหรือเปรียบเทียบข้อมูลเข้าได้

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

T Min<T>(T a, T b) where T : IComparable<T>
    => a.CompareTo(b) <= 0 ? a : b;

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

ทดสอบความเข้าใจเกี่ยวกับอินเทอร์เฟซแบบเจเนริก

สรุปทบทวน

อินเทอร์เฟซแบบเจเนริกประกาศพารามิเตอร์ชนิดข้อมูล และเปิดให้ผู้นำไปใช้งานกำหนดค่าหรือส่งต่อพารามิเตอร์เหล่านั้น ตัวอย่างที่มีมาให้ในระบบ ได้แก่ IEnumerable<T>, IComparable<T> และ IDictionary<TKey, TValue>

คำอธิบายการแปรผัน out และ in ช่วยให้เกิดการแปรผันร่วมและการแปรผันสวน และอินเทอร์เฟซแบบเจเนริกก็ทำงานร่วมกับข้อจำกัด where ได้อย่างเป็นธรรมชาติ

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

บทเรียน “อินเทอร์เฟซแบบ泛用” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “อินเทอร์เฟซแบบ泛用”

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

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

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

บทเรียน “อินเทอร์เฟซแบบ泛用” ใช้เวลานานแค่ไหน

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

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

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

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

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