C# 0 The Complete Reference

new

.

Explicit Implementations

When implementing a member of an interface, it is possible to 

fully qualify

 its name with 

its interface name. Doing this creates an 

explicit interface member implementation,

 or 

explicit

implementation,

 for short. For example, given

interface IMyIF {

  int MyMeth(int x);

}

then it is legal to implement 

IMyIF

 as shown here:

class MyClass : IMyIF {

  int IMyIF.MyMeth(int x) {

    return x / 3;

  }

}

As you can see, when the 

MyMeth( )

 member of 

IMyIF

 is implemented, its complete name, 

including its interface name, is specified.

There are two reasons that you might need to create an explicit implementation of an 

interface method. First, when you implement an interface method using its fully qualified 

name, you are providing an implementation that 

cannot

 be accessed through an object of the 

class. Instead, it must be accessed via an interface reference. Thus, an explicit implementation 

gives you a way to implement an interface method so that it is not a public member of the 

www.freepdf-books.com

---

324

 

P a r t   I :  

T h e   C #   L a n g u a g e

class that provides the implementation. Second, it is possible for a class to implement two 

interfaces, both of which declare methods by the same name and type signature. Qualifying 

the names with their interfaces removes the ambiguity from this situation. Let’s look at an 

example of each.

The following program contains an interface called 

IEven

, which defines two methods, 

IsEven( )

 and 

IsOdd( )

, which determine if a number is even or odd. 

MyClass

 then implements 

IEven

. When it does so, it implements 

IsOdd( )

 explicitly.

// Explicitly implement an interface member.

using System;

interface IEven {

  bool IsOdd(int x);

  bool IsEven(int x);

}

class MyClass : IEven {

  // Explicit implementation. Notice that this member is private

  // by default.

  bool IEven.IsOdd(int x) {

    if((x%2) != 0) return true;

    else return false;

  }

  // Normal implementation.

  public bool IsEven(int x) {

    IEven o = this; // Interface reference to the invoking object.

    return !o.IsOdd(x);

  }

}

class Demo {

  static void Main() {

    MyClass ob = new MyClass();

    bool result;

    result = ob.IsEven(4);

    if(result) Console.WriteLine("4 is even.");

    // result = ob.IsOdd(4); // Error, IsOdd not exposed.

    // But, this is OK. It creates an IEven reference to a MyClass object

    // and then calls IsOdd() through that reference.

    IEven iRef = (IEven) ob;

    result = iRef.IsOdd(3);

    if(result) Console.WriteLine("3 is odd.");

  }

}

www.freepdf-books.com

---