Învață să folosești interfețele definite de sistem

Integrarea interfețelor definite de sistem în aplicațiile C# este utilă în multe scenarii practice de codificare. Interfețele definite de sistem în C#, vă permit să aplicați funcționalități predefinite, făcând aplicațiile unitare și stabile.

Interfețe comune utilizate în metode

Mai multe interfețe comune sunt utilizate frecvent în metodele C# din cadrul .NET framework. Aceste interfețe oferă funcționalități standard implementate de diferite clase.

• IComparable: Utilizat pentru compararea obiectelor.
• IEnumerable: Utilizat pentru iterarea în colecții.
• IDisposable: Utilizat pentru eliberarea resurselor negestionate.
• IEquatable: Utilizat pentru definirea comparațiilor de egalitate.

Implementarea interfețelor definite de sistem

Pentru a implementa un membru al interfeței definite de sistem, membrul corespunzător al clasei de implementare trebuie să fie public, nu staticși să aibă același nume și semnătură ca membrul interfeței. O clasă sau o structură care implementează o interfață trebuie să furnizeze o implementare pentru toți membrii declarați fără o implementare implicită furnizată de interfață.

Interfețele definite de sistem din .NET utilizează adesea un substituent T pentru a reprezenta orice tip. De exemplu, IEquatable interfața este definită în .NET framework după cum urmează:

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

Atunci când implementați această interfață într-o clasă, înlocuiți T cu tipul clasei.

De exemplu, următoarea Car clasă implementează IEquatable interfața:

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;
    }
}

În acest exemplu, Car înlocuiește T în IEquatable, făcându-l IEquatable. Clasa Car oferă propria implementare a metodei Equals , care verifică dacă Make și Model proprietățile obiectului curent Car sunt egale cu proprietățile obiectului otherCar .

Proprietățile și indexatoarele unei clase pot defini accesorii suplimentare pentru o proprietate sau un indexator definit într-o interfață. De exemplu, o interfață poate declara o proprietate care are un get accesoriu. Clasa care implementează interfața poate declara aceeași proprietate atât cu un accesoriu, cât și get cu un set accesoriu. Iată un exemplu:

public interface IExampleInterface
{
    string Name { get; }
}

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

În acest exemplu, IExampleInterface declară o proprietate Name cu un get accesoriu. ExampleClassimplementează interfața și declară aceeași proprietate atât cu un accesoriu, cât și get cu un set accesoriu.

Utilizarea interfețelor comune definite de sistem

Interfețele comune definite de sistem, cum IEnumerablear fi , IDisposableși IComparable sunt utilizate frecvent în aplicațiile .NET. Aceste interfețe oferă metode standard care pot fi implementate pentru a asigura un comportament unitar în diferite tipuri.

IEnumerable

Interfața IEnumerable este utilizată pentru a defini o colecție care poate fi enumerată. Conține o singură metodă, GetEnumeratorcare returnează un enumerator care iterează prin colecție.

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

Interfața IDisposable este utilizată pentru a elibera resurse negestionate. Resursele negestionate sunt resurse care nu sunt gestionate cu modulul runtime .NET, cum ar fi handle-uri de fișiere, conexiuni de rețea etc. Este important să eliberați aceste resurse după utilizare pentru a preveni pierderile de memorie și alte probleme. Conține o singură metodă, Disposecare se numește resurse gratuite.

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

Interfața IComparable este utilizată pentru a defini o metodă pentru compararea instanțelor unei clase. Conține o singură metodă, CompareTocare compară instanța curentă cu un alt obiect de același tip.

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'.
    }
}

În acest exemplu, dacă other este nul, returnăm 1, indicând faptul că instanța curentă este considerată mai mare decât o referință nulă.

Interfețele definite de sistem din C# joacă un rol esențial în crearea de aplicații eficiente, stabile și unitare. Ele oferă metode standard care pot fi implementate în diferite tipuri, asigurând uniformitatea și previzibilitatea în comportament. Prin înțelegerea și implementarea eficientă a acestor interfețe, puteți să utilizați funcționalități predefinite și să reduceți volumul de cod repetitiv, făcând aplicațiile mai întreținute și mai robuste.