Jon Jagger
jon@jaggersoft.com
Table of Contents 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 Notes DownloadECMA-334 C# Language Specificationpreviousnextprevious at this levelnext at this level 20 Interfacesprevious at this levelnext at this level 20.4 Interface implementationsprevious at this levelnext at this level 20.4.1 Explicit interface member implementations Paragraph 11 For purposes of implementing interfaces, a class or struct may declare explicit interface member implementations. 2 An explicit interface member implementation is a method, property, event, or indexer declaration that references a fully qualified interface member name. [Example: For example
interface ICloneable  
{  
   object Clone();  
}  
interface IComparable  
{  
   int CompareTo(object other);  
}  
class ListEntry: ICloneable, IComparable  
{  
   object ICloneable.Clone() {...}  
   int IComparable.CompareTo(object other) {...}  
}  
Here, ICloneable.Clone and IComparable.CompareTo are explicit interface member implementations. end example] [Example: In some cases, the name of an interface member may not be appropriate for the implementing class, in which case the interface member may be implemented using explicit interface member implementation. A class implementing a file abstraction, for example, would likely implement a Close member function that has the effect of releasing the file resource, and implement the Dispose method of the IDisposable interface using explicit interface member implementation:
interface IDisposable {  
   void Dispose();  
}  
class MyFile: IDisposable {  
   void IDisposable.Dispose() {  
      Close();  
   }  
   public void Close() {  
      // Do what's necessary to close the file  
      System.GC.SuppressFinalize(this);  
   }  
}  
end example]
Paragraph 21 It is not possible to access an explicit interface member implementation through its fully qualified name in a method invocation, property access, or indexer access. 2 An explicit interface member implementation can only be accessed through an interface instance, and is in that case referenced simply by its member name. Paragraph 31 It is a compile-time error for an explicit interface member implementation to include access modifiers, and it is a compile-time error to include the modifiers abstract, virtual, override, or static. Paragraph 41 Explicit interface member implementations have different accessibility characteristics than other members. 2 Because explicit interface member implementations are never accessible through their fully qualified name in a method invocation or a property access, they are in a sense private. 3 However, since they can be accessed through an interface instance, they are in a sense also public. Paragraph 51 Explicit interface member implementations serve two primary purposes: Paragraph 61 For an explicit interface member implementation to be valid, the class or struct must name an interface in its base class list that contains a member whose fully qualified name, type, and parameter types exactly match those of the explicit interface member implementation. [Example: Thus, in the following class
class Shape: ICloneable  
{  
   object ICloneable.Clone() {...}  
   int IComparable.CompareTo(object other) {...}  // invalid  
}  
the declaration of IComparable.CompareTo results in a compile-time error because IComparable is not listed in the base class list of Shape and is not a base interface of ICloneable. Likewise, in the declarations
class Shape: ICloneable  
{  
   object ICloneable.Clone() {...}  
}  
class Ellipse: Shape  
{  
   object ICloneable.Clone() {...} // invalid  
}  
the declaration of ICloneable.Clone in Ellipse results in a compile-time error because ICloneable is not explicitly listed in the base class list of Ellipse. end example]
Paragraph 71 The fully qualified name of an interface member must reference the interface in which the member was declared. [Example: Thus, in the declarations
interface IControl  
{  
   void Paint();  
}  
interface ITextBox: IControl  
{  
   void SetText(string text);  
}  
class TextBox: ITextBox  
{  
   void IControl.Paint() {...}  
   void ITextBox.SetText(string text) {...}  
}  
the explicit interface member implementation of Paint must be written as IControl.Paint. end example]
{ JSL }
Jagger Software Ltd
Company # 4070126
VAT # 762 5213 42
Valid HTML 4.01Valid CSS