Interfaces (C# Programming Guide)

Interfaces describe a group of related functionalities that can belong to any class or struct. You define an interface by using the interface keyword, as shown in the following example.


interface IEquatable<T>
{
    bool Equals(T obj);
}


Interfaces consist of methods, properties, events, indexers, or any combination of those four member types. An interface cannot contain constants, fields, operators, instance constructors, destructors, or types. It cannot contain static members. Interfaces members are automatically public, and they cannot include any access modifiers.

When a class or struct implements an interface, the class or struct provides an implementation for all of the members defined by the interface. The interface itself provides no functionality that a class or struct can inherit in the way that base class functionality can be inherited. However, if a base class implements an interface, the derived class inherits that implementation. The derived class is said to implement the interface implicitly.

Classes and structs implement interfaces in a manner similar to how classes inherit a base class or struct, with two exceptions:

  • A class or struct can implement more than one interface.

  • When a class or struct implements an interface, it receives only the method names and signatures, because the interface itself contains no implementations, as shown in the following example.

    
    public class Car : IEquatable<Car>
    {
        public string Make {get; set;}
        public string Model { get; set; }
        public string Year { get; set; }
    
        // Implementation of IEquatable<T> interface
        public bool Equals(Car car)
        {
            if (this.Make == car.Make &&
                this.Model == car.Model &&
                this.Year == car.Year)
            {
                return true;
            }
            else
                return false;
        }
    }
    
    
    

The IEquatable<T> interface announces to the user of the object that the object can determine whether it is equal to other objects of the same type, and the user of the interface does not have to know how this is implemented.

To implement an interface member, the corresponding member of the class must be public, non-static, and have the same name and signature as the interface member. Properties and indexers of a class can define extra accessors for a property or indexer defined on an interface. For example, an interface might declare a property that has a get accessor. The class that implements the interface can declare the same property with both a get and set accessor. However, if the property or indexer uses explicit implementation, the accessors must match. For more information about explicit implementation, see Interface Properties (C# Programming Guide)

Interfaces and interface members are abstract; interfaces do not provide a default implementation. For more information, see Abstract and Sealed Classes and Class Members.

Interfaces can inherit other interfaces. It is possible for a class to inherit an interface multiple times, through base classes it inherits or through interfaces inherited by other interfaces. However, the class can implement an interface only one time, and only if the interface is declared as part of the definition of the class, as in class ClassName : InterfaceName. If the interface is inherited because you inherited a base class that implements the interface, its implementation is provided by the base class. It is also possible for a base class to implement interface members by using virtual members. In that case, a derived class can change the interface behavior by overriding the virtual members. For more information about virtual members, see Polymorphism.

An interface has the following properties:

  • An interface is like an abstract base class: any non-abstract type that implements the interface must implement all its members.

  • An interface cannot be instantiated directly.

  • Interfaces can contain events, indexers, methods, and properties.

  • Interfaces contain no implementation of methods.

  • Classes and structs can implement more than one interface.

  • An interface itself can inherit from multiple interfaces.

Explicit Interface Implementation (C# Programming Guide)

Explains how to create a class member that is specific to an interface.

How to: Explicitly Implement Interface Members (C# Programming Guide)

Provides an example of how to explicitly implement members of interfaces.

How to: Explicitly Implement Members of Two Interfaces (C# Programming Guide)

Provides an example of how to explicitly implement members of interfaces with inheritance.

Interface Properties (C# Programming Guide)

Explains how to declare properties on an interface.

Indexers in Interfaces (C# Programming Guide)

Explains how to declare indexers on an interface.

How to: Implement Interface Events (C# Programming Guide)

Illustrates how an interface can declare an event.

Classes and Structs (C# Programming Guide)

Describes how C# uses objects, classes and structs.

Inheritance (C# Programming Guide)

Explains how C# implements inheritance.

Methods (C# Programming Guide)

Explains the concepts of named methods in the C# programming model.

Polymorphism (C# Programming Guide)

Describes how classes can be used as more than one type in C#.

Abstract and Sealed Classes and Class Members (C# Programming Guide)

Describes how the abstract and sealed keywords affect inheritance.

Properties (C# Programming Guide)

Explains the concept of properties in C#.

Events (C# Programming Guide)

Explains the concept of events in C#.

Indexers (C# Programming Guide)

Explains the concept of indexers in C#.

Was this page helpful?
(1500 characters remaining)
Thank you for your feedback

Community Additions

ADD
Show:
© 2014 Microsoft