Fundamentos de C# y

POO

Ing. Francisco Miguel Ruiz Hidalgo MSc.

Interfaces
• Hasta ahora cuando le pasamos un tipo de dato a un método hemos
estado pasando tipos concretos eso significa que dicho método le debemos
pasar una instancia especifica de ese tipo.
• Por ejemplo el método: public void CambiarNombre(Persona persona)
{
persona.Nombre = "Nombre cambiado";
}

• El método CambiarNombre acepta como parámetro un objeto de tipo

Persona.
• Para algunos casos esto es lo que exactamente deseamos.
• Sin embargo para ciertos casos esto va a ser una limitación.
Interfaces
• C# nos da la posibilidad de codificar contra una abstracción o
generalización en vez de contra un tipo concreto, una manera de hacer
esto es utilizando interfaces.
• Las interfaces son un mecanismo que nos permite definir una serie de
signaturas, de métodos las cuales nuestra clase se compromete
implementar. Una manera de ver las interfaces es como un contrato el cual
cada clase que implemente la interfaz debe de cumplir.
• Por ejemplo:
• Crear un proyecto, nombre Interface.sln
• Click derecho sobre la solución Interface, Agregar clase, nombre de la clase
IRepositorioPersona.cs
Interfaces
• Borrar el contenido que se crea dentro del namespace Interface.
• Para declarar una interface seria public interface a continuación el nombre
de la interfaz, en C# por convención las interfaces empiezan con “I”,
entonces nuestra declaración quedaría public interface
IRepositorioPersonas{}
• En el cuerpo de la interfaz se coloca las signaturas de los métodos los
cuales las clases que utilicen esta interfaz deben de implementar.
• Ahora vamos añadir el método void ObtenerPersonas();
• Lo que estamos diciendo es que cualquier clase que implemente la
interface IRepositorioPersonas debe tener un método que sea void de
nombre ObtenerPersonas y que no tenga ningún parámetro de entrada.
Interfaces
• Entonces como podemos hacer que una clase implemente una Interfaz.
• Para el ejemplo y por comodidad lo vamos hacer en IRepositorioPersona.cs
debajo de public interface IRepositorioPersonas pero normalmente cada
clase va en su propio archivo.
• Declaramos una clase, public class RepositorioPersonasBD, BD es base de
datos y para implementar la interfaz escribimos : IRepositorioPersonas,
tendremos un error porque nuestra clase no esta implementando el
miembro de la interfaz obtener personas.
• Una manera rápida de hacer que una clase implemente todos los métodos
de una interfaz es presionar Ctrl + punto sobre el error, nos mostrara un
cuadro de opciones y debemos seleccionar implementar interfaz, con esto
se crearan todos los métodos faltantes de la interfaz.
Interfaces
public class RepositorioPersonasBD : IRepositorioPersonas
{
public void ObtenerPersonas()
• Por lo tanto quedaría: {
Console.WriteLine("Obteniendo personas de la base de datos");
}
}

• Una clase puede implementar varias interfaces, lo que tenemos que

hacer es separar por comas, entonces al final de IRepositorioPersonas
añadir coma y nombrar la interfaz
public class RepositorioPersonasBD : IRepositorioPersonas, IDisposable

• Idisposable es una interfaz que utilizamos cuando queremos liberar

recursos de una clase, presionando Ctrl + punto implementamos el
método Dispose, es el método que IDisposable nos exige
implementar.
Interfaces
public class RepositorioPersonasBD : IRepositorioPersonas, IDisposable
{
public void Dispose()
• Tendríamos: {
throw new NotImplementedException();
}

public void ObtenerPersonas()

{
Console.WriteLine("Obteniendo personas de la base de datos");
}
}

• Además de que una clase puede implementar varias interfaces una

misma interfaz puede ser implementada por varias clases, siendo la
funcionalidad de las interfaces que varias clases la implementen para
así poder programar contra una interfaz o una abstracción y no contra
un tipo concreto.
Interfaces
• Por ejemplo, vamos a crear una nueva clase, la llamaremos
RepositorioPersonasEnMemoria, esta implementara la interfaz
IRepositorioPersonas y también implementamos la interfaz, y
colocaremos un mensaje en consola “Obteniendo personas de la
memoria”
public class RepositorioPersonasEnMemoria : IRepositorioPersonas
{
public void Obtener Personas()
{
Console.WriteLine("Obteniendo personas de la memoria");
}
}
Interfaces
• En el archivo Program.cs, crear un nuevo método, va a recibir un
IRepositorioPersona como parámetro de entrada, nos fijamos que
tendremos el método ObtenerPersonas porque este es el método que
tenemos declarado en nuestra interfaz, esto significa que cualquier
clase que implemente la interfaz y repositorio personas puede ser el
parámetro de entrada del método procesar el repositorio.
public static void ProcesarRepositorio(IRepositorioPersonas repositorio)
{
repositorio.ObtenerPersonas();
}
Interfaces
• Ahora en static void Main, escribimos ProcesarRepositorio y le pasamos
nuestra clase RespositorioPersonasBD, le estamos pasando una instancia
de la clase y podemos hacer lo mismo con RepositorioPersonasEnMemoria,
nos fijamos que no tenemos ningún error.
static void Main(string[] args)
{
ProcesarRepositorio(new RepositorioPersonasBD());
ProcesarRepositorio(new RepositorioPersonasEnMemoria());

}
• Nuestro método es mas versátil ahora.
• Cuando programamos con una abstracción ganamos mucha flexibilidad.
• Ahora ejecutar, presionar Ctrl + F5
Interfaces
• En consola tenemos:

• Esto que tenemos acá donde recibimos una abstracción o

generalización.public static void ProcesarRepositorio(IRepositorioPersonas repositorio)
{
repositorio.ObtenerPersonas();
}

• Y en tiempo de ejecución podemos enviar tipos concretos como:

RepositorioPersonasBD ó RepositorioPersonasEnMemoria, a esto
llamamos Polimorfismo.
Interfaces
• No estamos limitados a utilizar interfaces como valores de entrada también
podemos utilizarlas como valores de salida.
• Por ejemplo: crear un tipo enumeración (enum TipoRepositorio), y los
miembros serian: Memoria = 1 y BD = 2 enum TipoRepositorio {Memoria = 1, BD = 2}

• Ahora crearemos un método estático IRepositorioPersonas tipo de dato de

salida, nombre del método ObtenerRepositorio y como parámetro de
entrada TipoRepositorio que es enum que acabamos de crear. En el
método vamos a crear un Switch(tipoRepositorio)
static IRepositorioPersonas ObtenerRepositorio(TipoRepositorio tipoRepositorio)
{
switch (tipoRepositorio)
{
case TipoRepositorio.Memoria:
return new RepositorioPersonasEnMemoria();
case TipoRepositorio.BD:
return new RepositorioPersonasBD();
default:
throw new NotImplementedException();

}
}
Interfaces
• Ahora en static void Main,
• Primero comentar las 2 líneas de código.
• A continuación crear una variable de nombre repositorio, lo que queremos
es una instancia de la clase TipoRepositorio personas en Memoria y lo que
recibimos que es de tipo IRepositorioPersonas le vamos a mandar al
método procesar repositorio parametro respositorio.
• Finalmente Ejecutar Ctrl +F5 static void Main(string[] args)
{
var respositorio = ObtenerRepositorio(TipoRepositorio.Memoria);
ProcesarRepositorio(respositorio);
//ProcesarRepositorio(new RepositorioPersonasBD());
//ProcesarRepositorio(new RepositorioPersonasEnMemoria());

}
Interfaces
• El resultado en consola es:

• En general las interfaces hacen que nuestro código sea mas versátil y
reutilizable.
• Las interfaces son un concepto fundamental en técnicas de diseño
orientado a objetos por lo tanto es importante que entendamos su uso
básico.