{"id":1343,"date":"2023-04-02T11:48:56","date_gmt":"2023-04-02T04:48:56","guid":{"rendered":"https:\/\/csharptutorial.net\/?page_id=1343"},"modified":"2023-04-02T11:48:58","modified_gmt":"2023-04-02T04:48:58","slug":"csharp-explicit-interface-implementation","status":"publish","type":"page","link":"https:\/\/www.csharptutorial.net\/csharp-tutorial\/csharp-explicit-interface-implementation\/","title":{"rendered":"C# Explicit Interface Implementation"},"content":{"rendered":"\n

Summary<\/strong>: in this tutorial, you’ll learn about C# explicit interface implementation and how to use it effectively.<\/p>\n\n\n\n

Introduction to C# explicit interface implementation<\/h2>\n\n\n\n

In C#, a class<\/a> can implement an interface<\/a> in two ways: implicitly and explicitly. By default, C# uses the implicit implementation. For example:<\/p>\n\n\n

interface<\/span> ILogger<\/span>\n{\n    void<\/span> Log<\/span>(string<\/span> message<\/span>)<\/span>;\n}\n\nclass<\/span> ConsoleLoger<\/span> : ILogger<\/span>\n{\n    public<\/span> void<\/span> Log<\/span>(string<\/span> message<\/span>)<\/span> => Console.WriteLine(message);\n}\n\nclass<\/span> Program<\/span>\n{\n    public<\/span> static<\/span> void<\/span> Main<\/span>(string<\/span>[] args<\/span>)<\/span>\n    {\n        var<\/span> logger = new<\/span> ConsoleLoger();\n        logger.Log(\"Hello\"<\/span>);\n    }\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
In this example, we define an ILogger<\/code><\/code> interface with one method called Log<\/code>, which logs a message. Then, we define a ConsoleLogger<\/code><\/code> class that implements the ILogger<\/code><\/code> interface. The ConsoleLogger<\/code><\/code> class implements the Log<\/code> method that logs a message to the console.<\/p>\n\n\n\n
In the Main()<\/code> method of the Program<\/code> class, we create a new instance of the ConsoleLogger<\/code> class and log a message to the console.<\/p>\n\n\n\n
Unlike the implicit interface implementation, an explicit interface implementation requires you to specify the interface name when implementing the method. For example:<\/p>\n\n\n
interface<\/span> ILogger<\/span>\n{\n    void<\/span> Log<\/span>(string<\/span> message<\/span>)<\/span>;\n}\n\nclass<\/span> ConsoleLoger<\/span> : ILogger<\/span>\n{\n    void<\/span> ILogger.Log(string<\/span> message) => Console.WriteLine(message);\n}\n\nclass<\/span> Program<\/span>\n{\n    public<\/span> static<\/span> void<\/span> Main<\/span>(string<\/span>[] args<\/span>)<\/span>\n    {\n        ILogger logger = new<\/span> ConsoleLoger();\n        logger.Log(\"Hello\"<\/span>);\n    }\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
In this example, the ConsoleLogger<\/code><\/code> implements the ILogger<\/code> interface explicitly. Therefore, we prefix the interface name before the method name, separated by a dot (.). Also, we don’t use an access modifier (public<\/code>) for the Log<\/code> method in the ConsoleLogger<\/code><\/code>.<\/p>\n\n\n\n
In the Main()<\/code> method of the Program<\/code> class, we can only access the Log<\/code> method via the ILogger<\/code><\/code> interface. The reason is that the Log<\/code> method belongs to the ILogger<\/code><\/code> interface, not the ConsoleLogger<\/code><\/code> class even though we implement it in the ConsoleLogger<\/code><\/code> class. <\/p>\n\n\n\n
This is also the reason why the Log<\/code> method doesn’t have the public<\/code> access modifier. In other words, you cannot call the Log<\/code> method via an instance of the ConsoleLogger<\/code> class.<\/p>\n\n\n\n
Therefore, the following code will not be compiled and result in an error:<\/p>\n\n\n
ConsoleLoger logger = new<\/span> ConsoleLoger();\nlogger.Log(\"Hello\"<\/span>); \/\/ error<\/span><\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
When to use C# explicit interface implementation<\/h2>\n\n\n\n
The explicit interface implementation allows you to prevent naming conflicts between multiple interfaces.<\/p>\n\n\n\n
Since a class can implement multiple interfaces and these interfaces may have members with the same name. To prevent the naming conflict, you can use the explicit interface implementation.<\/p>\n\n\n\n
The following example demonstrates how to use explicit interface implementation:<\/p>\n\n\n
interface<\/span> IWritable<\/span>\n{\n    void<\/span> Write<\/span>(string<\/span> message<\/span>)<\/span>;\n}\n\ninterface<\/span> ISavable<\/span>\n{\n    void<\/span> Write<\/span>(string<\/span> message<\/span>)<\/span>;\n}\n\nclass<\/span> TextFile<\/span> : IWritable<\/span>, ISavable<\/span>\n{\n    public<\/span> string<\/span> FileName  {  get<\/span>;  set<\/span>; }\n    public<\/span> TextFile<\/span>(string<\/span> filename<\/span>)<\/span>\n    {\n        FileName = filename;\n    }\n    void<\/span> IWritable.Write(string<\/span> message) => Console.WriteLine(message);\n    void<\/span> ISavable.Write(string<\/span> message) => File.WriteAllText(FileName, message);\n}\n\nclass<\/span> Program<\/span>\n{\n    public<\/span> static<\/span> void<\/span> Main<\/span>(string<\/span>[] args<\/span>)<\/span>\n    {\n        var<\/span> textFile = new<\/span> TextFile(@\"C:\\temp\\test.txt\"<\/span>);\n        ISavable savable = textFile;\n        savable.Write(\"Hello\"<\/span>);\n\n        IWritable writable = textFile;\n        writable.Write(\"Hello\"<\/span>);\n\n    }\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
How it works.<\/p>\n\n\n\n
First, define the IWritable<\/code> and ISavable<\/code> interface that has the same method Write<\/code>.<\/p>\n\n\n\n
Second, define the TextFile<\/code> class that implements both IWritable<\/code> and ISavable<\/code> interfaces explicitly.<\/p>\n\n\n\n
Third, create a new instance of the TextFile<\/code>, and call the Write method of the interfaces via ISavable<\/code> and IWritable<\/code> interface respectively.<\/p>\n\n\n\n
The program writes the Hello<\/code> message to the console and to a C:\\temp\\test.txt<\/code> file.<\/p>\n\n\n\n
Summary<\/h2>\n\n\n\n
    \n
  • Explicit interface implementation provides you with a way to implement interface methods with a specific interface prefix (interfaceName.methodName<\/code>).<\/li>\n\n\n\n
  • Explicit interface implementation is useful when you have a class that implements multiple interfaces with the same method name, or when you want to avoid naming conflicts between interface and class methods.<\/li>\n\n\n\n
  • Explicit interface implementation ensures that the method can only be accessed through the interface it belongs to.<\/li>\n<\/ul>\n
    \n\t
    \n\t\t
    Was this tutorial helpful ?<\/div>\n\t\t
    \n\t\t\t\n\t\t\t\t\n\t\t\t\t\t<\/path>\n\t\t\t\t<\/svg>\n\t\t\t\t Yes <\/span>\n\t\t\t<\/button>\n\n\t\t\t\n\t\t\t\t\n\t\t\t\t\t<\/path>\n\t\t\t\t<\/svg>\n\t\t\t\t No <\/span>\n\t\t\t<\/button>\n\t\t<\/div>\n\t<\/header>\n\n\t
    \n\t\t
    \n\t\t\t
    <\/div>\n\t\t\t\n\t\t\t