Explicit Interface Implementation
In the
implementation
shown so far, the implementing class (in this case,
Document
) creates a member method with the same
signature and return type as the method detailed in the interface. It
is not necessary to explicitly state that this is an implementation
of an interface; this is understood by the compiler implicitly.
What happens, however, if the class implements two interfaces, each
of which has a method with the same signature? Example 8-5 creates two interfaces:
IStorable
and ITalk
. The latter
implements a Read( )
method
that reads a book aloud. Unfortunately, this conflicts with the
Read( )
method in IStorable
.
Because both IStorable
and
ITalk
have a Read( )
method,
the implementing Document
class must use
explicit implementation
for at least one of the
methods. With explicit implementation, the implementing class
(Document
) explicitly identifies the interface for
the method:
void ITalk.Read( )
This resolves the conflict, but it does create a series of interesting side effects.
First, there is no need to use explicit implementation with the other
method of
Talk
:
public void Talk( )
Because there is no conflict, this can be declared as usual.
More importantly, the explicit implementation method cannot have an access modifier:
void ITalk.Read( )
This method is implicitly public.
In fact, a method declared through explicit implementation cannot be
declared with the abstract
,
virtual
, override
, or
new
modifiers.
Most important, you cannot access ...
Get Programming C#, Second Edition now with the O’Reilly learning platform.
O’Reilly members experience books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.