Como o Go melhora a produtividade com interfaces "implícitas" e como isso se compara à noção de métodos de extensão do C #?

No Go Language Tutorial, eles explicam como as interfaces funcionam:

Go não tem aulas. No entanto, você pode definir métodos nos tipos de estrutura. O receptor do método aparece em sua própria lista de argumentos entre a palavra-chave func e o nome do método.

type Vertex struct {
    X, Y float64
}

func (v *Vertex) Abs() float64 {
    return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

Um tipo de interface é definido por um conjunto de métodos. Um valor do tipo de interface pode conter qualquer valor que implemente esses métodos.

Essa é a única maneira de criar uma interface no Go. O Google explica ainda que:

Um tipo implementa uma interface implementando os métodos. Não há declaração explícita de intenção [ie interfacedeclarações].

As interfaces implícitas separam os pacotes de implementação dos pacotes que definem as interfaces: nenhum depende do outro.

Também incentiva a definição de interfaces precisas, porque você não precisa encontrar todas as implementações e identificá-las com o novo nome da interface.

Tudo isso parece suspeito como Métodos de extensão em C # , exceto que os métodos em Go são implacavelmente polimórficos; eles irão operar em qualquer tipo que os implemente.

O Google alega que isso incentiva o desenvolvimento rápido, mas por quê? Você desiste de algo afastando-se de interfaces explícitas em C #? Os métodos de extensão em C # permitem derivar alguns dos benefícios que as interfaces Go têm em C #?

Não vejo métodos de extensão e interfaces implícitas iguais.

Primeiro vamos falar com um propósito.

Os métodos de extensão existem como um açúcar sintático especificamente para fornecer a capacidade de usar um método como se fosse um membro de um objeto, sem ter acesso às partes internas desse objeto. Sem métodos de extensão, você pode fazer exatamente a mesma coisa, simplesmente não obtém a sintaxe agradável someObjectYouCantChange.YourMethod()e precisa chamar YourMethod(someObjectYouCantChange).

O objetivo das interfaces implícitas, no entanto, é para que você possa implementar uma interface em um objeto que não tem acesso para alterar. Isso permite criar um relacionamento polimórfico entre qualquer objeto que você escreve e qualquer objeto do qual não tenha acesso aos elementos internos.

Agora vamos falar das consequências.

Os métodos de extensão realmente não têm nenhum, isso está perfeitamente alinhado com as implacáveis ​​restrições de segurança que o .NET tenta usar para ajudar em perspectivas distintas em um modelo (a perspectiva de dentro, de fora, de herdador e vizinha). A consequência é apenas um pouco de prazer sintático.

As consequências de interfaces implícitas são algumas coisas.

• Implementação acidental da interface, pode ser um acidente feliz ou uma violação acidental do LSP, encontrando a interface de outra pessoa que você não pretendia sem respeitar a intenção do contrato.
• A capacidade de fazer qualquer método facilmente aceitar uma farsa de qualquer objeto, simplesmente espelhando a interface desse objeto (ou mesmo criando uma interface que atenda aos requisitos desse método e não mais).
• A capacidade de criar adaptadores ou outros vários padrões semelhantes com mais facilidade em relação aos objetos dos quais você não pode se intrometer.
• Adie a implementação da interface e implemente-a posteriormente sem precisar tocar na implementação real, implementando-a somente quando você realmente desejar criar outro implementador.