Explication détaillée d'exemples d'interface C#

1. Le rôle de l'interface C#

Résumé d'utilisation : Définir une interface, qui contient des méthodes, mais il n'y a pas de code pour l'implémentation spécifique des méthodes. Ensuite, dans la classe qui hérite de l’interface, vous devez implémenter le code de toutes les méthodes de l’interface. Mais quand on ne comprend pas vraiment le rôle des interfaces, on estime que leur utilisation est superflue. Bien sûr, on a absolument tort de penser ainsi. Concernant le rôle des interfaces, il y a quelqu'un sur Internet qui nous a fait une analyse très compréhensible de manière simple et approfondie.

[csharp] view plain copy

<p></p><pre code_snippet_id="219991" snippet_file_name="blog_20140306_1_6634576" name="code" class="csharp">//我们定义一个接口  
public interface IBark    
{  
    void Bark();  
}

//Définit une autre classe, hérite d'IBark et doit implémenter la méthode Bark()

public class Dog:IBark    
{  
    public Dog()  
    {}  
    public void Bark()  //实现其中的Bark()方法  
    {  
       Consol.write("汪汪");  
     }  
}

// Ensuite, déclarez une instance de Dog et appelez la méthode Bark()

Dog Wangcai=new Dog();

Wangcai.Bark(); > Question : Si vous souhaitez appeler la méthode Bark(), il vous suffit de déclarer une telle méthode dans Dog() Pourquoi utiliser une interface Parce qu'il n'y a pas encore d'implémentation spécifique de Bark() dans l'interface. doit être dans Dog(). Alors n'est-il pas inutile d'utiliser une interface ?

Certaines personnes disent ceci : D'après la définition de l'interface, l'interface est en fait une sorte d'accord de classe entre classes, une contrainte. .Prenons l'exemple ci-dessus.Toutes les classes qui héritent de l'interface IBark doivent implémenter la méthode Bark()Donc, du point de vue de l'utilisateur (l'utilisateur qui utilise la classe), s'il connaît une certaine classe, elle est héritée de l'interface IBark. , afin qu'il puisse appeler la méthode Bark() en toute confiance, quelle que soit la manière dont la méthode Bark() est implémentée. Par exemple, nous avons écrit une autre classe lorsque l'utilisateur utilise la classe Cat ou lorsqu'il s'agit d'une classe Dog, sachant qu'ils le sont. héritez d'IBark, vous pouvez appeler directement la méthode Bark() sans vous soucier de l'implémentation spécifique dans la classe, car il doit y avoir des implémentations spécifiques de la méthode Bark() dans ces deux classes

Si on regarde. Du point de vue de la conception, plusieurs classes doivent être écrites dans un projet. Étant donné que ces classes sont relativement complexes et que la charge de travail est relativement importante, chaque classe nécessite l'écriture d'un membre du personnel. Par exemple, A Le programmeur définit la classe Dog. , et le programmeur B écrit la classe Cat. Ces deux classes n'ont rien à voir l'une avec l'autre à l'origine, mais comme l'utilisateur a besoin d'elles pour implémenter toutes deux une méthode sur "l'appel", cela nécessite une contrainte sur elles. l'interface IBark, et le but est de faciliter une gestion unifiée. L'autre est de faciliter les appels. Bien sûr, le but peut être atteint sans utiliser l'interface. Mais dans ce cas, cette contrainte n'est pas si évidente. a une classe Duck Attendez, certaines personnes vont forcément manquer cette méthode, elle est donc plus fiable et plus contraignante via l'interface.

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

[csharp] view plain copy

/*Maintenant, l'entreprise a un projet et a besoin d'un programmeur pour écrire un programme*/

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

Dans le programme principal, nous pouvons écrire comme ceci :

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

Mais si un autre programmeur C# arrive dans l'entreprise à ce moment-là, comment pouvons-nous modifier ce programme pour qu'il puisse écrire des programmes en C# ? Et les fonctions ? 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 !

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

Mais si vous utilisez une interface à la place, ce sera complètement différent :

Déclarez d'abord une interface de programmeur :

Déclarez ensuite deux classes et implémentez l'interface IProgramer :

interface IProgramer()
{
WriteCode();
}

Modifiez la classe clsProject :

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

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

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

De plus, si nous scellons la classe clsProject dans un composant, alors lorsque nos utilisateurs ont besoin d'étendre les fonctions, il nous suffit d'apporter de petites modifications externes pour y parvenir. en gros, il n'est pas nécessaire de changer les composants que nous avons déjà scellés ! N'est-ce pas très pratique et puissant !

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!