Interface de C# (Interface)

En el mundo humano, los contratos entre dos o más personas imponen obligaciones para que actúen de acuerdo con el contrato. Del mismo modo, una interfaz incluye declaraciones de funciones relacionadas. La entidad que implementa la interfaz debe proporcionar la implementación de las funciones declaradas.

En C#, se puede definir una interfaz utilizando la palabra clave interface. Una interfaz puede contener declaraciones de métodos, propiedades, índices y eventos. Sin embargo, no puede contener campos ni propiedades implementadas automáticamente.

Las siguientes declaraciones de interfaz definen algunas funciones básicas de manipulación de archivos.

interface　IFile
{
　　　　void　ReadFile();
　　　　void WriteFile(string text);
}

No puedes aplicar un modificador de acceso a un miembro de interfaz. Por defecto, todos los miembros son públicos. Si se utiliza un modificador de acceso en una interfaz, el compilador de C# emitirá un error de tiempo de compilación: ‘El modificador ‘public’/private/‘protected’ no es válido para este elemento. (Visual Studio mostrará un error inmediatamente sin realizar la compilación).

interface　IFile
{
　　　　protected void ReadFile();　//Error de compilación
　　　　private void WriteFile(string text);//Error de compilación
}

La interfaz solo puede contener declaraciones y no implementaciones. Esto generará un error en tiempo de compilación.

interface　IFile
{
　　　　void　ReadFile();
　　　　void WriteFile(string text){
　　　　　　　　Console.Write(text);　　//Error: No se puede implementar el método
　　　　}
}

Una clase o una Struct puede implementar una o más interfaces utilizando dos puntos ( 　

Sintaxis:

<Class or Struct Name> : <Interface Name>

Por ejemplo, la clase siguiente implementa implícitamente la interfaz IFile.

interface　IFile
{
　　　　void　ReadFile();
　　　　void WriteFile(string text);
}
class FileInfo : IFile
{
　　　　public void ReadFile()
　　　　{
　　　　　　　　Console.WriteLine("Reading File");
　　　　}
　　　　public void WriteFile(string text)
　　　　{
　　　　　　　　Console.WriteLine("Escribiendo en archivo");
　　　　}
}

En el ejemplo anterior, la clase FileInfo implementó la interfaz IFile. Utiliza el modificador de acceso public para definir todos los miembros de la interfaz IFile. La clase FileInfo también puede contener miembros adicionales fuera de los miembros de la interfaz.

Los miembros de la interfaz deben implementarse utilizando el modificador de acceso public; de lo contrario, el compilador generará un error en tiempo de compilación.

Puede crear un objeto de la clase y asignarlo a una variable de tipo interfaz, como se muestra a continuación.

public　class　Program
{
　　　　public　static　void　Main()
　　　　{
　　　　　　　　IFile　file1　=　new　FileInfo();
　　　　　　　　FileInfo　file2　=　new　FileInfo();
　　　　　　　　file1.ReadFile();　
　　　　　　　　file1.WriteFile("content");　
　　　　　　　　file2.ReadFile();　
　　　　　　　　file2.WriteFile("content");　
　　　　}
}

En el ejemplo anterior, creamos un objeto de la clase FileInfo y lo asignamos a una variable de tipo IFile y a una variable de tipo FileInfo. Cuando se realiza la implementación implícita de la interfaz, puede usar la variable de tipo IFile y la variable de tipo FileInfo para acceder a los miembros de IFile.

Implementación explícita

Una interfaz puede usar <InterfaceName>.<MemberName> para implementar explícitamente. Cuando una clase está implementando múltiples interfaces, la implementación explícita es útil; por lo tanto, es más fácil de leer y elimina la confusión. También es útil si la interfaz tiene nombres de métodos idénticos.

No mezcle public Se utiliza el modificador de acceso junto con la implementación explícita. Esto generará un error en tiempo de compilación.

interface　IFile
{
　　　　void　ReadFile();
　　　　void WriteFile(string text);
}
　　　　
class FileInfo : IFile
{
　　　　void　IFile.ReadFile()
　　　　{
　　　　　　　　Console.WriteLine("Reading File");
　　　　}
　　　　void IFile.WriteFile(string text)
　　　　{
　　　　　　　　Console.WriteLine("Escribiendo en archivo");
　　　　}
}

Al implementar explícitamente una interfaz, solo se puede acceder a los miembros de la interfaz a través de instancias de tipo de interfaz.

interface　IFile
{
　　　　void　ReadFile();
　　　　void WriteFile(string text);
}
class FileInfo : IFile
{
　　　　void　IFile.ReadFile()
　　　　{
　　　　　　　　Console.WriteLine("Reading File");
　　　　}
　　　　void IFile.WriteFile(string text)
　　　　{
　　　　　　　　Console.WriteLine("Escribiendo en archivo");
　　　　}
　　　　public　void　Search(string　text)
　　　　{
　　　　　　　　Console.WriteLine("Búsqueda en archivo");
　　　　}
}
public　class　Program
{
　　　　public　static　void　Main()
　　　　{
　　　　　　　　IFile　file1　=　new　FileInfo();
　　　　　　　　FileInfo　file2　=　new　FileInfo();
　　　　　　　　file1.ReadFile();　
　　　　　　　　file1.WriteFile("content");　
　　　　　　　　//file1.Search("text　to　be　searched")//Error de compilación　
　　　　　　　　
　　　　　　　　file2.Search("text　to　be　searched");
　　　　　　　　//file2.ReadFile();　//Error de compilación　
　　　　　　　　//file2.WriteFile("content");　//Error de compilación　
　　　　}
}

En el ejemplo anterior, file1Los objetos solo pueden acceder a los miembros IFile y file2Sólo se puede acceder a los miembros de la clase FileInfo. Esta es la limitación de la implementación explícita.

Implementación de múltiples interfaces

Una clase o estructura puede implementar múltiples interfaces. Debe proporcionar la implementación de todos los miembros de todas las interfaces.

interface　IFile
{
　　　　void　ReadFile();
}
interface　IBinaryFile
{
　　　　void　OpenBinaryFile();
　　　　void　ReadFile();
}
class　FileInfo　:　IFile,　IBinaryFile
{
　　　　void　IFile.ReadFile()
　　　　{
　　　　　　　　Console.WriteLine("Leyendo archivo de texto");
　　　　}
　　　　void　IBinaryFile.OpenBinaryFile()
　　　　{
　　　　　　　　Console.WriteLine("Abriendo archivo binario");
　　　　}
　　　　void　IBinaryFile.ReadFile()
　　　　{
　　　　　　　　Console.WriteLine("Leyendo archivo binario");
　　　　}
　　　　public　void　Search(string　text)
　　　　{
　　　　　　　　Console.WriteLine("Búsqueda en el archivo");
　　　　}
}
public　class　Program
{
　　　　public　static　void　Main()
　　　　{
　　　　　　　　IFile　file1　=　new　FileInfo();
　　　　　　　　IBinaryFile　file2　=　new　FileInfo();
　　　　　　　　FileInfo　file3　=　new　FileInfo();
　　　　　　　　file1.ReadFile();　
　　　　　　　　//file1.OpenBinaryFile();　//Error de compilación　
　　　　　　　　//file1.SearchFile("text　to　be　searched");　//Error de compilación　
　　　　　　　　
　　　　　　　　file2.OpenBinaryFile();
　　　　　　　　file2.ReadFile();
　　　　　　　　//file2.SearchFile("text　to　be　searched");　//Error de compilación　
　　　　
　　　　　　　　file3.Search("text　to　be　searched");
　　　　　　　　//file3.ReadFile();　//Error de compilación　
　　　　　　　　//file3.OpenBinaryFile();　//Error de compilación　
　　　　}
}

Arriba, FileInfo ha implementado dos interfaces, IFile e IBinaryFile explícitamente. Se recomienda implementar explícitamente las interfaces cuando se implementan múltiples interfaces, para evitar la confusión y mejorar la legibilidad.