Interfaces en C# con un proyecto Logger

Contenido del curso

Fundamentos

Tipos de Datos y Variables

Control de Flujo

Programación Orientada a Objetos

Interfaces y Arquitectura

Herramientas y Entorno de Desarrollo

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:006:14

Interfaces en C# con un proyecto Logger

Curso de Introducción a .NET con C#

Clase 19 de 25

Clase 19 / 25

Recursos

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?

Fundamentos

Por qué C# sigue dominando el desarrollo

C# vs .NET: no son lo mismo

Instalación de .NET 8 en Ubuntu con WSL

Crea y ejecuta tu primer proyecto .NET

Depurar .NET con F5 en VS Code

Tipos de Datos y Variables

Variables primitivas en C# con var y tipos

Const vs variable en C# cuándo usar cada una

Leer y escribir datos en consola con C#

Control de Flujo

Sentencia if y operadores lógicos en C#

for y while en C# sin errores

Ciclo foreach en C# para iterar caracteres y cadenas

Diferencia entre arreglos y listas en C#

Sentencia switch en C# con arreglos y listas

Métodos en C# con void y return

Programación Orientada a Objetos

Clases y namespaces en C# con Calculator

Métodos públicos y privados en clases de C#

Clases estáticas en C# sin instanciar objetos

Interfaces y Arquitectura

Qué son las interfaces en C#

Interfaces en C# con un proyecto Logger

Configuración de depuración en Visual Studio Code para múltiples proyectos

Herramientas y Entorno de Desarrollo

Visual Studio vs VS Code para .NET

Creación de archivos SLN en .NET con múltiples proyectos

Instalación y uso de paquetes NuGet en proyectos .NET

dotnet publish para ejecutables sin SDK

Comandos esenciales de la terminal de .NET

Interfaces en C# con un proyecto Logger