Just a quick note, status update and link to new website. The C# port
may have been quiet, but progress has been steady. The core
implementation hasn't changed much for quite a while - which is at
least an *indication* that I think it's stable - and I've been working
on a few things around the periphery.

What's been happening?

- The C# port is now completely independent of the Google code other
than protoc. There's no non-C# source in the project. It requires
protoc.exe (included in the repository) but it's just the stock
protoc. (At the moment, anyway... there's an important change to
protoc which I want to attempt.) ProtoGen.exe is used to convert
descriptor sets (one possible output of protoc) into C#.

- The C# options are now specified using the standard mechanism -
there's a C# options .proto file which needs to be imported if you
want to use the options. (This is the change I want for protoc - it
would be good to get the import to be effectively ignored by other
generators; the C++ and Java code really shouldn't need to generate
source for the C# options messages.)

- There's some documentation! I've got the code hosted at
http://code.google.com/p/protobuf-csharp-port/ as well as github. I
commit to a local git repository, occasionally push to github, and
more occasionally update the code.google.com Subversion repository
based on the head of github. This is slightly kludgy, but at least it
means you can hack on the project with either source control system.
If I end up with other contributors it could end up being
"interesting" but we'll cross that bridge when we come to it. Bugs
should be reported there so I can track them easily.

- The build system is now NAnt calling MSBuild. I haven't even
attempted to build it with Mono yet, as last time I tried with the old
makefile, there were gmcs bugs which stopped it from working. I
reported the bugs, but haven't heard back yet. When I've got some free
time (yeah, right) I may try this again. I'll almost certainly try
*running* the code under Mono, having build it with the MS C#
compiler.

- There are three small new tools: ProtoDump, ProtoMunge and
ProtoBench. ProtoDump loads a binary message file and dumps out the
text format version. ProtoMunge loads a binary message file and writes
out a binary message file which has the same structure (and the same
length for each field) but with randomised data. More on this in a
minute. ProtoBench loads a binary message and serializes/deserializes
it in various ways for performance testing.

- There are two sample benchmarking messages. These are *nearly* real-
world messages - I took the Google internal benchmarking test data,
hand-converted the .proto files to get rid of all the comments and
meaningful names (it's all field1, field2 etc now), and ran it through
ProtoMunge. More benchmark files treated in the same way (i.e. real-
world data, but made intellectually-insensitive) are very welcome! I
intend to port ProtoBench to Java and protobuf-net so I can run a
reasonably meaningful benchmark across the three. (Obviously I won't
rest until the C# port wins comfortably ;)

The tools are all a little bit clunky at the moment - there's
definitely a lot of polishing still to do - but I'd trust the core
code pretty thoroughly now.

Jon
--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups 
"Protocol Buffers" group.
To post to this group, send email to protobuf@googlegroups.com
To unsubscribe from this group, send email to 
protobuf+unsubscr...@googlegroups.com
For more options, visit this group at 
http://groups.google.com/group/protobuf?hl=en
-~----------~----~----~----~------~----~------~--~---

Reply via email to