Implémenter une propriété dans une interface en C#

1. Utiliser un bloc de code simple pour définir des propriétés dans une interface
2. Modifications des propriétés dans une interface en C#
3. Implémenter la propriété avec l’héritage d’interface multiple dans une classe abstraite
4. Conclusion

Aujourd’hui, nous allons apprendre à implémenter des propriétés dans une interface en C#.

Les interfaces en C# peuvent avoir de nombreuses propriétés différentes, ainsi que les modificateurs d’accès spécifiant comment nous devons déclarer la disponibilité des propriétés à l’intérieur. L’interface agit souvent comme une implémentation par défaut de différents membres et objets.

Commençons par voir les différentes façons d’implémenter des propriétés dans une interface.

Utiliser un bloc de code simple pour définir des propriétés dans une interface

Supposons que nous créons une interface en C# appelée ENGINE avec la propriété TORQUE. Nous allons paramétrer l’interface ENGINE comme suit :

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

Par conséquent, nous avons créé une interface avec un getter et un setter appropriés pour sa propriété appelée TORQUE. Pour utiliser l’interface, nous devons continuer et définir une classe qui peut implémenter cette interface.

Supposons que l’on veuille définir une classe CAR contenant un ENGINE. On peut donc écrire quelque chose comme suit :

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

Notez que la classe CAR contient une implémentation de TORQUE pour un usage public lors de la création d’un objet à partir de cette classe. Pour utiliser l’objet CAR, appelez simplement quelque chose comme suit :

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

Par conséquent, vous pouvez utiliser différentes propriétés et les inclure dans l’interface à utiliser ultérieurement. Cela fournit une meilleure couche d’abstraction et permet des modifications sans changer les méthodes ou classes principales.

Ainsi, si nous voulions ajouter une nouvelle propriété appelée LABEL à ENGINE, nous pourrions la définir dans l’interface ENGINE, qui peut être utilisée dans la classe CAR.

L’ensemble du code ressemblerait à ceci :

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);
    }
  }
}

Nous avons nommé notre projet CA_ONE ; par conséquent, l’espace de noms l’étend et l’implémente. Une autre chose à noter ici est que l’implémentation de TORQUE dans CAR peut avoir d’autres définitions à l’intérieur de sa fonction, comme une méthode PRINT ou une conversion de couple, etc.

Modifications des propriétés dans une interface en C#

Dans la solution fournie ci-dessus, nous avons mentionné comment nous pourrions définir d’autres méthodes dans notre implémentation. Supposons que l’on veuille étendre les méthodes GET et SET définies par défaut dans l’interface ENGINE.

Nous laisserons ENGINE intact mais tendrons à modifier le code à l’intérieur de la classe CAR qui l’étend.

Dans CAR, lorsque nous définissons un TORQUE, nous pouvons également vouloir imprimer "Torque is Set to _value_" pour que notre utilisateur sache si la propriété TORQUE a été définie correctement ou non.

Nous pouvons donc continuer et faire quelque chose comme suit :

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);
    }
  }
}

Maintenant, concentrons-nous sur ce qui se passe dans le code. La première chose que l’on remarque est l’utilisation d’une autre variable appelée TORQUE_PRIV.

Nous l’avons instancié car nous avons besoin de stocker la valeur TORQUE passée dans le code suivant :

x.torque = 989;

Si au lieu de cela, vous n’utilisez pas la variable TORQUE_PRIV, le code se bloquera dans une boucle, se déplaçant de manière récursive pour attribuer la valeur à la propriété TORQUE. De plus, nous avons utilisé quelque chose appelé VALUE ici.

Notez que VALUE n’est pas une variable mais plutôt un mot-clé contextuel à l’intérieur de C#. VALUE est utilisé dans l’indexeur d’ensemble dans les déclarations de propriété et d’accès.

Il prend la valeur assignée par le client et l’assigne à la variable privée de la classe. De cette manière, vous pouvez modifier et utiliser vos déclarations.

Beaucoup de gens utiliseront le code suivant dans le setter de TORQUE pour l’abstrait CAR.

this.torque_priv = torque;

Et pour le GETTER :

return torque;

Cela présentera une erreur comme suit en raison du blocage dans une boucle récursive :

Stack overflow.

La syntaxe générale pour implémenter n’importe quelle propriété dans une interface est la suivante :

type name { get; set; }

Étant donné que plusieurs classes peuvent hériter et utiliser des interfaces, il est préférable d’étendre et de modifier les propriétés dans les classes abstraites. Les interfaces peuvent servir de structure dorsale lors de la mise en œuvre de différentes méthodes et fournir une idée de base de ce qu’il faut étendre et de ce qu’il ne faut pas étendre.

N’oubliez pas que les interfaces ne peuvent pas être utilisées directement. Ils doivent avoir des classes abstraites initialisées et utilisées lors de l’exécution d’un code.

Les méthodes d’une interface sont toujours publiques et aucun modificateur d’accès implicite n’est nécessaire. De plus, les interfaces peuvent hériter d’autres interfaces.

Si vous essayez d’implémenter une propriété dans une interface et qu’une autre interface hérite de celle définie précédemment, vous pouvez utiliser une classe pour étendre cette dernière interface.

Supposons que nous ayons une interface ENGINE qui hérite de BOLTS puis est héritée par la classe CAR. Nous voulons installer un kit d’urgence avec la taille de la clé en fonction des dimensions des boulons pour chaque CAR.

Par conséquent, nous pouvons utiliser une implémentation comme suit :

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

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

Et puis en étendant le BOLT dans la classe CAR comme suit :

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);
  }
}

Ainsi, vous pouvez voir que toutes les interfaces sont héritées. Si vous définissez une propriété dans une interface de base, vous devrez implémenter cette propriété dans toutes les classes qui étendent l’interface de base ou les interfaces dérivées.

Il est donc nécessaire d’étendre les définitions.

Implémenter la propriété avec l’héritage d’interface multiple dans une classe abstraite

Disons que nous avons deux interfaces : ENGINE et WHEEL. Et les deux contiennent une méthode de démarrage, nous indiquant si le ENGINE ou la WHEEL a démarré ou non.

Définissons une méthode de démarrage.

public interface WHEEL {
  void print();
}

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

Pour l’étendre dans la classe CAR, vous devez écrire certaines fonctions comme suit :

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

Et pour les appeler, écrivez quelque chose comme suit dans le principal :

((WHEEL)x).print();

Il s’agit de spécifier quelle interface vous souhaitez utiliser la méthode print().

Accédez au code complet utilisé dans ce tutoriel ici.

Conclusion

C’est tout pour savoir comment utiliser les propriétés dans les interfaces. Il peut y avoir différentes circonstances dans lesquelles nous devons définir et utiliser une propriété ; par conséquent, il est préférable d’étudier tous les cas décrits ci-dessus.