interface (Referencia de C#)interface (C# Reference)

Una interfaz define un contrato.An interface defines a contract. Cualquier class o struct que implemente ese contrato debe proporcionar una implementación de los miembros definidos en la interfaz.Any class or struct that implements that contract must provide an implementation of the members defined in the interface. A partir de C# 8.0, una interfaz puede definir una implementación predeterminada de miembros.Beginning with C# 8.0, an interface may define a default implementation for members. También puede definir miembros static para proporcionar una única implementación de funcionalidad común.It may also define static members in order to provide a single implementation for common functionality.

En el ejemplo siguiente, la clase ImplementationClass debe implementar un método denominado SampleMethod que no tiene ningún parámetro y devuelve void.In the following example, class ImplementationClass must implement a method named SampleMethod that has no parameters and returns void.

Para obtener más información y ejemplos, vea Interfaces.For more information and examples, see Interfaces.

EjemploExample

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();
    }
}

Una interfaz puede ser un miembro de un espacio de nombres o una clase.An interface can be a member of a namespace or a class. Una declaración de interfaz puede contener declaraciones (firmas sin ninguna implementación) de los miembros siguientes:An interface declaration can contain declarations (signatures without any implementation) of the following members:

Normalmente, estas declaraciones de miembros anteriores no contienen ningún cuerpo.These preceding member declarations typically do not contain a body. A partir de C# 8.0, un miembro de interfaz puede declarar un cuerpo.Beginning with C# 8.0, an interface member may declare a body. Esto se conoce como implementación predeterminada.This is called a default implementation. Los miembros con cuerpos permiten que la interfaz proporcione una implementación "predeterminada" de las clases y las estructuras que no proporcionan una implementación de invalidación.Members with bodies permit the interface to provide a "default" implementation for classes and structs that don't provide an overriding implementation. Además, a partir de C# 8.0, una interfaz puede incluir:In addition, beginning with C# 8.0, an interface may include:

Es posible que las interfaces no contengan estado de instancia.Interfaces may not contain instance state. Aunque los campos estáticos ahora están permitidos, los campos de instancia no se permiten en las interfaces.While static fields are now permitted, instance fields are not permitted in interfaces. Las propiedades automáticas de instancia no se admiten en las interfaces, ya que declararían de forma implícita un campo oculto.Instance auto-properties are not supported in interfaces, as they would implicitly declare a hidden field. Esta regla tiene un efecto sutil en las declaraciones de propiedad.This rule has a subtle effect on property declarations. En una declaración de interfaz, el código siguiente no declara una propiedad implementada automáticamente como hace en una class o un struct.In an interface declaration, the following code does not declare an auto-implemented property as it does in a class or struct. En su lugar, declara una propiedad que no tiene una implementación predeterminada pero que se debe implementar en cualquier tipo que implemente la interfaz:Instead, it declares a property that doesn't have a default implementation but must be implemented in any type that implements the interface:

public interface INamed
{
  public string Name {get; set;}
}

Una interfaz puede heredar de una o varias interfaces base.An interface can inherit from one or more base interfaces. Cuando una interfaz invalida un método implementado en una interfaz base, debe usar la sintaxis de implementación de interfaz explícita.When an interface overrides a method implemented in a base interface, it must use the explicit interface implementation syntax.

Cuando una lista de tipos base contiene una clase e interfaces base, la clase base debe aparecer primero en la lista.When a base type list contains a base class and interfaces, the base class must come first in the list.

Una clase que implementa una interfaz puede implementar explícitamente miembros de esa interfaz.A class that implements an interface can explicitly implement members of that interface. A un miembro implementado explícitamente solo se puede tener acceso mediante una instancia de la interfaz, y no mediante una instancia de la clase.An explicitly implemented member cannot be accessed through a class instance, but only through an instance of the interface. Además, solo se puede acceder a los miembros de interfaz predeterminados a través de una instancia de la interfaz.In addition, default interface members can only be accessed through an instance of the interface.

Para obtener más información sobre la implementación de interfaz explícita, vea Implementación de interfaz explícita.For more information about explicit interface implementation, see Explicit Interface Implementation.

EjemploExample

En el ejemplo siguiente se muestra la implementación de una interfaz.The following example demonstrates interface implementation. En este ejemplo, la interfaz contiene la declaración de propiedad y la clase contiene la implementación.In this example, the interface contains the property declaration and the class contains the implementation. Cualquier instancia de una clase que implemente IPoint tiene las propiedades de entero x e y.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;
   }

   double Distance
   {
       get;
   }
}

class Point : IPoint
{
   // Constructor:
   public Point(int x, int y)
   {
      X = x;
      Y = y;
   }

   // Property implementation:
   public int X { get; set; }

   public int Y { get; set; }

   // Property implementation
   public double Distance =>
      Math.Sqrt(X * X + Y * Y);

}

class MainClass
{
   static void PrintPoint(IPoint p)
   {
      Console.WriteLine("x={0}, y={1}", p.X, p.Y);
   }

   static void Main()
   {
      IPoint p = new Point(2, 3);
      Console.Write("My Point: ");
      PrintPoint(p);
   }
}
// Output: My Point: x=2, y=3

Especificación del lenguaje C#C# language specification

Para obtener más información, vea la sección Interfaces de Especificación del lenguaje C# y la especificación de características de Miembros de interfaz predeterminados (C# 8.0)For more information, see the Interfaces section of the C# language specification and the feature specification for Default interface members - C# 8.0

Vea tambiénSee also