เรียนรู้วิธีใช้อินเทอร์เฟสที่ระบบกําหนด

เสร็จสมบูรณ์เมื่อ

การรวมอินเทอร์เฟสที่ระบบกําหนดลงในแอปพลิเคชัน C# มีประโยชน์ในสถานการณ์การเข้ารหัสที่ใช้งานได้จริงมากมาย อินเทอร์เฟซที่ระบบกําหนดเองใน C# ช่วยให้คุณสามารถใช้ฟังก์ชันที่กําหนดไว้ล่วงหน้า ทําให้แอปพลิเคชันของคุณสอดคล้องกันและเสถียร

อินเทอร์เฟซทั่วไปที่ใช้ในวิธีการ

อินเทอร์เฟซทั่วไปหลายรายการมักใช้ในวิธีการ C# ภายใน .NET framework อินเทอร์เฟซเหล่านี้ให้ฟังก์ชันการทํางานมาตรฐานที่นํามาใช้โดยคลาสต่างๆ

• IComparable: ใช้สําหรับเปรียบเทียบวัตถุ
• IEnumerable: ใช้สําหรับวนซ้ําบนคอลเลกชัน
• IDisposable: ใช้สําหรับปล่อยทรัพยากรที่ไม่มีการจัดการ
• IEquatable: ใช้สําหรับกําหนดการเปรียบเทียบความเท่ากัน

ใช้อินเทอร์เฟสที่ระบบกําหนด

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

อินเทอร์เฟซที่ระบบกําหนดเองใน .NET มักใช้พื้นที่ที่สํารองไว้ T เพื่อแสดงชนิดใดก็ตาม ตัวอย่างเช่น IEquatable อินเทอร์เฟซจะถูกกําหนดใน .NET framework ดังนี้:

public interface IEquatable
{
    bool Equals(T other);
}

เมื่อคุณใช้อินเทอร์เฟซนี้ในคลาส คุณจะแทนที่ T ด้วยชนิดของคลาส

ตัวอย่างเช่น คลาสต่อไปนี้ Car จะใช้ IEquatable อินเทอร์เฟซ:

public class Car : IEquatable
{
    public string Make { get; set; }
    public string Model { get; set; }

    public bool Equals(Car other)
    {
        if (other == null) return false;
        return this.Make == other.Make && this.Model == other.Model;
    }
}

ในตัวอย่าง Car นี้ จะ T แทนที่ ใน IEquatableทําให้ IEquatableเป็น คลาส Car มีการนําไปใช้เองของ Equals เมธอด ซึ่งตรวจสอบว่า Make คุณสมบัติ และ Model ของวัตถุปัจจุบัน Car มีค่าเท่ากับคุณสมบัติของ otherCar วัตถุหรือไม่

คุณสมบัติและตัวทําดัชนีของคลาสสามารถกําหนดตัวเข้าถึงพิเศษสําหรับคุณสมบัติหรือตัวทําดัชนีที่กําหนดไว้ในอินเทอร์เฟซ ตัวอย่างเช่น อินเทอร์เฟซอาจประกาศคุณสมบัติที่มี get Accessor คลาสที่ใช้อินเทอร์เฟซสามารถประกาศคุณสมบัติเดียวกันด้วยทั้ง get และ set ผู้เข้าถึง ตัวอย่างมีดังนี้:

public interface IExampleInterface
{
    string Name { get; }
}

public class ExampleClass : IExampleInterface
{
    public string Name { get; set; }
}

ใน IExampleInterface ตัวอย่างนี้ ประกาศคุณสมบัติ Name ที่มี get Accessor ExampleClass ใช้อินเทอร์เฟซและประกาศคุณสมบัติเดียวกันด้วยทั้ง get และ set accessor

การใช้อินเทอร์เฟซที่กําหนดโดยระบบทั่วไป

อินเทอร์เฟซทั่วไปที่กําหนดโดยระบบ เช่น IEnumerable, IDisposableและ IComparable มักใช้ในแอปพลิเคชัน .NET อินเทอร์เฟซเหล่านี้มีวิธีการมาตรฐานที่สามารถใช้ได้เพื่อให้แน่ใจว่ามีลักษณะการทํางานที่สอดคล้องกันในประเภทที่แตกต่างกัน

IEnumerable

อินเทอร์เฟซ IEnumerable ถูกใช้เพื่อกําหนดคอลเลกชันที่สามารถแจกแจงได้ ซึ่งประกอบด้วยวิธีการเดียว ซึ่ง GetEnumeratorส่งกลับตัวแจงนับที่ทําซ้ําผ่านคอลเลกชัน

public class MyCollection : IEnumerable
{
    private int[] _items = { 1, 2, 3, 4, 5 };

    public IEnumerator GetEnumerator()
    {
        for (int i = 0; i < _items.Length; i++)
        {
            yield return _items[i];
        }
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

IDisposable

อินเทอร์เฟซ IDisposable ถูกใช้เพื่อปล่อยทรัพยากรที่ไม่มีการจัดการ ทรัพยากรที่ไม่มีการจัดการคือทรัพยากรที่ไม่ได้จัดการด้วยรันไทม์ .NET เช่น ตัวจัดการไฟล์ การเชื่อมต่อเครือข่าย ฯลฯ สิ่งสําคัญคือต้องปล่อยทรัพยากรเหล่านี้หลังจากใช้เพื่อป้องกันการรั่วไหลของหน่วยความจําและปัญหาอื่น ๆ ซึ่งประกอบด้วยวิธีการ Disposeเดียว ซึ่งเรียกว่า แหล่งข้อมูลฟรี

public class ResourceHolder : IDisposable
{
    private bool _disposed = false;

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this); // Prevents the garbage collector from calling the finalizer if Dispose has already been called.
    }

    protected virtual void Dispose(bool disposing)
    {
        if (!_disposed)
        {
            if (disposing)
            {
                // Free managed resources
            }
            // Free unmanaged resources
            _disposed = true;
        }
    }

    ~ResourceHolder()
    {
        Dispose(false);
    }
}

ไม่สามารถเทียบได้

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

public class Person : IComparable
{
    public string Name { get; set; }
    public int Age { get; set; }

    public int CompareTo(Person other)
    {
        if (other == null) return 1; // If 'other' is null, this instance is considered greater
        return this.Age.CompareTo(other.Age); // Returns negative value if  precedes 'other', 0 if same position, or postive value if follows 'other'.
    }
}

ในตัวอย่างนี้ หาก other เป็น null เราจะส่งกลับค่า 1 ซึ่งแสดงว่าอินสแตนซ์ปัจจุบันถือว่ามากกว่าการอ้างอิง null

อินเทอร์เฟซที่ระบบกําหนดเองใน C# มีบทบาทสําคัญในการสร้างแอปพลิเคชันที่มีประสิทธิภาพ เสถียร และสม่ําเสมอ ซึ่งมีวิธีการมาตรฐานที่สามารถใช้ได้ในประเภทที่แตกต่างกันเพื่อให้มั่นใจถึงความสม่ําเสมอและความสามารถในการคาดการณ์ในพฤติกรรม ด้วยการทําความเข้าใจและใช้งานอินเทอร์เฟซเหล่านี้อย่างมีประสิทธิภาพ คุณสามารถใช้ฟังก์ชันที่กําหนดไว้ล่วงหน้าและลดปริมาณโค้ดที่ซ้ําซ้อน ทําให้แอปพลิเคชันของคุณบํารุงรักษาและมีประสิทธิภาพมากขึ้นได้