Naučte se používat rozhraní definovaná systémem.

Integrace systémových rozhraní definovaných do aplikací jazyka C# je užitečná v mnoha praktických scénářích kódování. Systémově definovaná rozhraní v jazyce C# umožňují použít předdefinované funkce a zajistit tak konzistentní a stabilní aplikace.

Běžná rozhraní používaná v metodách

V metodách jazyka C# v rozhraní .NET Framework se často používá několik běžných rozhraní. Tato rozhraní poskytují standardní funkce implementované různými třídami.

• IComparable: Používá se pro porovnávání objektů.
• IEnumerable: Slouží k iterování kolekcí.
• IDisposable: Používá se pro uvolňování nespravovaných prostředků.
• IEquatable: Slouží k definování porovnání rovnosti.

Implementace rozhraní definovaných systémem

Aby bylo možné implementovat člen rozhraní definovaný systémem, musí být odpovídající člen implementované třídy veřejný, nikoli statica mít stejný název a podpis jako člen rozhraní. Třída nebo struktura, která implementuje rozhraní musí poskytnout implementaci pro všechny deklarované členy bez výchozí implementace poskytované rozhraním.

Rozhraní definovaná systémem v .NET často používají zástupný symbol T pro reprezentaci libovolného typu. Rozhraní je například IEquatable definováno v rozhraní .NET Framework následujícím způsobem:

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

Při implementaci tohoto rozhraní ve třídě nahradíte T typem třídy.

Například následující Car třída implementuje IEquatable rozhraní:

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

V tomto příkladu Car nahrazuje T v IEquatable, čímž se z něj stane IEquatable. Car Třída poskytuje vlastní implementaci Equals metody, která kontroluje, zda Make a Model vlastnosti aktuálního Car objektu jsou rovny vlastnostem objektuotherCar.

Vlastnosti a indexery třídy mohou definovat další přístupové objekty pro vlastnost nebo indexer definovaný v rozhraní. Rozhraní může například deklarovat vlastnost, která má přístupový člen get. Třída, která implementuje rozhraní, může deklarovat stejnou vlastnost s oběma přístupovými metodami: get a set. Tady je příklad:

public interface IExampleInterface
{
    string Name { get; }
}

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

V tomto příkladu IExampleInterface deklaruje vlastnost Name s příslušenstvím get . ExampleClass implementuje rozhraní a deklaruje stejnou vlastnost jak s přístupovým objektem get, tak i se set přístupovým objektem.

Použití běžných rozhraní definovaných systémem

Běžná systémově definovaná rozhraní, například IEnumerable, IDisposablea IComparable často se používají v aplikacích .NET. Tato rozhraní poskytují standardní metody, které je možné implementovat, aby se zajistilo konzistentní chování napříč různými typy.

IEnumerable

Rozhraní IEnumerable slouží k definování kolekce, která se dá vyčíslit. Obsahuje jednu metodu, GetEnumeratorkterá vrací výčet, který iteruje prostřednictvím kolekce.

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

Rozhraní IDisposable se používá k uvolnění nespravovaných prostředků. Nespravované prostředky jsou prostředky, které nejsou zpracovávány pomocí modulu runtime .NET, jako jsou popisovače souborů, síťová připojení atd. Tyto prostředky je důležité po použití uvolnit, aby se zabránilo nevracení paměti a dalším problémům. Obsahuje jednu metodu, Dispose, která se volá pro uvolnění prostředků.

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

Rozhraní IComparable slouží k definování metody pro porovnávání instancí třídy. Obsahuje jednu metodu, CompareTokterá porovnává aktuální instanci s jiným objektem stejného typu.

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

V tomto příkladu, pokud other je null, vrátíme hodnotu 1, což znamená, že aktuální instance je považována za větší než odkaz null.

Systémově definovaná rozhraní v jazyce C# hrají zásadní roli při vytváření efektivních, stabilních a konzistentních aplikací. Poskytují standardní metody, které lze implementovat napříč různými typy a zajišťují jednotnost a předvídatelnost chování. Díky pochopení a efektivní implementaci těchto rozhraní můžete použít předdefinované funkce a snížit množství opakujícího se kódu, aby vaše aplikace byly lépe udržovatelné a robustnější.