¿Qué es una interfaz en ASP.NET?
¿Qué es una interfaz? De hecho, la simple comprensión de la interfaz es una convención que hace que las clases o estructuras que implementan la interfaz sean consistentes en forma. Personalmente, creo que el uso de interfaces puede hacer que el programa sea más claro y organizado. Este es el beneficio de las interfaces. Sin embargo, no todos los lenguajes de programación admiten interfaces. Tenga en cuenta que, aunque conceptualmente las interfaces C# son similares a las interfaces COM, sus estructuras subyacentes son diferentes. Entonces, echemos un vistazo a cómo declarar y usar interfaces.
Declarar una interfaz
La sintaxis de declarar una interfaz es exactamente la misma que declarar una clase abstracta. Por ejemplo, aquí hay una interfaz para una cuenta bancaria:
<. p>interfaz pública IBankAccount{
void PayIn(monto decimal);
bool Withdraw(monto decimal);
Saldo decimal
{
get;
}
}
Nota: Las interfaces solo pueden contener declaraciones de métodos, propiedades, indexadores y eventos. No está permitido declarar modificadores en miembros, ni siquiera públicos, porque los miembros de la interfaz siempre son públicos y no pueden declararse virtuales o estáticos. Si se requieren modificadores, es mejor dejar que la clase de implementación los declare.
Ejemplo de uso de interfaces
Este es un ejemplo simple en el libro, pero es suficiente para ilustrar el uso de interfaces.
Una interfaz de cuenta bancaria y las clases de implementación de dos cuentas bancarias diferentes heredan de esta interfaz. La declaración de la interfaz es la anterior.
Las siguientes son dos clases de cuenta:
clase SaverAccount: IBankAccount
{
saldo decimal privado
saldo decimal público
{
obtener
{
saldo de devolución
}
}
pago vacío público (monto decimal)
{
saldo = monto
}
retiro bool público (decimal) importe)
{
if (saldo gt; = importe)
{
saldo -= importe;
devuelve verdadero;
}
Console.WriteLine("Falló el retiro."); /p>
cadena de anulación pública ToString()
{
return String.Format("Venus Bank Saver: Balance={0, 6: C}", balance) ;
}
}
clase GoldAccount: IBankAccount
{
saldo decimal privado;
Saldo decimal público
{
obtener
{
saldo de devolución
}
}
pago nulo público (monto decimal)
{
saldo = monto
}
public bool Retirar(monto decimal)
{
if (saldo gt; = monto)
{
saldo -= monto;
devuelve verdadero
}
Console.WriteLine("El retiro falló."); ;
}
cadena de anulación pública ToString()
{
return String.Format("Jupiter Bank Saver: Balance={0, 6: C}", balance);
}
}
Se puede ver que estas dos clases de implementación heredan la interfaz IBankAccount, por lo que deben implementar todas las declaraciones en la interfaz. método. De lo contrario, se producirán errores de compilación. Probemoslo Aquí está el código de prueba:
static void Main(string[] args)
{
IBankAccount venusAccount = new SaverAccount(); /p>
IBankAccount jupiterAccount = new CurrentAccount();
venusAccount.PayIn(200);
jupiterAccount.PayIn(500); .WriteLine(venusAccount.ToString());
jupiterAccount.PayIn(400);
jupiterAccount.Withdraw(500);
jupiterAccount.Withdraw( 100 );
Console.WriteLine(jupiterAccount.ToString());
}
Tenga en cuenta las dos primeras oraciones, las declaramos como referenciadas por IBankAccount. , pero no declarado como referencia a la clase, ¿por qué? Porque, de esta forma, podemos dejar que apunte a una instancia de cualquier clase que implemente esta interfaz, lo cual es más flexible. Pero esto también tiene una desventaja. Si queremos ejecutar un método que no pertenece a la interfaz, como el método ToString() sobrecargado aquí, primero debemos forzar la referencia de la interfaz al tipo apropiado.
Herencia de interfaces
Las interfaces también pueden heredar entre sí, al igual que la herencia de clases. Por ejemplo, declaramos una interfaz ITransferBankAccount, que hereda de la interfaz IBankAccount.
interfaz ITransferBankAccount: IBankAccount
{
bool TransferTo(destino de IBankAccount, importe decimal
}
Es decir:
clase CuentaActual: ITransferBankAccount
{
saldo decimal privado
Saldo decimal público
; {
obtener
{
saldo de devolución
}
}
public void PayIn(cantidad decimal)
{
saldo = cantidad;
}
public bool Retiro(cantidad decimal)
{
if (saldo gt;= monto)
{
saldo -= monto;
devuelve verdadero ;
}
Console.WriteLine("Retirada fallida."
devuelve falso
}
cadena de anulación pública ToString()
{
return String.Format("Jupiter Bank Saver: Balance={0, 6: C}", balance
}
public bool TransferTo(Destino de la cuenta IBank, monto decimal)
{
if (Retirar(monto))
{
destino.PayIn(monto);
devuelve verdadero
}
else
{
return false;
}
}
}
En resumen, hay varias cosas que Debe prestar atención al utilizar la interfaz C# Preguntas:
1. La interfaz en C# se define independientemente de la clase. Esto es la antítesis del modelo C, donde las interfaces son efectivamente clases base abstractas.
2. Tanto las interfaces como las clases pueden heredar múltiples interfaces.
3. Una clase puede heredar una clase base, pero una interfaz no puede heredar una clase en absoluto. Este modelo evita el problema de herencia múltiple de C, donde las implementaciones en diferentes clases base pueden entrar en conflicto. Por lo tanto, ya no son necesarios mecanismos complejos como la herencia virtual y el alcance explícito. El modelo de interfaz simplificado de C# ayuda a acelerar el desarrollo de aplicaciones.
4. Una interfaz define un tipo de referencia con solo miembros abstractos.
Lo que realmente hace una interfaz en C# es solo tener indicadores de método, pero no se ejecuta ningún código. Esto implica que no se puede crear una instancia de una interfaz, sólo un objeto derivado de esa interfaz.
5. Las interfaces pueden definir métodos, propiedades e índices. Entonces, en comparación con una clase, la particularidad de una interfaz es que cuando define una clase, puede derivar de múltiples interfaces, pero solo puede derivar de una sola clase.