Hiding Members via Explicit Interface Implementation in C#

Explicit Interface Implementation is a complex and rarely used technique that allows a single class to inherit from multiple interfaces that have the same method signature. Explicitly implementing each interface, prepending the interface name to the method, allows the same method signature to exist in the same class. I shall not demonstrate that here, but there are plenty of examples of this online. There is another benefit to explicitly implementing an interface, and that is to hide members from being accessed via the class reference. I’ll create an example of this technique using a factory design pattern and Fruit class and a console application that you can step through via F11. If you create a new C# console application in Visual Studio, then copy and paste all of the below code, you can step through (F11) the code to see how it works. System; { FruitType { Apple, Orange, Banana } { { fruit = Fruit(); ((IFruit)fruit).fruitType = type; (type) { FruitType.Apple: ((IFruit)fruit).color = ; ; FruitType.Banana: ((IFruit)fruit).color = ; ; FruitType.Orange: ((IFruit)fruit).color = ; ; } ((IFruit)fruit).DoOtherHiddenThings(); fruit; } { color { ; } FruitType fruitType { ; } ; } : { pColor; FruitType pFruitType; IFruit.color { { pColor = ; } } FruitType IFruit.fruitType { { pFruitType = ; } } IFruit.DoOtherHiddenThings() { } Color { { pColor; } } FruitType FruitType { { pFruitType; } } } } { { Factory.Fruit apple = Factory.Create(FruitType.Apple); fruitColor = apple.Color; FruitType type = apple.FruitType; } } } using namespace HidingMembersViaExplicitInterfaceImplementation public enum public class Factory Fruit ( ) public static Create FruitType type // the Factory class can modify the properties because it has access to // the private IFruitSetters interface var new switch case "Red" break case "Yellow" break case "Orange" break return // define a private interface containing the setters. private interface IFruit // define the setter in the private interface string set set ( ) void DoOtherHiddenThings // This is the inner class. It has members color and fruitType that should not be modified // by clients, but should be modified by the factory. public class Fruit IFruit private string private // explicitly implement the setters string set value set value void //Does nothing. Just showing how to hide methods too. // create a public getters public string get return public get return class Program ( ) static void Main [] args string // can only read color and fruitType because only the getter is public // and IFruit is private to Factory string First, I call the factory’s Create method and specify via an enumerator what type of fruit I want returned to me. Then, I set hidden properties via the explicit interface implementation, and even call a similarly hidden method that does nothing. The interface IFruit is hidden to the client, being private, and is only accessible from within the factory’s create method. This ensure that I always get a red Apple, a yellow Banana, and orange Orange. This same technique can be utilized to always create your own classes instances in a valid state with value default data, as well as protect read-only members. Yet another benefit can be found using this technique. Often, large interface definitions force a class to implement methods that, for our purposes, make no logical sense for our usage. By implementing them explicitly, we effectively hide those methods from the visible public class instance. About the author... Lee McGraw has worked in the technology industry for over 30 years, first developing on an Apple II. He has served as Enterprise Developer and Architect for entities such as AIG, Ford, Coke, USAA, US Department of Defense and Energy, and many banks.