Inheritance in protocol buffers

Protocol Buffers does not support inheritance. Instead, consider using composition:

message Foo {
  Bar bar = 1;
  string id = 2;
}

However, that said, there is a trick you can use which is like inheritance -- but which is an ugly hack, so you should only use it with care. If you define your message types like:

message Bar {
  string name = 1;
}
message Foo {
  string name = 1;
  string id = 2;
}

These two types are compatible, because Foo contains a superset of the fields of Bar. This means if you have an encoded message of one type, you can decode it as the other type. If you try to decode a Bar as type Foo, the field id will not be set (and will get its default value). If you decode a Foo as type Bar, the field id will be ignored. (Notice that these are the same rules that apply when adding new fields to a type over time.)

You can possibly use this to implement something like inheritance, by having several types all of which contain a copy of the fields of the "superclass". However, there are a couple big problems with this approach:

• To convert a message object of type Foo to type Bar, you have to serialize and re-parse; you can't just cast. This can be inefficient.
• It's very hard to add new fields to the superclass, because you have to make sure to add the field to every subclass and have to make sure that this doesn't create any field number conflicts.

See the Protocol Buffer Basics tutorial:

Don't go looking for facilities similar to class inheritance, though – protocol buffers don't do that.