Implementar una propiedad en una interfaz en C#

1. Use un bloque de código simple para establecer propiedades en una interfaz
2. Modificaciones a las Propiedades en una Interfaz en C#
3. Implementar propiedad con herencia de interfaz múltiple en una clase abstracta
4. Conclusión

Hoy, aprenderemos cómo implementar propiedades en una interfaz en C#.

Las interfaces en C# pueden tener muchas propiedades diferentes, junto con los modificadores de acceso que especifican cómo debemos declarar la disponibilidad de la propiedad dentro. La interfaz a menudo actúa como una implementación predeterminada de diferentes miembros y objetos.

Comencemos y veamos las diversas formas en que podemos implementar propiedades en una interfaz.

Use un bloque de código simple para establecer propiedades en una interfaz

Supongamos que creamos una interfaz en C# llamada ENGINE con la propiedad TORQUE. Configuraremos la interfaz ENGINE de la siguiente manera:

public interface ENGINE {
  int torque { get; set; }
}

Por lo tanto, hemos creado una interfaz con un getter y setter adecuado para su propiedad llamada TORQUE. Para usar la interfaz, tenemos que seguir adelante y definir una clase que pueda implementar esta interfaz.

Supongamos que queremos definir una clase CAR que contenga un ENGINE. Por lo tanto, podemos escribir algo de la siguiente manera:

class CAR : ENGINE {
  public int torque { get; set; }
}

Tenga en cuenta que la clase CAR contiene una implementación de TORQUE para uso público al crear un objeto de esta clase. Para usar el objeto CAR, simplemente llame a algo de la siguiente manera:

CAR x = new CAR();
x.torque = 989;
Console.WriteLine(x.torque);

Por lo tanto, puede usar diferentes propiedades e incluirlas en la interfaz para usarlas más adelante. Esto proporciona una mejor capa de abstracción y permite modificaciones sin cambiar los métodos o clases principales.

Entonces, si quisiéramos agregar una nueva propiedad llamada LABEL a ENGINE, podríamos configurarla en la interfaz ENGINE, que se puede usar en la clase CAR.

Todo el código quedaría de la siguiente manera:

using System;

namespace CA_ONE {
  class Program {
    public interface ENGINE {
      int torque { get; set; }
    }

    class CAR : ENGINE {
      public int torque { get; set; }
    }

    static void Main(string[] args) {
      CAR x = new CAR();
      x.torque = 989;
      Console.WriteLine(x.torque);
    }
  }
}

Hemos denominado a nuestro proyecto CA_ONE; por lo tanto, el espacio de nombres lo amplía y lo implementa. Una cosa más a tener en cuenta aquí es que la implementación de TORQUE en CAR puede tener otras definiciones dentro de su función, como un método PRINT o una conversión de par, etc.

Modificaciones a las Propiedades en una Interfaz en C#

En la solución proporcionada anteriormente, mencionamos cómo podríamos definir otros métodos dentro de nuestra implementación. Supongamos que queremos extender los métodos GET y SET definidos por defecto en la interfaz ENGINE.

Dejaremos ENGINE intacto pero tenderemos a modificar el código dentro de la clase CAR que lo amplía.

En CAR, cuando configuramos un TORQUE, también podemos querer imprimir "Torque is Set to _value_" para que nuestro usuario sepa si la propiedad TORQUE se ha configurado correctamente o no.

Por lo tanto, podemos seguir adelante y hacer algo de la siguiente manera:

class CAR : ENGINE {
  private int torque_priv;
  public int torque {
    get { return this.torque_priv; }
    set {
      this.torque_priv = value;
      Console.WriteLine("This torque has been set to " + torque_priv);
    }
  }
}

Ahora aquí, concentrémonos en lo que está sucediendo en el código. Lo primero que notamos es el uso de otra variable llamada TORQUE_PRIV.

Lo hemos instanciado porque necesitamos almacenar el valor TORQUE pasado en el siguiente código:

x.torque = 989;

Si en lugar de esto, no utiliza la variable TORQUE_PRIV, el código se quedará atascado en un bucle, moviéndose recursivamente para asignar el valor a la propiedad TORQUE. Además, aquí hemos usado algo llamado VALUE.

Tenga en cuenta que VALUE no es una variable sino una palabra clave contextual dentro de C#. VALUE se utiliza en el indexador de conjuntos en las declaraciones de propiedad y acceso.

Toma el valor asignado por el cliente y lo asigna a la variable privada de la clase. De esta manera, puede modificar y utilizar sus declaraciones.

Mucha gente usará el siguiente código en el setter de TORQUE para el resumen CAR.

this.torque_priv = torque;

Y para el GETTER:

return torque;

Esto presentará un error de la siguiente manera debido a que se quedó atascado en un bucle recursivo:

Stack overflow.

La sintaxis general para implementar cualquier propiedad en una interfaz es la siguiente:

type name { get; set; }

Debido a que múltiples clases pueden heredar y usar interfaces, es mejor extender y modificar propiedades en las clases abstractas. Las interfaces pueden servir como estructura principal al implementar diferentes métodos y proporcionar una idea básica de qué extender y qué no.

Recuerde que las interfaces no se pueden utilizar directamente. Necesitan tener clases abstractas inicializadas y usadas mientras ejecutan un código.

Los métodos en una interfaz siempre son públicos y no hay necesidad de ningún modificador de acceso implícito. Además, las interfaces pueden heredar de otras interfaces.

Si está intentando implementar una propiedad en una interfaz y otra interfaz hereda la definida anteriormente, puede usar una clase para extender la última interfaz.

Supongamos que tenemos una interfaz ENGINE que hereda BOLTS y luego es heredada por la clase CAR. Queremos instalar un kit de emergencia con el tamaño de llave acorde a las dimensiones de los tornillos de cada CAR.

Por lo tanto, podemos usar una implementación de la siguiente manera:

public interface BOLT {
  int size { get; set; }
}

public interface ENGINE : BOLT {
  int torque { get; set; }

Y luego extendiendo el BOLT en la clase CAR de la siguiente manera:

public int size {
  get { return wrench_size; }
  set {
    // set the wrench size
    wrench_size = value;
    Console.WriteLine("The wrench size to use should be: " + wrench_size);
  }
}

Entonces puede ver que las interfaces se heredan. Si establece una propiedad en una interfaz base, deberá implementar esa propiedad en todas las clases que amplían la interfaz base o las interfaces derivadas.

Por lo tanto, es necesario ampliar las definiciones.

Implementar propiedad con herencia de interfaz múltiple en una clase abstracta

Digamos que tenemos dos interfaces: ENGINE y WHEEL. Y ambos contienen un método de arranque, diciéndonos si el ENGINE o el WHEEL ha arrancado o no.

Definamos un método de inicio.

public interface WHEEL {
  void print();
}

public interface ENGINE : BOLT {
  int torque { get; set; }
  void print();
}

Para extenderlo en la clase CAR, debe escribir algunas funciones de la siguiente manera:

void WHEEL.print() {
  Console.WriteLine("Wheel has been started");
}
void ENGINE.print() {
  Console.WriteLine("Engine has been started!");
}

Y para llamarlas, escribe algo como lo siguiente en el main:

((WHEEL)x).print();

Esto es para especificar qué interfaz quieres usar con el método print().

Acceda al código completo utilizado en este tutorial aquí.

Conclusión

Eso es todo sobre cómo usar las propiedades en las interfaces. Puede haber diferentes circunstancias en las que necesitemos configurar y usar una propiedad; por lo tanto, es mejor estudiar todos los casos descritos anteriormente.