Aprenda a usar interfaces definidas pelo sistema

Concluído

A integração de interfaces definidas pelo sistema em aplicativos C# é útil em muitos cenários práticos de codificação. Interfaces definidas pelo sistema em C#, permitem que você aplique funcionalidades predefinidas, tornando seus aplicativos consistentes e estáveis.

Interfaces comuns utilizadas em métodos

Várias interfaces comuns são freqüentemente usadas em métodos C# dentro do .NET framework. Estas interfaces fornecem funcionalidades padrão implementadas por várias classes.

• IComparable: Usado para comparar objetos.
• IEnumerable: Usado para iterar sobre coleções.
• IDisposable: Usado para liberar recursos não gerenciados.
• IEquatable: Utilizado para definir comparações de igualdade.

Implementar interfaces definidas pelo sistema

Para implementar um membro da interface definido pelo sistema, o membro correspondente da classe de implementação deve ser público, não static, e ter o mesmo nome e assinatura que o membro da interface. Uma classe ou struct que implementa uma interface deve fornecer uma implementação para todos os membros declarados sem uma implementação padrão fornecida pela interface.

As interfaces definidas pelo sistema no .NET geralmente usam um placeholder T para representar qualquer tipo. Por exemplo, a IEquatable interface é definida no .NET framework da seguinte maneira:

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

Quando você implementa essa interface em uma classe, você substitui T pelo tipo da classe.

Por exemplo, a seguinte Car classe implementa a IEquatable interface:

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

Neste exemplo, Car substitui T em IEquatable, tornando-o IEquatable. A Car classe fornece sua própria implementação do Equals método, que verifica se as Make propriedades e Model do objeto atual Car são iguais às propriedades do otherCar objeto.

Propriedades e indexadores de uma classe podem definir acessadores extras para uma propriedade ou indexador definido em uma interface. Por exemplo, uma interface pode declarar uma propriedade que tem um get acessador. A classe que implementa a interface pode declarar a mesma propriedade com ambos os acessores get e set. Aqui está um exemplo:

public interface IExampleInterface
{
    string Name { get; }
}

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

Neste exemplo, IExampleInterface declara uma propriedade Name com um get acessador. ExampleClass implementa a interface e declara a mesma propriedade com os acessores get e set.

Utilização de interfaces comuns definidas pelo sistema

Interfaces comuns definidas pelo sistema, como IEnumerable, IDisposablee IComparable são frequentemente usadas em aplicativos .NET. Essas interfaces fornecem métodos padrão que podem ser implementados para garantir um comportamento consistente em diferentes tipos.

IEnumerável

A IEnumerable interface é usada para definir uma coleção que pode ser enumerada. Ele contém um único método, GetEnumerator, que retorna um enumerador que itera através da coleção.

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

A IDisposable interface é usada para liberar recursos não gerenciados. Recursos não gerenciados são recursos que não são manipulados com o tempo de execução do .NET, como identificadores de arquivo, conexões de rede, etc. É importante liberar esses recursos após o uso para evitar vazamentos de memória e outros problemas. Ele contém um único método, Dispose, que é chamado para liberar recursos.

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

A IComparable interface é usada para definir um método para comparar instâncias de uma classe. Ele contém um único método, CompareTo, que compara a instância atual com outro objeto do mesmo tipo.

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

Neste exemplo, se other for null, retornamos 1, indicando que a instância atual é considerada maior do que uma referência nula.

As interfaces definidas pelo sistema em C# desempenham um papel crucial na criação de aplicativos eficientes, estáveis e consistentes. Eles fornecem métodos padrão que podem ser implementados em diferentes tipos, garantindo uniformidade e previsibilidade no comportamento. Ao entender e implementar efetivamente essas interfaces, você pode usar funcionalidades predefinidas e reduzir a quantidade de código repetitivo, tornando seus aplicativos mais fáceis de manter e robustos.