Not grasping API using interfaces

Question

I've just been handed an API that seems to be a step up from what I'm used to, as everything appears to be implemented using interfaces, and I'm struggling to get my head around them.

public partial class Form1 : Form, IFoo
{
    public Form1()
    {
        InitializeComponent();
    }

    private void button1_Click(object sender, EventArgs e)
    {
        Guid jobID = AddBarToFoo(fooID, barPath);
    }

    public Guid IFoo.AddBarToFoo(string fooID, string barPath)
    {
        throw new NotImplementedException();
    }

So that's a basic structure. Visual Studio has kindly implemented the interface in its entirety and I can call the AddBarToFoo method. Great.

But now what? Evidently the method is a void that requires some code, but what code? Should I be scouring the API for objects to instantiate with that method? Or am I going down completely the wrong path?

It should return a `Guid`, it's not `void`. Basically, the 'API' 'knows' of this interface and could call the method on which types it is implemented - it should be in the specification what/how you're expected to produce that Guid. — Grant Thomas, Feb 01 '12 at 13:56
The code can be whatever you want it to be depending on your product specification. — JConstantine, Feb 01 '12 at 13:57

Yuck · Accepted Answer · 2012-02-01T14:05:03.683

That's the thing with interfaces. They only define how someone will call them. They say absolutely nothing about what the method should really do, or how it should do it. That's up to the person implementing the interface to decide.

VS "implements" the method by adding the single line throw new NotImplementedException(); which is really just to satisfy the compiler.

Here's two possible (contrived) implementations that do totally different things. Both implement IFoo:

public class DbFoo:IFoo {
    public Guid IFoo.AddBarToFoo(string fooID, string barPath) {
        // this might add a Foo to the database and return its Guid
    }
}

public class ListBasedFoo:IFoo {
    public ListBasedFoo() { MyList = new List<Foo>(); }

    public List<Foo> MyList { get; private set; }

    public Guid IFoo.AddBarToFoo(string fooID, string barPath) {
        // this could add a Foo to MyList, and return some Guid to reference it
    }
}

Edit... You'll see interfaces used a lot in places where the abstract behavior is important, but the implementation can vary. For instance, an interface to persist objects. During development you might want to use a mock that puts and gets items into a list in memory. Later you might use an interface that directly hits a database via ADO .NET or Entity Framework or LINQ to SQL. Maybe at another point in the application's lifetime a new implementation would be dropped in that uses WCF web services instead.

The point in my above example is that the calling code won't break. The interface is satisfied - only the behavior has been changed.

thanks. What this made clear (and the other comments) is that my understanding of interfaces wasn't totally wrong, it's just that I've been given the documentation for most of the code base, but only a section of that is the actual API. There's nothing more than the auto-generated documentation from the code itself (this is standard for this particular company), so I'm having to pick it apart. Thanks for helping me along with interfaces though! Much appreciated. — David M, Feb 01 '12 at 14:44

Tigran · Answer 2 · 2012-02-01T15:01:33.573

Interface is contract that you're going to sign, in the moment you implement it. So what you should do in this method, it depends on what you're gonna do with this interface.

public class MyFooImplementation:IFoo {
    public Guid IFoo.AddBarToFoo(string fooID, string barPath) {
        // do somethign and return GUID
    }
}

Visual Studio kindly generates for you a method with required signature, but pushes inside, naturally, NotImplementedException(), cause you neeed still implement it. And if you forget, dismiss or whatever, but not write anything inside it, your class consumer in the moment of use of that method will get that exception.

Absolutely correct behaviour.

Not grasping API using interfaces

2 Answers2