What exactly is "interface based programming"?

Question

Hey guys,

I often hear/read about interfaced based programming but I am not exactly clear on what that really means. Is interfaced based programming an actual stand alone topic that actually has books written about it? If so, can anyone recommend any good ones?

I came across interface based programming as I was reading about how good APIs are designed and would like to learn more about it. Right now I am not clear how to properly go about designing an API around interfaces.

Any info is greatly appreciated.

Thanks.

Answer 1

It's basically a matter of expressing your dependencies in terms of interfaces instead of concrete classes (or worse, static methods). So if one of your classes needs to perform authentication, it should be provided an IAuthenticator (or whatever).

This means that:

• You can write your code before implementing the real dependency
• You can test via mocking really easily (without having to mock classes, which gets ugly)
• It's clear what you depend on in terms of the API instead of implementation (i.e. you have looser coupling)

Answer 2

Chapter 6 of "Practical API Design" by Jaroslav Tulach is titled "Code Against Interfaces, Not Implementations". It explains that, by coding against an interface rather than a specific implementation, you can decouple modules (or components) in a system and therefore raise the system quality.

Bertrand Meyer in OOSC2 explains clearly why "closing" a system and making it more modular raises its quality.

Answer 3

If you google for interfaces, you will find plenty of information about how useful interfaces may be.

The concept is to define clear interfaces, which will be used by the various components/parts/classes/modules to communicate and interact. Once you have defined what should be the input/output of these interfaces, you can let the various teams to develop whatever is needed to fulfill the interface requirements, including the input/output testing, ... etc

If you follow this pattern, various teams can start developing their part without waiting for the other parts to be ready. In addition to that you can use Unit testing (using fake objects to simulate the other parts which you are not developing, and test your part).

This method is quite the standard for any new programming project and everybody will take this for granted.

Answer 4

This is something that I don't recommend using heavily in C# development.

Interface-based programming is basically programming to interfaces. You develop the interfaces you're going to use an Contracts, and the actual implementation of the interfaces is hidden behind these contracts.

It was very common prior to .NET, as the best way to get reusable components in Windows was via COM, which worked via interfaces everywhere. However, given .NET's ability to support multiple languages with a single runtime (the CLR), as well as it's superior support for versioning when compared with native code, the usefulness of interface based programming is lessened dramatically when you're programming in C# (unless you're trying to make COM components, in which case, you'll still be creating the COM interfaces indirectly from your C# classes).

Answer 5

What you refer to as "interface based programming" is more commonly referred to as programming to an interface. Here is an example below. The benefit is hiding the actual implementation of the interface and allowing your code to be more flexible and easily maintained in the future.

YourInterface foo = CreateYourInterface();
foo.DoWork();
foo.DoMoreWork();

CreateYourInterface() would return a concrete implementation of YourInterface. This allows you to change the functionality of the application by changing one line:

YourInterface foo = CreateYourInterface();

Answer 6

See if these very popular discussions help:

What is the best analogy to help non-oop developers grok interface based programming?

Why would I want to use Interfaces?

When are interfaces needed?

When should one use interfaces?

What is the purpose of interfaces?

Good Case For Interfaces

What does it mean to “program to an interface”?

Answer 7

Interface based programming can be thought of as decoupling the implementation of functionality and how you access the functionality.

You define an interface
interface ICallSomeone { public bool DialNumber(string number); }

and you write your implementation

public class callsomeone: ICallSomeone {
public bool DialNumber(string number) {
//dial number, return results }}

You use the interface without caring about the implementation. If you change the implementation, nothing cares because it just uses the interface.