Aprenda a usar interfaces definidas por el sistema

Completados

La integración de interfaces definidas por el sistema en aplicaciones de C# es útil en muchos escenarios prácticos de codificación. Las interfaces definidas por el sistema en C#, permiten aplicar funcionalidades predefinidas, lo que hace que las aplicaciones sean coherentes y estables.

Interfaces comunes usadas en métodos

Varias interfaces comunes se usan con frecuencia en métodos de C# en .NET Framework. Estas interfaces proporcionan funcionalidades estándar implementadas por varias clases.

  • IComparable: se usa para comparar objetos.
  • IEnumerable: Se utiliza para iterar sobre colecciones.
  • IDisposable: se usa para liberar recursos no administrados.
  • IEquatable: se usa para definir comparaciones de igualdad.

Implementación de interfaces definidas por el sistema

Para implementar un miembro de interfaz definido por el sistema, el miembro correspondiente de la clase de implementación debe ser público, no static, y tener el mismo nombre y firma que el miembro de interfaz. Una clase o estructura que implementa una interfaz debe proporcionar una implementación para todos los miembros declarados sin una implementación predeterminada proporcionada por la interfaz.

Las interfaces definidas por el sistema en .NET suelen usar un marcador de posición T para representar cualquier tipo. Por ejemplo, la IEquatable interfaz se define en .NET Framework de la siguiente manera:

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

Al implementar esta interfaz en una clase, reemplace T por el tipo de la clase .

Por ejemplo, la siguiente Car clase implementa la IEquatable interfaz :

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

En este ejemplo, Car reemplaza T en IEquatable, por lo que es IEquatable. La Car clase proporciona su propia implementación del Equals método , que comprueba si las Make propiedades y Model del objeto actual Car son iguales a las propiedades del otherCar objeto .

Las propiedades y los indexadores de una clase pueden definir descriptores de acceso adicionales para una propiedad o indexador definido en una interfaz. Por ejemplo, una interfaz podría declarar una propiedad que tiene un get accesor. La clase que implementa la interfaz puede declarar la misma propiedad con un descriptor de acceso get y set. Este es un ejemplo:

public interface IExampleInterface
{
    string Name { get; }
}

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

En este ejemplo, IExampleInterface declara una propiedad Name con un get descriptor de acceso. ExampleClass implementa la interfaz y declara la misma propiedad con un descriptor de acceso get y set.

Uso de interfaces comunes definidas por el sistema

Las interfaces comunes definidas por el sistema como IEnumerable, IDisposabley IComparable se usan con frecuencia en aplicaciones .NET. Estas interfaces proporcionan métodos estándar que se pueden implementar para garantizar un comportamiento coherente entre distintos tipos.

IEnumerable

La IEnumerable interfaz se usa para definir una colección que se puede enumerar. Contiene un único método, , GetEnumeratorque devuelve un enumerador que recorre en iteración la colección.

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

La IDisposable interfaz se usa para liberar recursos no administrados. Los recursos no administrados son recursos que no se administran con el entorno de ejecución de .NET, como identificadores de archivos, conexiones de red, etc. Es importante liberar estos recursos después de usarlos para evitar pérdidas de memoria y otros problemas. Contiene un único método, , Disposeal que se llama 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

La IComparable interfaz se usa para definir un método para comparar instancias de una clase. Contiene un único método, , CompareToque compara la instancia actual con otro objeto del mismo 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'.
    }
}

En este ejemplo, si other es null, se devuelve 1, lo que indica que la instancia actual se considera mayor que una referencia nula.

Las interfaces definidas por el sistema en C# desempeñan un papel fundamental en la creación de aplicaciones eficaces, estables y coherentes. Proporcionan métodos estándar que se pueden implementar en diferentes tipos, lo que garantiza la uniformidad y la previsibilidad en el comportamiento. Al comprender e implementar eficazmente estas interfaces, puede usar funcionalidades predefinidas y reducir la cantidad de código repetitivo, lo que hace que las aplicaciones sean más fáciles de mantener y sólidas.