Classe abstraite en C#

Le mot abstrait désigne une pensée ou une idée qui n'a aucune forme physique propre mais qui sert de base à d'autres choses. Le concept derrière la classe abstraite est le même. Dans cet article, nous discuterions des classes abstraites en C#. Une classe abstraite est une classe spéciale en C# qui ne peut pas être instanciée, c'est-à-dire que vous ne pouvez pas créer d'objets d'une classe abstraite. Le but d’une classe abstraite est de fournir une structure squelettique dont d’autres classes peuvent dériver. Les classes abstraites n’ont pas d’implémentation propre. Ils exigent que les développeurs et les programmeurs dérivent de la classe abstraite et s'appuient sur la structure squelettique, c'est-à-dire qu'ils écrivent leur implémentation. Une classe abstraite peut également contenir des déclarations de méthodes abstraites. Encore une fois, ces méthodes ne peuvent avoir aucune définition.

La syntaxe de déclaration des classes et méthodes abstraites implique de placer le mot-clé abstract avant la déclaration. Aussi simple que ça.

Syntaxe :

abstract class ClassName
{
public abstract void MethodName();
}

N'oubliez pas que les méthodes abstraites ne peuvent pas avoir de définitions. Ainsi, les déclarations de méthodes abstraites se terminent par un point-virgule. Ils ne peuvent qu'être déclarés. Les définitions doivent être fournies dans des classes dérivées non abstraites.

Comment fonctionne la classe abstraite en C# ?

Le mot-clé abstract indique au compilateur que la classe est une structure squelette de classe de base à implémenter dans des classes dérivées. Si le compilateur trouve une classe dérivant de la classe de base abstraite, il vérifie si toutes les méthodes et propriétés abstraites sont remplacées et implémentées dans la classe dérivée.

Classe abstraite vs interface

Maintenant, vous vous demandez peut-être ce que tout cela signifie et ce que fait l'interface. Alors, en quoi une classe abstraite est-elle différente d'une interface ?

Comprenons cela avec un exemple. Disons que nous dirigeons une maison d'édition et que nous avons embauché quelques rédacteurs pour rédiger des chroniques pour notre magazine. Supposons qu'ils soient experts dans différents genres, écrivent des articles à publier un jour précis de la semaine et soient tous embauchés au même salaire.

Définissons la classe abstraite Employee pour nos éditeurs.

Code :

abstract class EmployeeEditors
{
public abstract void Genre();
public abstract string PublishDay();
public int Payment()
{
Console.Write(“Monthly salary is {0}$.”, 1000);
}
}

Nous pourrions facilement mettre en place le Mode de Paiement, sachant qu'il serait le même pour tous. Les deux autres méthodes ont été déclarées abstraites pour être implémentées par la classe dérivée. On pourrait déclarer une classe normale pour chaque éditeur dérivée de la classe abstraite et ensuite implémenter les méthodes abstraites pour définir les genres et les jours. Supposons maintenant que le salaire de chaque éditeur soit également différent. Une façon de modifier notre code consiste à déclarer le mode de paiement comme abstrait. L'autre façon serait de déclarer l'ensemble de EmployeeEditor comme interface et de donner toute liberté à l'héritage des classes.

Public interface EmployeeEditors
{
public abstract void Genre();
public abstract string PublishDay();
public abstract int Payment();
}

Ainsi, une classe abstraite est une classe de base sur laquelle d'autres classes peuvent s'appuyer. Alors qu'une interface est un modèle auquel d'autres classes peuvent se référer et construire à partir de zéro.

Règles de la classe abstraite en C#

Il y a certaines règles à suivre lorsque vous travaillez avec des classes abstraites.

• Étant donné que les classes abstraites ont des définitions de méthodes incomplètes, elles ne peuvent pas être instanciées. Toute tentative de création d'un objet d'une classe abstraite entraînerait une erreur de compilation.
• Les méthodes abstraites ne peuvent pas être définies dans des classes abstraites mais seulement déclarées. Le corps de la méthode doit être défini dans les classes dérivées.
• Les classes dérivées doivent implémenter toutes les méthodes abstraites.
• Les méthodes abstraites ne peuvent pas être statiques ou virtuelles.

Exemple de classe abstraite en C#

Énoncé du problème : Prenons un autre exemple concret. Supposons que l'on vous demande d'automatiser le processus de génération de lettres d'offre pour une certaine organisation. Le processus actuel est entièrement manuel et nécessite la modification des lettres d'offre existantes, ce qui est sujet aux erreurs. Certaines choses seraient communes à toutes les lettres d'offre, telles que le lieu de travail, les horaires de travail, le titre de l'entreprise, l'image de marque de l'entreprise, etc. D'autres éléments tels que le nom de l'employé, le poste, le salaire, la date d'arrivée, etc., sont spécifiques à chacun. lettre d'offre.

Solution : Vous concevriez une classe abstraite dans le but ci-dessus. Voyons comment.

Code :

ode: using System;
abstract class OfferLetter
{
public abstract string Name(string name);
public abstract string Designation(string designation);
public abstract int Payment(int pay);
public abstract string DOJ(string doj);
public string CompanyName()
{
return "XYZ Corporation Pvt. Ltd.";
}
public string OfficeAddress()
{
return "512, Manhattan, NY";
}
public string CompanyBranding()
{
return this.CompanyName() + " is a privately owned regsitered corporation operating \n under the license provided by the state of New York.";
}
public string Disclaimer()
{
return "This letter and its contents are confidential in nature and are intended only \n for the recipient."+
"\nIf you are not the correct recipient, kindly return it immediately \n to " + this.CompanyName() + " " + this.OfficeAddress() + ".";
}
}
class PrintOfferLetter : OfferLetter
{
public override string Name(string name)
{
return name;
}
public override string Designation(string designation)
{
return designation;
}
public override int Payment(int pay)
{
return pay;
}
public override string DOJ(string doj)
{
return doj;
}
}
public class Program
{
public static void Main()
{
PrintOfferLetter ltr = new PrintOfferLetter();
string empName = "Mr. ABC", designation = "Senior Consultant", doj = "20-02-2020";
int pay = 50000;
Console.WriteLine(ltr.CompanyName() + " is very happy to extend this offer letter to \n" + ltr.Name(empName)
+ " at the designation of " + ltr.Designation(designation) + " with an annual pay of " + ltr.Payment(pay) + "$.");
Console.WriteLine("\nYou are required to report at " + ltr.OfficeAddress() + " from " + ltr.DOJ(doj) + " (dd-mm-yyyy).");
Console.WriteLine("\n\n" + ltr.CompanyBranding());
Console.WriteLine("\n\n" + ltr.Disclaimer());
}
}

Sortie :

Conclusion

En un mot, une classe abstraite est simplement une classe incomplète ou partiellement complète que d'autres classes peuvent dériver et construire leur logique par-dessus. Dans cet article, nous avons vu comment une classe abstraite est déclarée et cela fonctionne. Nous avons vu des exemples concrets d'utilisation de classes abstraites et en quoi elles diffèrent des interfaces. Il est recommandé d'essayer d'utiliser autant que possible des classes abstraites dans votre code. Il s'agit d'une pratique cruciale d'une bonne programmation.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!