Interfaces (introducción) e implementación de varias interfaces
Defina interfaces como contratos, implemente varias interfaces en una clase, use polimorfismo basado en interfaces y aprenda los conceptos básicos de la implementación explícita de interfaces.
Interfaces (introducción) e implementación de varias interfaces es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 2 de 3. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C# Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C# Academy incluye 3 lecciones en total.
Descripción general de las interfaces
Objetivo: programar usando interfaces para obtener código flexible.
- Las interfaces declaran qué, no cómo
- Implemente múltiples interfaces
- Pase interfaces a las funciones
- Use la implementación explícita para resolver conflictos de nombres
Implementación de múltiples interfaces
Las interfaces definen un contrato. Una clase puede implementar múltiples interfaces para expresar roles diferentes.
using System;
public interface IPlayable
{
void Play();
}
public interface IHasDuration
{
int DurationSeconds { get; }
}
public class Song : IPlayable, IHasDuration
{
private readonly string _title;
private readonly int _seconds;
public Song(string title, int seconds)
{
_title = title;
_seconds = seconds;
}
public int DurationSeconds { get { return _seconds; } }
public void Play()
{
Console.WriteLine("Playing " + _title + " (" + _seconds + "s)");
}
}
public class Program
{
public static void Main(string[] args)
{
Song s = new Song("Hello", 5);
s.Play();
Console.WriteLine("Duration = " + s.DurationSeconds);
}
}
Polimorfismo de interfaces
Acepte un tipo interface en los métodos. Los llamadores pueden pasar cualquier implementación.
using System;
public interface IPrintable
{
void Print();
}
public class Report : IPrintable
{
private readonly string _text;
public Report(string text) { _text = text; }
public void Print() { Console.WriteLine("Report: " + _text); }
}
public class Label : IPrintable
{
private readonly string _text;
public Label(string text) { _text = text; }
public void Print() { Console.WriteLine("Label: " + _text); }
}
public class Program
{
// Works with any IPrintable (polymorphism)
static void PrintAll(IPrintable item)
{
item.Print();
}
public static void Main(string[] args)
{
PrintAll(new Report("Sales Q1"));
PrintAll(new Label("Fragile"));
}
}
Implementación explícita
La implementación explícita desambigua los miembros con el mismo nombre y los oculta de la superficie de la clase.
using System;
public interface ILogger { void Write(string msg); }
public interface IFileWriter { void Write(string msg); }
public class DualWriter : ILogger, IFileWriter
{
// Explicit implementations: only visible via the interface reference
void ILogger.Write(string msg) { Console.WriteLine("[LOG] " + msg); }
void IFileWriter.Write(string msg) { Console.WriteLine("[FILE] " + msg); }
public void Demo()
{
Console.WriteLine("DualWriter ready");
}
}
public class Program
{
public static void Main(string[] args)
{
DualWriter dw = new DualWriter();
dw.Demo();
ILogger log = dw;
IFileWriter file = dw;
log.Write("started");
file.Write("saved");
}
}
Colecciones de interfaces
Almacene distintas implementaciones en una lista del tipo de interfaz e itérelas de manera uniforme.
using System;
using System.Collections.Generic;
public interface ITask
{
void Run();
}
public class EmailTask : ITask
{
public void Run() { Console.WriteLine("Send email"); }
}
public class BackupTask : ITask
{
public void Run() { Console.WriteLine("Run backup"); }
}
public class Program
{
public static void Main(string[] args)
{
List<ITask> tasks = new List<ITask>();
tasks.Add(new EmailTask());
tasks.Add(new BackupTask());
foreach (ITask t in tasks)
{
t.Run(); // calls the right implementation
}
}
}
Consejos sobre interfaces
Consejos:
- Prefiera interfaces pequeñas que describan un solo rol.
- Use interfaces para las pruebas (intercambie implementaciones).
- En C# 6, las interfaces no tienen campos ni cuerpos de métodos.
- Implemente múltiples interfaces para combinar comportamientos.
Concepto de las interfaces
Repaso
Repaso: las interfaces son contratos y admiten que cada clase implemente múltiples interfaces. Pase interfaces a las funciones, manténgalas pequeñas y use la implementación explícita para resolver conflictos.
Preguntas frecuentes
¿La lección «Interfaces (introducción) e implementación de varias interfaces» es gratis?
Sí — el texto completo de «Interfaces (introducción) e implementación de varias interfaces» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C# Academy, actualiza a CoddyKit PRO. El curso de C# Academy incluye 3 lecciones en total.
¿Qué aprenderé en «Interfaces (introducción) e implementación de varias interfaces»?
Defina interfaces como contratos, implemente varias interfaces en una clase, use polimorfismo basado en interfaces y aprenda los conceptos básicos de la implementación explícita de interfaces. Practicas C# Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar C# Academy?
No se requiere experiencia previa. C# Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 3.
¿Cuánto tiempo toma la lección «Interfaces (introducción) e implementación de varias interfaces»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de C# Academy?
Sí. Cada lección de C# Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- virtual/override/sealed y clases abstractas
- Interfaces (introducción) e implementación de varias interfaces
- Polimorfismo y distribución dinámica