O que são interfaces em C#?

Question

Accepted Answer

Uma **interface** define um **contrato** — um conjunto de membros (métodos, propriedades) que as classes implementadoras devem fornecer, sem implementação (tradicionalmente). Uma classe pode implementar **múltiplas** interfaces, tornando-as fundamentais para design flexível, desacoplado e testável em C#. ## Definindo e implementando uma interface ```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"; } ``` Uma interface (nomeada `IXxx` por convenção) declara membros sem implementação; uma classe que a implementa **deve** fornecê-los. (Desde C# 8, interfaces podem ter implementações *padrão*, mas o papel de contrato é primário.) ## Múltiplas interfaces (vs herança única) ```csharp public class Widget : IDrawable, ISerializable, IComparable { // must implement ALL members of ALL interfaces } ``` Uma classe pode implementar **muitas** interfaces (diferentemente da herança de classe única) — a forma de C# compartilhar capacidades entre tipos não relacionados. ## Polimorfismo através de interfaces (o benefício-chave) ```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 .NET comuns e testabilidade ```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 que isso importa Interfaces são centrais para um bom design em C# e são fundamentais para como o framework .NET e aplicações modernas em C# são estruturadas, portanto compreendê-las é essencial. Interfaces definem **contratos** (o que um tipo pode fazer) sem implementação, e uma classe pode implementar **múltiplas** interfaces — tornando-as a ferramenta principal de C# para design flexível e desacoplado e sua resposta às limitações de herança única (compartilhando capacidades entre tipos não relacionados). O benefício mais importante é permitir **acoplamento frouxo e testabilidade**: ao depender de interfaces em vez de classes concretas ("programa para uma interface"), o código fica flexível (trocar implementações) e altamente **testável** (injetar implementações mock em testes — uma razão importante pela qual interfaces são enfatizadas, pois tornam injeção de dependência e testes unitários práticos). Interfaces também possibilitam **polimorfismo** (tratar diferentes implementações uniformemente através do tipo de interface). Compreender interfaces — definir contratos, implementar múltiplas, programar para interfaces para desacoplamento e testabilidade, e as interfaces .NET comuns (`IEnumerable`, `IDisposable`, etc.) — é conhecimento importante para projetar aplicações C# mantíveis e testáveis e para trabalhar com o framework (que é construído em torno de interfaces). Como interfaces sustentam injeção de dependência, testabilidade e arquitetura flexível — todas características de C# profissional — e aparecem em todo o .NET, dominá-las é conhecimento essencial e frequentemente aplicado que distingue C# bem-arquitetado e testável de código acoplado, e um tópico comum em entrevistas refletindo compreensão de bons princípios de design.