Compréhension approfondie du rôle des interfaces C#

Adresse originale : //m.sbmmt.com/

Supposons qu'il existe deux types de programmeurs dans notre entreprise : les programmeurs VB, faisant référence à Les programmeurs qui écrivent des programmes en VB sont représentés par la classe clsVBProgramer ; les programmeurs Delphi font référence aux programmeurs qui écrivent des programmes en Delphi, représentés par la classe clsDelphiProgramer. Chaque classe possède une méthode WriteCode(). La définition est la suivante :

class clsVBProgramer()
{
....
WriteCode()
{
     //用VB语言写代码；
}
....
}

class clsDelphiProgramer()
{
....
WriteCode()
{
    //用Delphi语言写代码；
}
   ....
}

Maintenant, le L'entreprise a un Le projet nécessite l'envoi d'un programmeur pour écrire un programme.

class clsProject()
{
....
WritePrograme(clsVBProgramer programer)//用VB写代码
{
    programer.WriteCode();
}
WritePrograme(clsDelphiProgramer programer)//重载方法，用Delphi写代码
{
    programer.WriteCode();
}
......
}

Dans le programme principal, nous Vous pouvez écrire comme ceci :

main()
{
   clsProject proj=new clsProject;
   //如果需要用VB写代码
   clsVBProgramer programer1=new clsVBProgramer;
   proj.WritePrograme(programer1);
   //如果需要用Delphi写代码
   clsDelphiProgramer programer2=new clsDelphiProgramer;
   proj.WritePrograme(programer2);
}

Mais si un autre programmeur C# arrive dans l'entreprise à ce moment-là, comment pouvons-nous modifier ce programme afin qu'il puisse réaliser la fonction d'écriture de programmes en C# ? Nous devons ajouter une nouvelle classe clsCSharpProgramer et en même temps surcharger à nouveau la méthode WritePrograme (programmeur clsCSharpProgramer) dans cette classe clsProject. Cette fois, c'est plus de problèmes. Et s'il y avait des programmeurs C, des programmeurs C et des programmeurs JAVA. Gros problème !

Mais si vous utilisez plutôt une interface, ce sera complètement différent :
Déclarez d'abord une interface de programmeur :

interface IProgramer()
{
WriteCode();
}
然后声明两个类，并实现IProgramer接口：
class clsVBProgramer():IProgramer
{
....
WriteCode()
{
     //用VB语言写代码；
}
....
}

class clsDelphiProgramer():IProgramer
{
....
WriteCode()
{
    //用Delphi语言写代码；
}
   ....
}

Modifiez la classe clsProject :

class clsProject()
{
....
WritePrograme(IProgramer programer)
{
    programer.WriteCode();//写代码
}
......
}
 
main()
{
   clsProject proj=new clsProject;
   IProgramer programer;
   //如果需要用VB写代码
   programer=new clsVBProgramer;
   proj.WritePrograme(programer);
   //如果需要用Delphi写代码
   programer=new clsDelphiProgramer;
   proj.WritePrograme(programer);   
}

Si des programmeurs comme C#, C, C, JAVA sont ajoutés, il suffit d'ajouter leurs classes associées, puis d'apporter de légères modifications dans main( ) et tout ira bien. L'évolutivité est particulièrement bonne !

De plus, si nous scellons la classe clsProject dans un composant, alors lorsque nos utilisateurs ont besoin d'étendre les fonctions, nous n'avons besoin que de petites modifications externes pour y parvenir. On peut dire que ce n'est pas nécessaire. tous. Modifications Nous avons scellé les composants ! N'est-ce pas très pratique et puissant !

Ce qui précède est une compréhension approfondie du rôle de l'interface C#. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (m.sbmmt.com). !