Aprender a usar interfaces en C# se vuelve mucho más claro cuando lo haces con un proyecto pequeño y visual. Aquí construimos un Logger desde cero para que entiendas cómo una misma interfaz puede comportarse de dos formas distintas, ideal si estás empezando con programación orientada a objetos en .NET.

¿Qué es una interfaz en C# y para qué sirve?

Una interfaz define un contrato: dice qué métodos debe tener una clase, pero no cómo implementarlos. Eso te permite escribir clases muy diferentes que comparten la misma forma de ser invocadas.

En este proyecto creamos una interfaz llamada ILogger con un único método Log, y luego dos clases que heredan de ella con comportamientos completamente distintos. Una escribe en la consola, la otra escribe en un archivo de texto. La firma es la misma, el resultado cambia.

¿Por qué las interfaces en C# se nombran con I al inicio? Es una convención del lenguaje para distinguirlas de las clases. Por ejemplo, ILogger indica de inmediato que es una interfaz, no una clase concreta.

¿Cómo crear el proyecto Logger paso a paso?

El punto de partida es crear una aplicación de consola nueva en .NET con el comando dotnet new console dentro de una carpeta llamada Logger [00:35]. Sobre ese esqueleto vamos a montar tres archivos clave: la interfaz y dos implementaciones.

¿Cómo se define la interfaz ILogger?

Dentro del proyecto creamos un archivo ILogger.cs con un solo método. Quedaría así:

csharp public interface ILogger { void Log(string mensaje); }

Es literalmente un método sin cuerpo. La interfaz no resuelve nada por sí misma, solo establece la regla: cualquiera que herede de ILogger tiene que implementar Log recibiendo un string [01:20].

¿Cómo implementar ConsoleLogger y FileLogger?

La primera clase, ConsoleLogger, hereda de ILogger y resuelve Log mostrando el mensaje en la terminal con Console.WriteLine. Es la versión más directa.

csharp public class ConsoleLogger : ILogger { public void Log(string mensaje) { Console.WriteLine(mensaje); } }

La segunda, FileLogger, también hereda de ILogger pero en lugar de imprimir, escribe el mensaje en un archivo de texto. Mismo método, comportamiento opuesto.

csharp public class FileLogger : ILogger { public void Log(string mensaje) { File.WriteAllText("Log.txt", mensaje); } }

Aquí está la idea poderosa: la interfaz se comunica con la consola en un caso y con el sistema de archivos en el otro. La firma no cambia, lo que cambia es el destino del mensaje [03:10].

¿Cómo usar las dos implementaciones desde Program.cs?

En Program.cs eliminamos el clásico "Hola mundo" e instanciamos cada clase para verlas en acción. Primero la versión de consola, luego la de archivo.

csharp ILogger consoleLogger = new ConsoleLogger(); consoleLogger.Log("Este es un mensaje de log en la consola");

ILogger fileLogger = new FileLogger(); fileLogger.Log("Este es un mensaje de log en un archivo");

Al correr dotnet run desde la terminal pasan dos cosas a la vez:

• En la consola aparece el mensaje Este es un mensaje de log en la consola.
• En la carpeta del proyecto se genera un archivo Log.txt con el segundo mensaje dentro.

¿Qué ventaja real da usar una interfaz aquí? Puedes intercambiar ConsoleLogger por FileLogger sin tocar el código que llama a Log. Esa flexibilidad es la base de patrones como inyección de dependencias.

¿Qué reto puedes hacer para practicar interfaces?

Una vez que tengas las dos clases funcionando, te propongo crear una tercera implementación llamada HybridLogger. La idea es que esa nueva clase también herede de ILogger y, al llamar Log, haga las dos cosas al mismo tiempo: mostrar el mensaje en la consola y guardarlo en el archivo de texto [05:40].

Es un ejercicio corto pero muy revelador. Te obliga a pensar cómo combinar comportamientos dentro de un mismo contrato y a sentir, en código, por qué las interfaces son tan útiles cuando un sistema crece.

Cuéntame en los comentarios qué otra implementación de ILogger se te ocurre: ¿una que envíe el mensaje a una base de datos, a una API o a un servicio en la nube?