Question: I have an interface as below:

```
public interface IInterface
{
    void Open();
    void Open(bool flag);
    void Open(bool flag, bool otherFlag);
}

```

Now when implementing the interface I have the following:

```
public class IClass : IInterface
{
    void IInterface.Open()
    {
        Open(false, false);
    }

    void IInterface.Open(bool flag)
    {
        Open(flag, false);
    }

    void IInterface.Open(bool flag, bool otherFlag)
    {
         //Do some stuff
    }
}

```

Now, the problem I am encountering is that within the first two function bodies in the IClass, I cannot call the third function. I get the error:

> 
> The name 'Open' does not exist in the current context
> 
> 
> 

Okay, so I'm implementing the interface explicitly (due to a requirement from another team in the organization) and then I get the 'Open' context issue.
I can remove the explicit IInterface from the three open methods, and then I can successfully compile, even with the other methods (not listed here) implemented explicitly, but I am not sure what the implications of this are.

Is there a way to call the third method while explicitly implementing the interface methods?

Thanks!

Answer: 
You can do:

```
((IInterface)this).Open(false, false);

```

One thing you might consider is making the other overloads extension methods on `IInterface` instead of re-implementing them each time:

```
public static void Open(this IInterface iface, bool flag)
{
    iface.Open(flag, false);
}

```
Just ensure that you treat the `this` object explicitly as an interface by casting it first:

```
void IInterface.Open(bool flag)
{
   ((IInterface)this).Open(flag, false);
}

```