Tutoriel de base C#

Tutoriel avancé C#

C# orienté objet (OOP)

Interface C#

Dans le monde humain, un contrat entre deux ou plusieurs personnes les oblige à agir conformément au contrat. De même, une interface inclut des déclarations de fonctionnalités pertinentes. Les entités qui implémentent l'interface doivent fournir des implémentations des fonctionnalités déclarées.

Dans C#, vous pouvez utiliser la keyword interface pour définir une interface. Une interface peut contenir des déclarations de méthodes, de propriétés, d'indexeurs et d'événements. Cependant, elle ne peut pas inclure de champs, de propriétés automatiquement implémentées.

Les interfaces suivantes déclarent certaines fonctionnalités de base des opérations sur les fichiers.

Exemple : interface C#

interface IFile
{
　　　　void ReadFile();
　　　　void WriteFile(string text);
}

Vous ne pouvez pas appliquer un modificateur d'accès aux membres de l'interface. Par défaut, tous les membres sont publics. Si vous utilisez un modificateur d'accès dans une interface, le compilateur C# donnera une erreur de compilation 'The modifier 'public'/private/Le mot-clé 'protected' n'est pas valide pour cet élément. (Visual Studio affichera immédiatement un erreur sans compilation.)

示例：带有访问修饰符的无效接口

interface IFile
{
　　　　protected void ReadFile();　//Erreur de compilation
　　　　private void WriteFile(string text);//Erreur de compilation
}

接口只能包含声明，而不能包含实现。以下将给出编译时错误。

示例：无效的实现接口

interface IFile
{
　　　　void ReadFile();
　　　　void WriteFile(string text){
　　　　　　　　Console.Write(text);　　//错误：无法实现方法
　　　　}
}

实现接口

一个类或一个Struct可以使用冒号（:）实现一个或多个接口。　

语法：

<Class or Struct Name> : <Interface Name>

例如，下面的类隐式地实现了 IFile 接口。

示例：接口实现

interface IFile
{
　　　　void ReadFile();
　　　　void WriteFile(string text);
}
class FileInfo : IFile
{
　　　　public void ReadFile()
　　　　{
　　　　　　　　Console.WriteLine("Reading File");
　　　　}
　　　　public void WriteFile(string text)
　　　　{
　　　　　　　　Console.WriteLine("Écriture dans le fichier");
　　　　}
}

在上面的示例中，FileInfo 类实现了 IFile 接口。它使用 public 访问修饰符定义 IFile 接口的所有成员。FileInfo 类还可以包含接口成员以外的其他成员。

接口成员必须使用 public 修饰符实现；否则，编译器将给出编译时错误。

您可以创建该类的对象，并将其分配给接口类型的变量，如下所示。

示例：接口实现

public class Program
{
　　　　public static void Main()
　　　　{
　　　　　　　　IFile file1　= new FileInfo();
　　　　　　　　FileInfo file2　= new FileInfo();
　　　　　　　　file1.ReadFile();　
　　　　　　　　file1.WriteFile("contenu");　
　　　　　　　　file2.ReadFile();　
　　　　　　　　file2.WriteFile("contenu");　
　　　　}
}

在上面，我们创建了 FileInfo 类的对象，并将其分配给 IFile 类型变量和 FileInfo 类型变量。当接口隐式实现时，您可以使用 IFile 类型变量以及 FileInfo 类型变量访问 IFile 成员。

显式实现

接口可以使用<InterfaceName>.<MemberName>来显式实现。当类正在实现多个接口时，显式实现是有用的；因此，它更易于阅读，并消除了混乱。如果接口具有相同的方法名，那么它也是有用的。

不要将 public 修饰符与显式实现一起使用时，它将给出一个编译时错误。

示例：显式实现

interface IFile
{
　　　　void ReadFile();
　　　　void WriteFile(string text);
}
　　　　
class FileInfo : IFile
{
　　　　void IFile.ReadFile()
　　　　{
　　　　　　　　Console.WriteLine("Reading File");
　　　　}
　　　　void IFile.WriteFile(string text)
　　　　{
　　　　　　　　Console.WriteLine("Écriture dans le fichier");
　　　　}
}

当显式实现接口时，只能通过接口类型的实例访问接口成员。

示例：显式实现

interface IFile
{
　　　　void ReadFile();
　　　　void WriteFile(string text);
}
class FileInfo : IFile
{
　　　　void IFile.ReadFile()
　　　　{
　　　　　　　　Console.WriteLine("Reading File");
　　　　}
　　　　void IFile.WriteFile(string text)
　　　　{
　　　　　　　　Console.WriteLine("Écriture dans le fichier");
　　　　}
　　　　public void Search(string text)
　　　　{
　　　　　　　　Console.WriteLine("Recherche dans le fichier");
　　　　}
}
public class Program
{
　　　　public static void Main()
　　　　{
　　　　　　　　IFile file1　= new FileInfo();
　　　　　　　　FileInfo file2　= new FileInfo();
　　　　　　　　file1.ReadFile();　
　　　　　　　　file1.WriteFile("contenu");　
　　　　　　　　//file1.Search("texte à chercher")//Erreur de compilation　
　　　　　　　　
　　　　　　　　file2.Search("texte à chercher");
　　　　　　　　//file2.ReadFile();　//Erreur de compilation　
　　　　　　　　//file2.WriteFile("contenu");　//Erreur de compilation　
　　　　}
}

Dans l'exemple ci-dessus, file1Les membres IFile auxquels l'objet peut accéder, et file2Seulement les membres de la classe FileInfo peuvent être accédés. C'est la limitation de l'implémentation explicite.

Implémentation de multiples interfaces

Une classe ou une structure peut implémenter plusieurs interfaces. Elle doit fournir l'implémentation de tous les membres de toutes les interfaces.

Exemple : implémentation de multiples interfaces

interface IFile
{
　　　　void ReadFile();
}
interface IBinaryFile
{
　　　　void OpenBinaryFile();
　　　　void ReadFile();
}
class FileInfo : IFile, IBinaryFile
{
　　　　void IFile.ReadFile()
　　　　{
　　　　　　　　Console.WriteLine("Lecture de fichier texte");
　　　　}
　　　　void IBinaryFile.OpenBinaryFile()
　　　　{
　　　　　　　　Console.WriteLine("Ouverture de fichier binaire");
　　　　}
　　　　void IBinaryFile.ReadFile()
　　　　{
　　　　　　　　Console.WriteLine("Lecture de fichier binaire");
　　　　}
　　　　public void Search(string text)
　　　　{
　　　　　　　　Console.WriteLine("Recherche dans le fichier");
　　　　}
}
public class Program
{
　　　　public static void Main()
　　　　{
　　　　　　　　IFile file1　= new FileInfo();
　　　　　　　　IBinaryFile file2　= new FileInfo();
　　　　　　　　FileInfo file3　= new FileInfo();
　　　　　　　　file1.ReadFile();　
　　　　　　　　//file1.OpenBinaryFile();　//Erreur de compilation　
　　　　　　　　//file1.SearchFile("texte à chercher");　//Erreur de compilation　
　　　　　　　　
　　　　　　　　file2.OpenBinaryFile();
　　　　　　　　file2.ReadFile();
　　　　　　　　//file2.SearchFile("texte à chercher");　//Erreur de compilation　
　　　　
　　　　　　　　file3.Search("texte à chercher");
　　　　　　　　//file3.ReadFile();　//Erreur de compilation　
　　　　　　　　//file3.OpenBinaryFile();　//Erreur de compilation　
　　　　}
}

En haut, FileInfo implémente deux interfaces, IFile et IBinaryFile explicitement implémentées. Il est recommandé d'implémenter explicitement les interfaces lors de l'implémentation de multiples interfaces, pour éviter la confusion et améliorer la lisibilité.

Points à retenir :

Les interfaces peuvent contenir des déclarations de méthodes, de propriétés, d'indexeurs et d'événements.
Les interfaces ne peuvent pas contenir de membres privés, protégés ou internes. Par défaut, tous les membres sont publics.
Les interfaces ne peuvent pas contenir de champs et de propriétés automatiquement implémentées.
Une classe ou une structure peut implémenter implicitement ou explicitement une ou plusieurs interfaces. Utilisez le modificateur public pour implémenter implicitement une interface, et n'utilisez pas de modificateur dans le cas d'une implémentation explicite.
Implémenter explicitement l'interface en utilisant InterfaceName. MemberName.
Un interface peut hériter d'une ou plusieurs interfaces.

FileInfo C#Classe C#