I make no secret of the fact that I love Go. I think it’s a wonderfully designed language and it gave me nothing but pleasure in the years I’ve been working with it full time.
Now however I am working on a project that requires the use of C#, which prompted me to realize something.
When people ask about Go, most people talk about channels and concurrency but I think one of the most beautiful aspects of Go is its implementation of interfaces.
To see what I mean, let’s define a simple interface in Go.
type Greeter interface {
Hello() string
}
Now say we have a type that implements this interface
type MyGreeter struct {}
func (mg MyGreeter) Hello() string {
return "Hello World"
}
This is it. myGreeter implicitly implements the Greeter interface and we can pass it along to any function that accepts a Greeter.
func doSomethingWithGreeter(g Greeter) {
// do something
}
func main() {
mg := myGreeter{}
doSomethingWithGreeter(mg)
}
The fact that the implementation is actually important, but we’ll get to that. Let’s first do the same thing in C#.
interface Greeter
{
string Hello();
}
And then we create a class that implements the interface.
class MyGreeter
{
public string Hello()
{
return "Hello world";
}
}
We quickly find out that the compiler doesn’t like this.
public static string doSomething(Greeter g)
{
return g.Hello ();
}
public static void Main (string[] args)
{
MyGreeter mg = new MyGreeter ();
doSomething (mg);
}
The compiler complains that it cannot convert MyGreeter to type Greeter. That’s because the C# compiler requires classes to explicitly declare the interfaces they implement. Changing MyGreeter as below solves the problem.
class MyGreeter : Greeter
{
public string Hello()
{
return "Hello world";
}
}
And voilà, everything works.
Now, we might argue that it is not much different. All you have to do is to declare the interface implemented by the class, right? Except it does make a difference.
Imagine that you cannot change MyGreeter, be it because it’s from a third-party library or it was done by another team.
In Go, you could declare the Greeter interface in your own code and the MyGreeter that is part of somebody else’s package would “magically” implement it. It is great for mocking tests, for example.
Implicit interfaces is an underrated feature of Go.
Update: someone on Twitter pointed me to the fact that C# not only also has implicit interfaces but that this is the default state of things. That is true in a literal sense, but it’s not the same thing.
Imagine in our C# above, we have a second interface.
interface IAgreeable
{
string Hello();
string Bye();
}
(Yes, I was also told that in C# we should always name interfaces like ISomethingable. I disagree but there it is.)
We then implement our class thusly
class MyClass : Greeter, IAgreeable
{
public string Hello() {
return "Hello world";
}
public string Bye() {
return "Bye world";
}
}
It now correctly implements both interfaces and all is well with the world. Until, that is, the Hello() method needs to be different for each interface in which case you will need to do an explicit implementation.
class MyClass : Greeter, IAgreeable
{
string Greeter.Hello() {
return "Hello world from Greeter";
}
public string Hello() {
return "Hello world from !Greeter";
}
public string Bye() {
return "Bye world";
}
}
And then the compiler will call the appropriate Hello() depending on the cast.
public static string doSomething(Greeter g)
{
return g.Hello ();
}
public static string doSomethingElse(IAgreeable g)
{
return g.Hello ();
}
public static void Main (string[] args)
{
MyClass mg = new MyClass ();
Console.Out.WriteLine(doSomething (mg));
Console.Out.WriteLine(doSomethingElse (mg));
}
This will print
Hello world from Greeter
Hello world from !Greeter
Personally I consider two interfaces with clashing method names that need to behave differently a design flaw in the API, but reality being what it is, sometimes we need to deal with this.
