¿Por qué creamos instancia de objeto desde Interface en lugar de Class?

He visto muchas veces una instancia de Interfaz generada desde una clase. ¿Por qué usa una interfaz de esta manera? Una instancia de interfaz creada solo con la ayuda de la clase derivada y solo podemos acceder a esta interfaz a través de esta instancia. ¿Cómo esto le da una ventaja? Estoy tan confundida..

interface IPrint { void Print(); } class Sample : IPrint { public void Print() { Console.WriteLine("Print..."); } public void Sample() { Console.WriteLine("Sample..."); } } class Program { static void Main(string[] args) { IPrint print = new Sample(); print.Print(); } } 

Las interfaces definen que una clase DEBE poder hacer algo. Esto significa que sabe que el objeto sobre el que se trabajará hará lo que quiera. Le permite una mayor libertad y ventajas de OOP. Este es un tema profundo, pero un ejemplo muy básico sería este:

 public interface IAnimal { string Speak(); } public class Dog : IAnimal { public string Speak() { return "Woof, woof"; } } public class Cat : IAnimal { public string Speak() { return "Meow"; } } public class Parrot : IAnimal { public string Speak() { return "Sqwark!"; } } 

¡Entonces podrías usar cualquier animal que te guste!

 class Program { static void Main(string[] args) { // Writes Woof, Woof IAnimal animal = new Dog(); Console.WriteLine(animal.Speak()); // Now writes Meow animal = new Cat(); Console.WriteLine(animal.Speak()); // Now writes Sqwark etc animal = new Parrot(); Console.WriteLine(animal.Speak()); } } 

Esto también le permite entrar en cosas como Inversión de control donde tomaría un artículo así y podría pasar un perro, gato o loro y el método siempre funcionaría, sin saber o sin importar qué animal era:

 public void ShoutLoud(IAnimal animal) { MessageBox.Show("Shout " + animal.Speak()); } 

Esto hace que la unidad ShoutLoud sea comprobable porque puedes usar un objeto simulado en lugar de un animal real. Básicamente, hace que su código sea flexible y dynamic en lugar de rígido y estrechamente acoplado.

Además, ampliando la pregunta de Mateo. En C #, solo puede heredar de una clase base, pero puede tener múltiples interfaces. Entonces, podrías tener:

 public class Dog : IAnimal, IMammal, ICarnivor 

Esto le permite tener interfaces pequeñas (recomendadas) que le permiten acumularse para tener el máximo control sobre lo que un elemento puede / debe hacer.

El uso de una interfaz de esta manera le brinda la posibilidad de crear métodos que utilizan una plantilla estándar de la interfaz. Así que aquí podría tener muchas clases de impresoras que todas heredan de IPrinter

 class SamsungPrinter : IPrinter { // Stuff and interface members. } class SonyPrinter : IPrinter { // Stuff and interface members. } interface IPrinter { void Print(); } 

Entonces, para cada tipo de SamsungPrinter , SonyPrinter , etc., puede preprocesar utilizando algo así como

 public static void PreProcessAndPrint(IPrinter printer) { // Do pre-processing or something. printer.Print(); } 

Usted sabe, heredando de IPrinter y utilizando ese tipo en los parámetros del método, que siempre puede usar de forma segura el método de Print en cualquier objeto que se pase.

Por supuesto, hay muchos otros usos para usar interfaces. Un ejemplo de su uso se encuentra en los patrones de diseño, en particular, los patrones de Fábrica y Estrategia. La descripción de los cuales y ejemplos se pueden encontrar aquí .

Espero que esto ayude.

Pero, ¿cómo difiere esto de, por ejemplo, el uso de una clase base con métodos virtuales?

Todos están en la suposición de que un progtwigdor o un progtwig escribe la interfaz y las clases, pero esto no siempre tiene que ser así.

Tal vez tengas un progtwig completo que funcione con animales y lo hayas hecho usando:

 public abstract class Animal { public abstract string Speak(); } 

Y luego, algún día, descargarás una impresionante DLL de nuget que muestra imágenes de animales. La biblioteca de clases contiene un contrato – interfaz – ‘IAnimal’:

 namespace AwesomeAnimalLibrary { public interface IAnimal { string AnimalName; } } 

La biblioteca de la clase también puede contener:

 namespace AwesomeAnimalLibrary { public class AnimalPhotos { [Byte] GetPhotos(IAnimal animal); } } 

¿Qué podrías hacer ahora? Su clase de base Animal puede implementar la interfaz AwesomeAnimalLibrary IAnimal y eso es todo.

No asum que otras personas utilizarán sus clases base abstractas, pero trabajarán juntas utilizando contratos de interfaz.

La interfaz no puede tener instancia porque la interfaz implementa solo firmas de propiedades o métodos. La interfaz es solo un puntero a una instancia de alguna clase:

 interface IExample { // method signature void MyMethod(); } public class MyClass : IExample { // method implementation public void MyMethod() { ConsoleWriteline("This is my method"); } } // interface pointing to instance of class IExample ie = new MyClass(); ie.MyMethod();