Interfaces What s the point

Question

The reason for interfaces truly eludes me  From what I understand  it is kind of a work around for the non-existent multi-inheritance which doesn t exist in C   or so I was told    All I see is  you predefine some members and functions  which then have to be re-defined in the class again  Thus making the interface redundant  It just feels like syntactic    well  junk to me  Please no offense meant  Junk as in useless stuff    In the example given below taken from a different C  interfaces thread on stack overflow  I would just create a base class called Pizza instead of an interface   easy example  taken from a different stack overflow contribution   public interface IPizza       public void Order       public class PepperoniPizza   IPizza       public void Order                   Order Pepperoni pizza          public class HawaiiPizza   IPizza       public void Order                   Order HawaiiPizza

User · Answer

No one has really explained in plain terms how interfaces are useful, so I'm going to give it a shot (and steal an idea from Shamim's answer a bit).

Lets take the idea of a pizza ordering service. You can have multiple types of pizzas and a common action for each pizza is preparing the order in the system. Each pizza has to be prepared but each pizza is prepared differently. For example, when a stuffed crust pizza is ordered the system probably has to verify certain ingredients are available at the restaurant and set those aside that aren't needed for deep dish pizzas.

When writing this in code, technically you could just do

public class Pizza()
{
    public void Prepare(PizzaType tp)
    {
        switch (tp)
        {
            case PizzaType.StuffedCrust:
                // prepare stuffed crust ingredients in system
                break;

            case PizzaType.DeepDish:
                // prepare deep dish ingredients in system
                break;

            //.... etc.
        }
    }
}

However, deep dish pizzas (in C# terms) may require different properties to be set in the Prepare() method than stuffed crust, and thus you end up with a lot of optional properties, and the class doesn't scale well (what if you add new pizza types).

The proper way to solve this is to use interface. The interface declares that all Pizzas can be prepared, but each pizza can be prepared differently. So if you have the following interfaces:

public interface IPizza
{
    void Prepare();
}

public class StuffedCrustPizza : IPizza
{
    public void Prepare()
    {
        // Set settings in system for stuffed crust preparations
    }
}

public class DeepDishPizza : IPizza
{
    public void Prepare()
    {
        // Set settings in system for deep dish preparations
    }
}

Now your order handling code does not need to know exactly what types of pizzas were ordered in order to handle the ingredients. It just has:

public PreparePizzas(IList<IPizza> pizzas)
{
    foreach (IPizza pizza in pizzas)
        pizza.Prepare();
}

Even though each type of pizza is prepared differently, this part of the code doesn't have to care what type of pizza we are dealing with, it just knows that it's being called for pizzas and therefore each call to Prepare will automatically prepare each pizza correctly based on its type, even if the collection has multiple types of pizzas.

User · Answer

Interfaces are for applying connection between different classes  for example  you have a class for car and a tree   public class Car          public class Tree           you want to add a burnable functionality for both classes  But each class have their own ways to burn  so you simply make   public class Car   IBurnable   public void Burn              public class Tree   IBurnable   public void Burn

User · Answer

I know I am very late    almost nine years   but if someone wants small explanation then you can go for this   In simple words  you use Interface when you know what an Object can do or what function we are going to implement on an object   Example Insert Update  and Delete   interface ICRUD        void InsertData       will insert data       void UpdateData       will update data       void DeleteData       will delete data     Important Note  Interfaces are ALWAYS public   Hope this helps

User · Answer

The simplest way to think about interfaces is to recognize what inheritance means   If class CC inherits class C  it means both that    Class CC can use any public or protected members of class C as though they were its own  and thus only needs to implement things which do not exist in the parent class  A reference to a CC can be passed or assigned to a routine or variable that expects a reference to a C    Those two function of inheritance are in some sense independent  although inheritance applies both simultaneously  it is also possible to apply the second without the first   This is useful because allowing an object to inherit members from two or more unrelated classes is much more complicated than allowing one type of thing to be substitutable for multiple types   An interface is somewhat like an abstract base class  but with a key difference  an object which inherits a base class cannot inherit any other class   By contrast  an object may implement an interface without affecting its ability to inherit any desired class or implement any other interfaces   One nice feature of this  underutilized in the  net framework  IMHO  is that they make it possible to indicate declaratively the things an object can do   Some objects  for example  will want data-source object from which they can retrieve things by index  as is possible with a List   but they won t need to store anything there   Other routines will need a data-depository object where they can store things not by index  as with Collection Add   but they won t need to read anything back   Some data types will allow access by index  but won t allow writing  others will allow writing  but won t allow access by index   Some  of course  will allow both   If ReadableByIndex and Appendable were unrelated base classes  it would be impossible to define a type which could be passed both to things expecting a ReadableByIndex and things expecting an Appendable   One could try to mitigate this by having ReadableByIndex or Appendable derive from the other  the derived class would have to make available public members for both purposes  but warn that some public members might not actually work   Some of Microsoft s classes and interfaces do that  but that s rather icky   A cleaner approach is to have interfaces for the different purposes  and then have objects implement interfaces for the things they can actually do   If one had an interface IReadableByIndex and another interface IAppendable  classes which could do one or the other could implement the appropriate interfaces for the things they can do

User · Answer

Here s an interface for objects that have a rectangular shape   interface IRectangular       Int32 Width        Int32 Height        All it demands is that you implement ways to access the width and height of the object   Now let s define a method that will work on any object that is IRectangular   static class Utils       public static Int32 Area IRectangular rect                return rect Width     rect Height              That will return the area of any rectangular object   Let s implement a class SwimmingPool that is rectangular   class SwimmingPool   IRectangular       int width      int height       public SwimmingPool int w  int h        width   w  height   h         public int Width     return width        public int Height     return height        And another class House that is also rectangular   class House   IRectangular       int width      int height       public House int w  int h        width   w  height   h         public int Width     return width        public int Height     return height        Given that  you can call the Area method on houses or swimming-pools   var house   new House 2  3    var pool   new SwimmingPool 3  4    Console WriteLine Utils Area house    Console WriteLine Utils Area pool      In this way  your classes can  inherit  behavior  static-methods  from any number of interfaces

User · Answer

Therese are ask really great examples   Another  in the case of a switch statement  you no longer have the need to maintain and switch every time you want rio perform a task in a specific way    In your pizza example  if want to make a pizza  the interface is all you need  from there each pizza takes care of it s own logic     This helps to reduce coupling and cyclomatic complexity  You have to still implement the logic but there will be less you have to keep track of in the broader picture    For each pizza you can then keep track of information specific to that pizza  What other pizzas have doesn t matter because only the other pizzas need to know

User · Answer

The point is that the interface represents a contract  A set of public methods any implementing class has to have  Technically  the interface only governs syntax  i e  what methods are there   what arguments they get and what they return  Usually they encapsulate semantics as well  although that only by documentation   You can then have different implementations of an interface and swap them out at will  In your example  since every pizza instance is an IPizza you can use IPizza wherever you handle an instance of an unknown pizza type  Any instance whose type inherits from IPizza is guaranteed to be orderable  as it has an Order   method   Python is not statically-typed  therefore types are kept and looked up at runtime  So you can try calling an Order   method on any object  The runtime is happy as long as the object has such a method and probably just shrugs and says   Meh    if it doesn t  Not so in C   The compiler is responsible for making the correct calls and if it just has some random object the compiler doesn t know yet whether the instance during runtime will have that method  From the compiler s point of view it s invalid since it cannot verify it   You can do such things with reflection or the dynamic keyword  but that s going a bit far right now  I guess    Also note that an interface in the usual sense does not necessarily have to be a C  interface  it could be an abstract class as well or even a normal class  which can come in handy if all subclasses need to share some common code     in most cases  however  interface suffices

User · Answer

The Pizza example is bad because you should be using an abstract class that handles the ordering  and the pizzas should just override the pizza type  for example   You use interfaces when you have a shared property  but your classes inherit from different places  or when you don t have any common code you could use  For instance  this is used things that can be disposed IDisposable  you know it will be disposed  you just don t know what will happen when it s disposed   An interface is just a contract that tells you some things an object can do  what parameters and what return types to expect

User · Answer

Interfaces can also be daisy chained to create yet another interface  This ability to implement multiple Interfaces give the developer the advantage of adding functionality to their classes without having to change current class functionality  SOLID Principles    O    Classes should be open for extension but closed for modification

User · Answer

In the absence of duck typing as you can use it in Python  C  relies on interfaces to provide abstractions  If the dependencies of a class were all concrete types  you could not pass in any other type - using interfaces you can pass in any type that implements the interface

User · Answer

Simple Explanation with analogy  The Problem to Solve  What is the purpose of polymorphism   Analogy  So I m a foreperson on a construction site   Tradesmen walk on the construction site all the time  I don t know who s going to walk through those doors  But I basically tell them what to do    If it s a carpenter I say  build wooden scaffolding  If it s a plumber  I say   Set up the pipes  If it s an electrician  I say   Pull out the cables  and replace them with fibre optic ones     The problem with the above approach is that I have to   i  know who s walking in that door  and depending on who it is  I have to tell them what to do  That means I have to know everything about a particular trade  There are costs benefits associated with this approach   The implications of knowing what to do    This means if the carpenter s code changes from  BuildScaffolding   to BuildScaffold    i e  a slight name change  then I will have to also change the calling class  i e  the Foreperson class  as well - you ll have to make two changes to the code instead of  basically  just one  With polymorphism you  basically  only need to make one change to achieve the same result  Secondly you won t have to constantly ask  who are you  ok do this   who are you  ok do that     polymorphism - it DRYs that code  and is very effective in certain situations  with polymorphism you can easily add additional classes of tradespeople without changing any existing code   i e  the second of the SOLID design principles  Open-close principle      The solution  Imagine a scenario where  no matter who walks in the door  I can say   Work    and they do their respect jobs that they specialise in   the plumber would deal with pipes  and the electrician would deal with wires   The benefit of this approach is that   i  I don t need to know exactly who is walking in through that door - all i need to know is that they will be a type of tradie and that they can do work  and secondly   ii  i don t need to know anything about that particular trade  The tradie will take care of that   So instead of this   If electrician  then  electrician FixCablesAndElectricity     if plumber  then plumber IncreaseWaterPressureAndFixLeaks      I can do something like this   ITradesman tradie   Tradesman Factory       in reality i know it s a plumber  but in the real world you won t know who s on the other side of the tradie assignment   tradie Work       and then tradie will do the work of a plumber  or electrician etc  depending on what type of tradesman he is  The foreman doesn t need to know anything  apart from telling the anonymous tradie to get to Work       What s the benefit   The benefit is that if the specific job requirements of the carpenter etc change  then the foreperson won t need to change his code - he doesn t need to know or care  All that matters is that the carpenter knows what is meant by Work    Secondly  if a new type of construction worker comes onto the job site  then the foreman doesn t need to know anything about the trade - all the foreman cares is if the construction worker   e g Welder  Glazier  Tiler etc   can get some Work   done     Illustrated Problem and Solution  With and Without Interfaces    No interface  Example 1      No interface  Example 2      With an interface     Summary  An interface allows you to get the person to do the work they are assigned to  without you having the knowledge of exactly who they are or the specifics of what they can do  This allows you to easily add new types  of trade  without changing your existing code  well technically you do change it a tiny tiny bit   and that s the real benefit of an OOP approach vs  a more functional programming methodology   If you don t understand any of the above or if it isn t clear ask in a comment and i ll try to make the answer better

User · Answer

Interface   contract  used for loose coupling  see GRASP

User · Answer

I share your sense that Interfaces are not necessary  Here is a quote from Cwalina pg 80 Framework Design Guidelines  I often here people saying that interfaces specify contracts  I believe this a dangerous myth  Interfaces by themselves do not specify much       He and co-author Abrams managed 3 releases of  Net for Microsoft  He goes on to say that the  contract  is  expressed  in an implementation of the class  IMHO watching this for decades  there were many people warning Microsoft that taking the engineering paradigm to the max in OLE COM might seem good but its usefulness is more directly to hardware  Especially in a big way in the 80s and 90s getting interoperating standards codified  In our TCP IP Internet world there is little appreciation of the hardware and software gymnastics we would jump through to get solutions  wired up  between and among mainframes  minicomputers  and microprocessors of which PCs were just a small minority  So coding to interfaces and their protocols made computing work  And interfaces ruled  But what does solving making X 25 work with your application have in common with posting recipes for the holidays  I have been coding C   and C  for many years and I never created one once

User · Answer

You will get interfaces  when you will need them    You can study examples  but you need the Aha  effect to really get them   Now that you know what interfaces are  just code without them  Sooner or later you will run into a problem  where the use of interfaces will be the most natural thing to do

User · Answer

There are a lot of good answers here but I would like to try from a slightlt different perspective   You may be familiar with the SOLID principles of object oriented design  In summary   S - Single Responsibility Principle O - Open Closed Principle L - Liskov Substitution Principle I - Interface Segregation Principle D - Dependency Inversion Principle  Following the SOLID principles helps to produce code that is clean  well factored  cohesive and loosely coupled  Given that       Dependency management is the key challenge in software at every scale   Donald Knuth    then anything that helps with dependency management is a big win  Interfaces and the Dependency Inversion Principle really help to decouple code from dependencies on concrete classes  so code can be written and reasoned about in terms of behaviours rather than implementations  This helps to break the code into components which can be composed at runtime rather than compile time and also means those components can be quite easily plugged in and out without having to alter the rest of the code   Interfaces help in particular with the Dependency Inversion Principle  where code can be componentized into a collection of services  with each service being described by an interface  Services can then be  injected  into classes at runtime by passing them in as a constructor parameter  This technique really becomes critical if you start to write unit tests and use test driven development  Try it  You will quickly understand how interfaces help to break apart the code into manageable chunks that can be individually tested in isolation

User · Answer

Consider you can t use multiple inheritance in C   and then look at your question again

User · Answer

Consider the case where you don t control or own the base classes   Take visual controls for instance  in  NET for Winforms they all inherit from the base class Control  that is completely defined in the  NET framework   Let s assume you re in the business of creating custom controls  You want to build new buttons  textboxes  listviews  grids  whatnot and you d like them all to have certain features unique to your set of controls   For instance you might want a common way to handle theming  or a common way to handle localization   In this case you can t  just create a base class  because if you do that  you have to reimplement everything that relates to controls   Instead you will descend from Button  TextBox  ListView  GridView  etc  and add your code   But this poses a problem  how can you now identify which controls are  yours   how can you build some code that says  for all the controls on the form that are mine  set the theme to X    Enter interfaces   Interfaces are a way to look at an object  to determine that the object adheres to a certain contract   You would create  YourButton   descend from Button  and add support for all the interfaces you need   This would allow you to write code like the following   foreach  Control ctrl in Controls        if  ctrl is IMyThemableControl            IMyThemableControl ctrl  SetTheme newTheme       This would not be possible without interfaces  instead you would have to write code like this   foreach  Control ctrl in Controls        if  ctrl is MyThemableButton            MyThemableButton ctrl  SetTheme newTheme       else if  ctrl is MyThemableTextBox            MyThemableTextBox ctrl  SetTheme newTheme       else if  ctrl is MyThemableGridView            MyThemableGridView ctrl  SetTheme newTheme       else

User · Answer

In this case  you could   and probably would   just define a Pizza base class and inherit from them  However  there are two reasons where Interfaces allow you to do things that cannot be achieved in other ways    A class can implement multiple interfaces  It just defines features that the class must have  Implementing a range of interfaces means that a class can fulfil multiple functions in different places  An interface can be defined in a hogher scope than the class or the caller  This means that you can separate the functionality  separate the project dependency  and keep the functionality in one project or class  and the implementation of this elsewhere    One implication of 2 is that you can change the class that is being used  just requiring that it implements the appropriate interface

User · Answer

An interface defines a contract between the provider of a certain functionality and the correspondig consumers  It decouples the implementation from the contract  interface   You should have a look at object oriented architecture and design  You may want to start with wikipedia  http   en wikipedia org wiki Interface  computing

User · Answer

For me  when starting out  the point to these only became clear when you stop looking at them as things to make your code easier faster to write - this is not their purpose  They have a number of uses    This is going to lose the pizza analogy  as it s not very easy to visualise a use of this   Say you are making a simple game on screen and It will have creatures with which you interact   A  They can make your code easier to maintain in the future by introducing a loose coupling between your front end and your back end implementation     You could write this to start with  as there are only going to be trolls      This is our back-end implementation of a troll class Troll       void Walk int distance                  Implementation here           Front end   function SpawnCreature         Troll aTroll   new Troll         aTroll Walk 1       Two weeks down the line  marketing decide you also need Orcs  as they read about them on twitter  so you would have to do something like   class Orc       void Walk int distance                  Implementation  orcs are faster than trolls            Front end   void SpawnCreature creatureType        switch creatureType                 case Orc              Orc anOrc   new Orc               anORc Walk               case Troll               Troll aTroll   new Troll                 aTroll Walk              And you can see how this starts to get messy   You could use an interface here so that your front end would be written once and  here s the important bit  tested  and you can then plug in further back end items as required   interface ICreature       void Walk int distance     public class Troll   ICreature public class Orc   ICreature     etc   Front end is then   void SpawnCreature creatureType        ICreature creature       switch creatureType                 case Orc              creature   new Orc               case Troll               creature   new Troll               creature Walk        The front end now only cares about the interface ICreature - it s not bothered about the internal implementation of a troll or an orc  but only on the fact that they implement ICreature   An important point to note when looking at this from this point of view is that you could also easily have used an abstract creature class  and from this perspective  this has the same effect    And you could extract the creation out to a factory   public class CreatureFactory     public ICreature GetCreature creatureType         ICreature creature       switch creatureType                 case Orc              creature   new Orc               case Troll               creature   new Troll               return creature          And our front end would then become   CreatureFactory  factory   void SpawnCreature creatureType        ICreature creature    factory GetCreature creatureType        creature Walk        The front end now does not even have to have a reference to the library where Troll and Orc are implemented  providing the factory is in a separate library  - it need know nothing about them whatsoever   B  Say you have functionality that only some creatures will have in your otherwise homogenous data structure  e g   interface ICanTurnToStone      void TurnToStone       public class Troll  ICreature  ICanTurnToStone   Front end could then be   void SpawnCreatureInSunlight creatureType        ICreature creature       switch creatureType                 case Orc              creature   new Orc               case Troll               creature   new Troll               creature Walk         if  creature is ICanTurnToStone                ICanTurnToStone creature TurnToStone              C  Usage for dependency injection  Most dependency injection frameworks are easier to work with when there is a very loose coupling between the front end code and the back end implementation   If we take our factory example above and have our factory implement an interface   public interface ICreatureFactory        ICreature GetCreature string creatureType       Our front end could then have this injected  e g an MVC API controller  through the constructor  typically    public class CreatureController   Controller       private readonly ICreatureFactory  factory      public CreatureController ICreatureFactory factory          factory   factory           public HttpResponseMessage TurnToStone string creatureType            ICreature creature    factory GetCreature creatureType           creature TurnToStone            return Request CreateResponse HttpStatusCode OK            With our DI framework  e g  Ninject or Autofac   we can set them up so that at runtime a instance of CreatureFactory will be created whenever an ICreatureFactory is needed in an constructor - this makes our code nice and simple    It also means that when we write a unit test for our controller  we can provide a mocked ICreatureFactory  e g  if the concrete implementation required DB access  we don t want our unit tests dependent on that  and easily test the code in our controller   D  There are other uses e g  you have two projects A and B that for  legacy  reasons are not well structured  and A has a reference to B     You then find functionality in B that needs to call a method already in A  You can t do it using concrete implementations as you get a circular reference   You can have an interface declared in B that the class in A then implements  Your method in B can be passed an instance of a class that implements the interface with no problem  even though the concrete object is of a type in A

User · Answer

What   Interfaces are basically a contract that all the classes implementing the Interface should follow  They looks like a class but has no implementation  In C  Interface names by convention is defined by Prefixing an  I  so if you want to have an interface called shapes  you would declare it as IShapes Now Why   Improves code re-usability Lets say you want to draw Circle  Triangle    You can group them together and call them Shapesand have methods to draw Circle and Triangle But having concrete implementation would be a bad idea because tomorrow you might decide to have 2 more Shapes Rectangle  amp  Square  Now when you add them there is a great chance that you might break other parts of your code  With Interface you isolate the different implementation from the Contract  Live Scenario Day 1 You were asked to create an App to Draw Circle and Triangle interface IShapes      void DrawShape            class Circle   IShapes            public void DrawShape                 Console WriteLine  quot Implementation to Draw a Circle quot             Class Triangle  IShapes        public void DrawShape                 Console WriteLine  quot Implementation to draw a Triangle quot              static void Main          List  lt IShapes gt  shapes   new List lt IShapes gt             shapes Add new Circle             shapes Add new Triangle              foreach var shape in shapes                        shape DrawShape                 Live Scenario Day 2 If you were asked add Square and Rectangle to it  all you have to do is create the implentation for it in class Square  IShapes and in Main add to list shapes Add new Square

User · Answer

Examples above don t make much sense  You could accomplish all above examples using classes  abstract class if you want it to behave only as a contract    public abstract class Food       public abstract void Prepare       public class Pizza   Food        public override void Prepare        Prepare pizza         public class Burger   Food        public override void Prepare        Prepare Burger          You get the same behavior as with interface  You can create a List lt Food gt  and iterate that w o knowing what class sits on top   More adequate example would be multiple inheritance   public abstract class MenuItem       public string Name   get  set        public abstract void BringToTable          Notice Soda only inherits from MenuItem public class Soda   MenuItem       public override void BringToTable        Bring soda to table             All food needs to be cooked  real food  so we add this    feature to all food menu items public interface IFood       void Cook       public class Pizza   MenuItem  IFood       public override void BringToTable        Bring pizza to table          public void Cook        Cook Pizza         public class Burger   MenuItem  IFood       public override void BringToTable        Bring burger to table          public void Cook        Cook Burger          Then you can use all of them as MenuItem and don t care about how they handle each method call   public class Waiter       public void TakeOrder IEnumerable lt MenuItem gt  order                    Cook first             all except soda because soda is not IFood          foreach  var food in order OfType lt IFood gt                 food Cook                Bring them all to the table             everything  including soda  pizza and burger because they re all menu items          foreach  var menuItem in order              menuItem BringToTable

User · Answer

Interfaces are used to drive consistency in a manner that is loosely coupled which makes it different to abstract class which is tightly coupled That s why its also commonly defined as a contract Whichever classes that implements the interface has abide to  rules syntax  defined by the interface and there is no concrete elements within it   I ll just give an example supported by the graphic below   Imagine in a factory there are 3 types of machines A rectangle machine a triangle machine and a polygon machine Times are competitive and you want to streamline operator training You just want to train them in one methodology of starting and stopping machines so you have a green start button and red stop button So now across 3 different machines you have a consistent way of starting and stopping 3 different types of machines Now imagine these machines are classes and the classes need to have start and stop methods how you going to drive consistency across these classes which can be very different  Interface is the answer     A simple example to help you visualize one might ask why not use abstract class  With an interface the objects don t have to be directly related or inherited and you can still drive consistency across different classes     public interface IMachine       bool Start        bool Stop       public class Car   IMachine       public bool Start                 Console WriteLine  Car started            return true             public bool Stop                 Console WriteLine  Car stopped            return false           public class Tank   IMachine       public bool Start                 Console WriteLine  Tank started            return true             public bool Stop                 Console WriteLine  Tank stopped            return false           class Program       static void Main string   args                var car   new Car            car Start            car Stop             var tank   new Tank            tank Start            tank Stop

User · Answer

I did a search for the word  composition  on this page and didn t see it once   This answer is very much in addition to the answers aforementioned   One of the absolutely crucial reasons for using interfaces in an Object Oriented Project is that they allow you to favour composition over inheritance   By implementing interfaces you can decouple your implementations from the various algorithms you are applying to them   This superb  Decorator Pattern  tutorial by Derek Banas  which - funnily enough - also uses pizza as an example  is a worthwhile illustration   https   www youtube com watch v j40kRwSm4VE

User · Answer

The main purpose of the interfaces is that it makes a contract between you and any other class that implement that interface which makes your code decoupled and allows expandability

User · Answer

An interface is really a contract that the implementing classes must follow  it is in fact the base for pretty much every design pattern I know   In your example  the interface is created because then anything that IS A Pizza  which means implements the Pizza interface  is guaranteed to have implemented   public void Order      After your mentioned code you could have something like this   public void orderMyPizza IPizza myPizza      This will always work  because everyone MUST implement order       myPizza order        This way you are using polymorphism and all you care is that your objects respond to order

User · Answer

I m surprised that not many posts contain the one most important reason for an interface  Design Patterns  It s the bigger picture into using contracts  and although it s a syntax decoration to machine code  to be honest  the compiler probably just ignores them   abstraction and interfaces are pivotal for OOP  human understanding  and complex system architectures   Let s expand the pizza analogy to say a full fledge 3 course meal  We ll still have the core Prepare   interface for all our food categories  but we d also have abstract declarations for course selections  starter  main  dessert   and differing properties for food types  savoury sweet  vegetarian non-vegetarian  gluten free etc    Based on these specifications  we could implement the Abstract Factory pattern to conceptualise the whole process  but use interfaces to ensure that only the foundations were concrete  Everything else could become flexible or encourage polymorphism  yet maintain encapsulation between the different classes of Course that implement the ICourse interface    If I had more time  I d like to draw up a full example of this  or someone can extend this for me  but in summary  a C  interface would be the best tool in designing this type of system

User · Answer

To me an advantage benefit of an interface is that it is more flexible than an abstract class   Since you can only inherit 1 abstract class but you can implement multiple interfaces  changes to a system that inherits an abstract class in many places becomes problematic   If it is inherited in 100 places  a change requires changes to all 100   But  with the interface  you can place the new change in a new interface and just use that interface where its needed  Interface Seq  from SOLID    Additionally  the memory usage seems like it would be less with the interface as an object in the interface example is used just once in memory despite how many places implement the interface

User · Answer

If I am working on an API to draw shapes  I may want to use DirectX or graphic calls  or OpenGL   So  I will create an interface  which will abstract my implementation from what you call   So you call a factory method  MyInterface i   MyGraphics getInstance     Then  you have a contract  so you know what functions you can expect in MyInterface   So  you can call i drawRectangle or i drawCube and know that if you swap one library out for another  that the functions are supported   This becomes more important if you are using Dependency Injection  as then you can  in an XML file  swap implementations out   So  you may have one crypto library that can be exported that is for general use  and another that is for sale only to American companies  and the difference is in that you change a config file  and the rest of the program isn t changed   This is used a great deal with collections in  NET  as you should just use  for example  List variables  and don t worry whether it was an ArrayList or LinkedList   As long as you code to the interface then the developer can change the actual implementation and the rest of the program is left unchanged   This is also useful when unit testing  as you can mock out entire interfaces  so  I don t have to go to a database  but to a mocked out implementation that just returns static data  so I can test my method without worrying if the database is down for maintenance or not

User · Answer

class Program       static void Main string   args            IMachine machine   new Machine            machine Run            Console ReadKey              class Machine   IMachine       private void Run             Console WriteLine  Running                 void IMachine Run     gt  Run       interface IMachine       void Run        Let me describe this by a different perspective  Let   s create a story according to the example which i have shown above   Program  Machine and IMachine are the actors of our story  Program wants to run but it has not that ability and Machine knows how to run  Machine and IMachine are best friends but Program is not on speaking terms with Machine  So Program and IMachine make a deal and decided that IMachine will tell to Program how to run by looking Machine like a reflector    And Program learns how to run by help of IMachine   Interface provides communication and developing loosely coupled projects   PS  I   ve the method of concrete class as private  My aim in here is to achieve loosely coupled by preventing accessing concrete class properties and methods  and left only allowing way to reach them via interfaces   So i defined interfaces    methods explicitily

User · Answer

Here are your examples reexplained   public interface IFood    not Pizza       public void Prepare        public class Pizza   IFood       public void Prepare      Not order for explanations sake                 Prepare Pizza          public class Burger   IFood       public void Prepare                   Prepare Burger

[c#] Interfaces — What's the point?

Examples related to c#

Examples related to .net

Examples related to interface