Implementación implícita y explícita de la interfaz

Question

Mientras trabajaba en una actualización, me encontré con un código como este.

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();    
     } 
    } 

Mi pregunta es: ¿Hay alguna necesidad/uso de la aplicación 'explícito' de la interfaz de esta pieza de código? ¿Creará algún problema si elimino el método (implementación explícita de la interfaz) que he marcado como "redundante" más arriba?

PD: Entiendo que la implementación explícita de la interfaz es muy importante, y puede usarse cuando necesitamos dar acceso a un método solo a nivel de interfaz, y usar dos interfaces con la misma firma de método.

Answer 1

Sí. Parece redundante.

Llamar a través de un tipo de referencia de personalización y un tipo de referencia de personalización da como resultado el mismo comportamiento. Si quería que las llamadas siguientes se comportaran de manera diferente, entonces la implementación explícita de la interfaz tendría sentido.

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

Debe eliminar la implementación explícita. Sin embargo, si elimina la otra implementación, restringirá a los clientes de modo que ya no puedan llamar a oVar.GetColumnsDefintion(): tienen que usar una variable de interfaz como se muestra arriba.

Answer 2

Para información, el tiempo principal se ve que un patrón específico es cuando (una de las):

• el método no explícito es virtual o abstract, por subclases de override
• la firma del public método no es bastante lo mismo, por ejemplo, la API pública tiene un tipo de devolución más específico (común para cosas como IEnumerable[<T>] o ICloneable).
• no queremos que sea public, pero queremos que sea fácilmente exigible dentro del tipo (sin necesidad de un NOP-cast)

En este caso sí que parece redundante.