¿Qué son las interfaces en C#?

Question

Accepted Answer

Una **interfaz** define un **contrato** — un conjunto de miembros (métodos, propiedades) que las clases que la implementan deben proporcionar, sin implementación (tradicionalmente). Una clase puede implementar **múltiples** interfaces, lo que las hace clave para un diseño flexible, desacoplado y testeable en C#. ## Definir e implementar una interfaz ```csharp public interface IShape { double Area(); // a method signature (no body) string Name { get; } // a property } public class Circle : IShape // implement the interface { public double Radius { get; set; } public double Area() => Math.PI * Radius * Radius; // must implement public string Name => "Circle"; } ``` Una interfaz (nombrada `IXxx` por convención) declara miembros sin implementación; una clase que la implementa **debe** proporcionarlos. (Desde C# 8, las interfaces pueden tener implementaciones *por defecto*, pero el rol de contrato es primario.) ## Múltiples interfaces (vs herencia simple) ```csharp public class Widget : IDrawable, ISerializable, IComparable { // must implement ALL members of ALL interfaces } ``` Una clase puede implementar **muchas** interfaces (a diferencia de la herencia de clase única) — la forma de C# de compartir capacidades entre tipos no relacionados. ## Polimorfismo a través de interfaces (el beneficio clave) ```csharp // program to the INTERFACE — works with ANY implementation List shapes = new() { new Circle(), new Square() }; foreach (IShape s in shapes) Console.WriteLine(s.Area()); // calls each type's implementation void Process(IRepository repo) { } // depend on an interface, not a concrete class ``` ## Interfaces comunes de .NET y testabilidad ```csharp IEnumerable, IDisposable, IComparable, IEquatable // framework interfaces // interfaces enable mocking in tests (depend on an interface, inject a mock) public class Service(IEmailSender sender) { } // inject any IEmailSender (real or mock) ``` ## Por qué es importante Las interfaces son centrales para un buen diseño en C# y son fundamentales para cómo el framework .NET y las aplicaciones modernas de C# están estructuradas, por lo que entenderlas es esencial. Las interfaces definen **contratos** (qué puede hacer un tipo) sin implementación, y una clase puede implementar **múltiples** interfaces — convirtiéndolas en la herramienta principal de C# para un diseño flexible y desacoplado, y su respuesta a las limitaciones de herencia única (compartir capacidades entre tipos no relacionados). El beneficio más importante es habilitar **bajo acoplamiento y testabilidad**: al depender de interfaces en lugar de clases concretas ("programar para una interfaz"), el código se vuelve flexible (intercambiar implementaciones) y altamente **testeable** (inyectar implementaciones mock en pruebas — una razón importante por la que se enfatizan las interfaces, ya que hacen que la inyección de dependencias y las pruebas unitarias sean prácticas). Las interfaces también habilitan **polimorfismo** (tratar diferentes implementaciones uniformemente a través del tipo de interfaz). Entender las interfaces — definir contratos, implementar múltiples, programar para interfaces para desacoplamiento y testabilidad, y las interfaces comunes de .NET (`IEnumerable`, `IDisposable`, etc.) — es un conocimiento importante para diseñar aplicaciones C# mantenibles y testeables y para trabajar con el framework (que está construido alrededor de interfaces). Ya que las interfaces sustentan la inyección de dependencias, la testabilidad y la arquitectura flexible — todos los distintivos del C# profesional — y aparecen en todo .NET, dominarlas es un conocimiento central y frecuentemente aplicado que distingue un C# bien arquitecturado y testeable del código fuertemente acoplado, y es un tema común en entrevistas que refleja la comprensión de buenos principios de diseño.