Why we do create object instance from Interface instead of Class?

Question

I have seen an Interface instance being generated from a class many times. Why do we use interface this way? An interface instance is created only itself with the help of the derived class and we can access only these interface members through this instance. How does this give an advantage? I'm so confused.

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

Answer 1

Interfaces define that a class MUST be able to do something. This means that you know the object being worked on will do what you want to be able to do. It allows you greater freedom and is one of the advantages of OOP. This is a deep topic but a very basic example would be this:

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!";     } }  

Then you could use any animal you like!

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

This also allows you to then get into things like Inversion Of Control where you would take an item in like this and you could pass a dog, cat or parrot and the method would always work, not knowing or caring which animal it was:

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

This then makes ShoutLoud unit testable because you could use a mock object rather than a real animal. It basically makes your code flexible and dynamic rather than rigid and tightly coupled.

Also, expanding on Matthew's question. In C# you can only inherit from one base class but you can have multiple interfaces. So, you could have:

public class Dog : IAnimal, IMammal, ICarnivor 

This allows you to have small interfaces (recommended) that then allow you to build up so giving maximum control over what an item can / must do.