interface (C# Reference)

An interface contains only the signatures of methods, properties, events or indexers. A class or struct that implements the interface must implement the members of the interface that are specified in the interface definition. In the following example, class ImplementationClass must implement a method named SampleMethod that has no parameters and returns void.

For more information, see Interfaces (C# Programming Guide).

Example

interface ISampleInterface
{
 void SampleMethod();
}
class ImplementationClass : ISampleInterface
{
 // Explicit interface member implementation: 
 void ISampleInterface.SampleMethod()
 {
 // Method implementation.
 }
 static void Main()
 {
 // Declare an interface instance.
 ISampleInterface obj = new ImplementationClass();
 // Call the member.
 obj.SampleMethod();
 }
}

An interface can be a member of a namespace or a class and can contain signatures of the following members:

• Methods

• Properties

• Indexers

• Events

An interface can inherit from one or more base interfaces.

When a base type list contains a base class and interfaces, the base class must come first in the list.

A class that implements an interface can explicitly implement members of that interface. An explicitly implemented member cannot be accessed through a class instance, but only through an instance of the interface.

For more details and code examples on explicit interface implementation, see Explicit Interface Implementation (C# Programming Guide).

The following example demonstrates interface implementation. In this example, the interface contains the property declaration and the class contains the implementation. Any instance of a class that implements IPoint has integer properties x and y.

interface IPoint
{
 // Property signatures: 
 int x
 {
 get;
 set;
 }
 int y
 {
 get;
 set;
 }
}
class Point : IPoint
{
 // Fields: 
 private int _x;
 private int _y;
 // Constructor: 
 public Point(int x, int y)
 {
 _x = x;
 _y = y;
 }
 // Property implementation: 
 public int x
 {
 get
 {
 return _x;
 }
 set
 {
 _x = value;
 }
 }
 public int y
 {
 get
 {
 return _y;
 }
 set
 {
 _y = value;
 }
 }
}
class MainClass
{
 static void PrintPoint(IPoint p)
 {
 Console.WriteLine("x={0}, y={1}", p.x, p.y);
 }
 static void Main()
 {
 Point p = new Point(2, 3);
 Console.Write("My Point: ");
 PrintPoint(p);
 }
}
// Output: My Point: x=2, y=3

C# Language Specification

For more information, see the following sections in the C# Language Specification:

• 1.9 Interfaces

• 3.4.5 Interface members

• 4.2.4 Interface types

• 10.1.2.2 Interface implementations

• 11.2 Struct interfaces

• 13 Interfaces

See Also

Concepts

C# Programming Guide

Reference

C# Keywords

Reference Types (C# Reference)

Interfaces (C# Programming Guide)

Using Properties (C# Programming Guide)

Using Indexers (C# Programming Guide)

class (C# Reference)

struct (C# Reference)

Interfaces (C# Programming Guide)

Other Resources

C# Reference

Change History