Interfaces (C# Programming Guide)

  • Makale

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.

Interfaces Overview

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.

In This Section

Interfaces in Learning C# 3.0: Master the Fundamentals of C# 3.0

See Also

Reference

Inheritance (C# Programming Guide)

Concepts

C# Programming Guide

Change History

Date

History

Reason

July 2010

Distinguished between implementation and inheritance. Clarified what can and cannot be included in interfaces.

Customer feedback.