Implicit and Explicit implementation of interface

While working on a upgrade i happene开发者_StackOverflowd to come across a code like this.

interface ICustomization
    {
        IMMColumnsDefinition GetColumnsDefinition();
    }

    class Customization : ICustomization
    {
        private readonly ColumnDefinition _columnDefinition;

        //More code here.

        public ColumnsDefinition GetColumnsDefinition()
        {
            return _columnDefinition;
        }

        ColumnsDefinition ICustomization.GetColumnsDefinition()  //redundant
        {
            return GetColumnsDefinition();            
        }
    }

My question is: Is there any need/use of 'explicit' implementation of interface in this piece of code? Will it create any problem if i remove the method (explicit implementation of interface) that i have marked "redundant" above?

PS: I understand that explicit implementation of interface is very important, and it can be used when we need to give access to a method at interface level only, and to use two interface with same signature of method.

Yup. Looks redundant.

Calling it via a Customization type of reference and an ICustomization type of reference results in the same behavior. If you wanted the below calls to behave differently, then explicitly implementing the interface would have made sense.

Customization oVar = new Customization();
oVar.GetColumnsDefinition(); // calls 1st method
ICustomization iVar = obj;
iVar.GetColumnsDefinition(); // calls 2nd method - explicit impl.

You should remove the explicit implementation. However if you remove the other implementation, you will constrain clients such that they can no longer call oVar.GetColumnsDefintion() - they would have to use an interface variable as shown above.

For info, the main time you see that specific pattern is when (any one of):

• the non-explicit method is virtual or abstract, for subclasses to override
• the signature of the public method is not quite the same, for example the public API has a more specific return type (common for things like IEnumerable[<T>] or ICloneable).
• we don't want it to be public, but we want it to be easily callable within the type (without needing a nop-cast)

In this case it does indeed look redundant.