Interfaces

En capítulos anteriores, hemos visto clases abstractas. Las interfaces son parecidas a las clases abstractas y comparten el hecho de que no se pueden crear instancias de ellas. Sin embargo, las interfaces son aún mas conceptuales que las clases abstractas, dado que no se permiten cuerpos de métodos. Así, una interfaz es como una clase abstracta con nada más que métodos abstractos, y dado que no hay métodos con código real, no hay necesidad de campos. Sí se permiten las propiedades, así como los indexadores y eventos. Puedes considerar una interfaz como un contrato - a la clase que la implemente se le requiere que implemente todos sus métodos y propiedades. Sin embargo, la diferencia más importante es que mientras C# no permite herencia múltiple, donde las clases heredan de más de una única clase base, de hecho permite la implementación de múltiples interfaces!

Entonces, ¿cómo se vería todo esto en el código? Aquí hay un ejemplo completo. Míralo, pruébalo, y luego sigue leyendo la explicación detallada:

using System;
using System.Collections.Generic;

namespace Interfaces
{
    class Program
    {
        static void Main(string[] args)
        {
            List<Dog> dogs = new List<Dog>();
            dogs.Add(new Dog("Fido"));
            dogs.Add(new Dog("Bob"));
            dogs.Add(new Dog("Adam"));
            dogs.Sort();
            foreach(Dog dog in dogs)
                Console.WriteLine(dog.Describe());
            Console.ReadKey();
        }
    }

    interface IAnimal
    {
        string Describe();

        string Name
        {
            get;
            set;
        }
    }

    class Dog : IAnimal, IComparable
    {
        private string name;

        public Dog(string name)
        {
            this.Name = name;
        }

        public string Describe()
        {
            return "Hello, I'm a dog and my name is " + this.Name;
        }

        public int CompareTo(object obj)
        {
            if(obj is IAnimal)
                return this.Name.CompareTo((obj as IAnimal).Name);
            return 0;
        }

        public string Name
        {
            get { return name; }
            set { name = value; }
        }
    }
}

Comencemos en el medio, donde declaramos la interface. Como puede ver, la única diferencia con una declaración de clase es la palabra clave utilizada: interface en lugar de class. Además, el nombre de la interfaz tiene el prefijo I para la interfaz; esto es simplemente un estándar de codificación y no un requisito. Puedes llamar a tus interfaces como quieras, pero como se usan tanto como las clases, que es posible que tengas dificultades para notar la diferencia en algunas partes de tu código, el prefijo I tiene bastante sentido.

Luego declaramos el método Describe, y luego, la propiedad Name, que tiene una palabra clave get y set, convirtiéndola en una propiedad de lectura y escritura. También notará la falta de modificadores de acceso (públicos, privados, protegidos, etc.), y eso se debe a que no están permitidos en una interfaz; todos son públicos de forma predeterminada.

El siguiente es nuestra clase Dog. Observe cómo hereda de otra clase, con los dos puntos entre el nombre de la clase y la clase / interface que se subclasifica / implementa. Sin embargo, en este caso, se implementan dos interfaces para la misma clase, simplemente separadas por una coma. Puede implementar tantas interfaces como desee, pero en este caso solo implementamos dos: nuestra propia interfaz IAnimal y la interfaz .NET IComparable, que es una interfaz compartida para clases que se pueden ordenar. Ahora, como puede ver, hemos implementado tanto el método como la propiedad desde la interfaz IAnimal, así como un método CompareTo desde la interfaz IComparable.

Ahora podría estar pensando: si tenemos que hacer todo el trabajo nosotros mismos, implementando todos los métodos y propiedades, ¿por qué molestarse? Un buen ejemplo de por qué vale la pena, se da en la parte superior de nuestro ejemplo. Aquí, agregamos un montón de objetos Dog a una lista, y luego ordenamos la lista. ¿Cómo sabe la lista cómo clasificar perros? Porque nuestra clase de perros tiene un método CompareTo que puede decir cómo comparar dos perros. ¿Y cómo sabe la lista que nuestro objeto Perro puede hacer exactamente eso, y qué método llamar para comparar a los perros? ¡Porque lo dijimos así, al implementar una interfaz que promete que habrá un método CompareTo! Esta es la verdadera belleza de las interfaces.