Interfaces

En C#, una interfaz es un tipo de referencia similar a una clase, pero define un contrato que las clases concretas deben seguir. Las interfaces proporcionan una forma de lograr la herencia múltiple, ya que una clase puede implementar varias interfaces. Aquí tienes una explicación detallada con ejemplos:

Definición de una interfaz:

// Definición de una interfaz
public interface IShape
{
    double GetArea(); // Método que debe ser implementado por las clases que implementen la interfaz.
}

Implementación de una interfaz en una clase:

// Clase que implementa la interfaz
public class Circle : IShape
{
    public double Radius { get; set; }

    // Implementación del método de la interfaz
    public double GetArea()
    {
        return Math.PI * Math.Pow(Radius, 2);
    }
}

Uso de la interfaz:

class Program
{
    static void Main()
    {
        // Crear una instancia de la clase Circle
        Circle circle = new Circle { Radius = 5 };

        // Utilizar la interfaz para llamar al método común
        Console.WriteLine($"Área del círculo: {circle.GetArea()}");
    }
}

Herencia de interfaces:

// Definir otra interfaz que herede de IShape
public interface IResizableShape : IShape
{
    void Resize(double factor);
}

Implementación de múltiples interfaces:

// Clase que implementa múltiples interfaces
public class ResizableCircle : IResizableShape
{
    public double Radius { get; set; }

    public double GetArea()
    {
        return Math.PI * Math.Pow(Radius, 2);
    }

    public void Resize(double factor)
    {
        Radius *= factor;
    }
}

Ejemplo de uso con herencia de interfaces:

class Program
{
    static void Main()
    {
        ResizableCircle resizableCircle = new ResizableCircle { Radius = 5 };

        Console.WriteLine($"Área antes de la redimensión: {resizableCircle.GetArea()}");

        resizableCircle.Resize(2);

        Console.WriteLine($"Área después de la redimensión: {resizableCircle.GetArea()}");
    }
}

Las interfaces en C# son una herramienta poderosa para definir contratos comunes entre clases sin imponer una jerarquía de herencia rígida. Estos ejemplos ilustran cómo las interfaces pueden ser utilizadas para lograr abstracción y polimorfismo en el código.

Aquí tienes un ejemplo que involucra una clase abstracta, dos interfaces y una clase derivada que implementa ambos interfaces:

using System;

// Definición de una interfaz
public interface IShape
{
    void DisplayShapeType();
}

// Otra interfaz
public interface IResizable
{
    void Resize(double factor);
}

// Definición de una clase abstracta
public abstract class Shape
{
    public abstract void Draw(); // Método abstracto que debe ser implementado por las clases derivadas.
}

// Clase que implementa la interfaz IShape y hereda de la clase abstracta Shape
public class Circle : Shape, IShape, IResizable
{
    public double Radius { get; set; }

    // Implementación del método abstracto de la clase Shape
    public override void Draw()
    {
        Console.WriteLine("Drawing a circle");
    }

    // Implementación del método de la interfaz IShape
    public void DisplayShapeType()
    {
        Console.WriteLine("This is a circle");
    }

    // Implementación del método de la interfaz IResizable
    public void Resize(double factor)
    {
        Radius *= factor;
        Console.WriteLine($"Circle resized. New radius: {Radius}");
    }
}

class Program
{
    static void Main()
    {
        // Crear una instancia de la clase Circle
        Circle circle = new Circle { Radius = 5 };

        // Llamar a métodos de la clase Circle
        circle.Draw();
        circle.DisplayShapeType();
        circle.Resize(2);
    }
}

En este ejemplo:

• Shape es una clase abstracta con un método abstracto Draw.

• IShape es una interfaz que define un método DisplayShapeType.

• IResizable es otra interfaz que define un método Resize.

• La clase Circle hereda de la clase abstracta Shape y también implementa las interfaces IShape e IResizable. Esto demuestra cómo una clase puede heredar de una clase abstracta y al mismo tiempo implementar múltiples interfaces.

La instancia de Circle puede acceder a los métodos de la clase abstracta y de ambas interfaces. Este ejemplo ilustra cómo se puede utilizar la herencia y la implementación de interfaces para crear clases más flexibles y reutilizables.