interfaces son el medio principal para desacoplar los usos de una clase de su implementación. Este desacoplamiento aporta flexibilidad para el mantenimiento de la implementación y ayuda a habilitar un comportamiento genérico y seguro en cuanto a tipos.
La sintaxis de una interfaz es similar a la de una clase o un struct, salvo que los métodos y las propiedades aparecen solo como la firma y no se proporciona un cuerpo.
public interface ILanguage
{
string Speak();
}
public interface IItalianLanguage : ILanguage
{
string Speak();
string SpeakItalian();
}
public interface IScriptConverter
{
string Version { get; set; }
string ConvertCyrillicToLatin(string cyrillic);
}
La clase o el struct que la implementa debe implementar todas las operaciones que define la interfaz.
Por lo general, las interfaces hacen una o más de las siguientes cosas:
IComparable<T>) opublic class ItalianTraveller : IItalianLanguage
{
public string Speak()
{
return "Ciao mondo";
}
public string SpeakItalian()
{
return Speak();
}
}
public class ItalianTravellerV2 : IItalianLanguage
{
public string Speak()
{
return "migliorata - Ciao mondo";
}
public string SpeakItalian()
{
return Speak();
}
}
public class FrenchTraveller : ILanguage
{
public string Speak()
{
return "Ça va?";
}
}
public class RussianTraveller : ILanguage, IScriptConverter
{
public string Version { get; set; } = "1.0";
public string Speak()
{
return "Привет мир";
}
public string ConvertCyrillicToLatin(string cyrillic)
{
throw new NotImplementedException();
}
}
public class DocumentTranslator : IScriptConverter
{
public string Version { get; set; } = "1.0";
public string Translate(string russian)
{
throw new NotImplementedException();
}
public string ConvertCyrillicToLatin(string cyrillic)
{
throw new NotImplementedException();
}
}
El código que usa las interfaces y las clases anteriores puede:
Las interfaces se usan mucho para facilitar las pruebas, ya que permiten simular objetos con facilidad.
Consulta este artículo para ver en detalle qué tipos de miembros puede incluir una interfaz.
Las interfaces pueden heredar de otras interfaces.
Los miembros de una interfaz son públicos de forma predeterminada.
Las interfaces pueden contener tipos anidados, como literales const, enums, delegates, classes y structs. Aquí, las interfaces actúan como espacios de nombres de la misma manera que lo hacen las clases y los structs, y el comportamiento y la sintaxis son idénticos.
Por diseño, C# no admite la herencia múltiple, pero facilita una especie de herencia múltiple a través de las interfaces.
Además, el concepto de que el polimorfismo se puede implementar a través de las interfaces es lo que sustenta el mecanismo de las interfaces.
A veces, dos interfaces distintas pueden compartir los nombres y las firmas de sus métodos. Para proporcionar una implementación distinta de estos métodos, C# ofrece la implementación explícita de interfaces. Ten en cuenta que, para usar una implementación concreta de una interfaz, debes convertir a esa interfaz la expresión que hace referencia al objeto. Puedes lograrlo con una asignación, una conversión de tipo o pasándolo como parámetro.
public interface IFoo
{
void X();
}
public interface IBar
{
void X();
}
public class Census : IFoo, IBar
{
void IFoo.X()
{
Console.Write("This is from Foo");
}
void IBar.X()
{
Console.Write("This is from Bar");
}
}
public class User
{
public void Use()
{
IFoo foo = new Census();
IBar bar = new Census();
foo.X();
// => "This is from Foo"
bar.X();
// => "This is from Bar"
}
}
Existen varios casos de uso:
IEnumerable.GetEnumerator() heredado, junto con IEnumerable<T>.GetEnuerator(). Puede que nunca uses esa interfaz, pero el compilador puede exigirla.IFormattable tiene un método ToString() que recibe un parámetro tipo de formato además de un parámetro de tipo IFormatProvider. Una clase como FormattableString de la Base Class Library (BCL) tiene la interfaz para garantizar que se pueda usar desde rutinas que aceptan un IFormattable, pero resulta más expresivo que su versión principal de ToString(IFormatProvider) omita el parámetro tipo de formato, ya que no se usa en la implementación y confundiría a quienes usan la API.La versión 8 de C# resuelve un problema molesto de las API. Si agregas métodos a una interfaz para mejorar la funcionalidad de las nuevas implementaciones, es necesario modificar todas las implementaciones existentes de la interfaz para que cumplan con el contrato de la API, aunque no tengan un comportamiento específico de implementación. Ahora C# permite incluir un método predeterminado como parte de la interfaz (a quienes programan en Java les resultará familiar). Antes, cuando ocurría un cambio así, existía una versión 2 de la interfaz junto con la original.
Este artículo es una excelente introducción a las interfaces y se centra en la implementación predeterminada y en otras innovaciones de apoyo, como los miembros static, private y virtual.