An open source project by FPL.
Before diving into the FlatBuffers usage in Java or C#, it should be noted that the Tutorial page has a complete guide to general FlatBuffers usage in all of the supported languages (including both Java and C#). This page is designed to cover the nuances of FlatBuffers usage, specific to Java and C#.
The code for the FlatBuffers Java library can be found at
flatbuffers/java/com/google/flatbuffers. You can browse the library on the FlatBuffers GitHub page.
The code for the FlatBuffers C# library can be found at
flatbuffers/net/FlatBuffers. You can browse the library on the FlatBuffers GitHub page.
The code to test the libraries can be found at
The test code for Java is located in JavaTest.java.
Note: These scripts require that Java is installed.
Optionally, you can run this using Mono instead. Once you have installed
Mono, you can run the tests from the command line by running the following commands from inside the
Note: See Tutorial for a more in-depth example of how to use FlatBuffers in Java or C#.
FlatBuffers supports reading and writing binary FlatBuffers in Java and C#.
To use FlatBuffers in your own code, first generate Java classes from your schema with the
--java option to
flatc. (Or for C# with
--csharp). Then you can include both FlatBuffers and the generated code to read or write a FlatBuffer.
For example, here is how you would read a FlatBuffer binary file in Java: First, import the library and generated code. Then, you read a FlatBuffer binary file into a
byte. You then turn the
byte into a
ByteBuffer, which you pass to the
Note: The code here is written from the perspective of Java. Code for both languages is both generated and used in nearly the exact same way, with only minor differences. These differences are explained in a section below.
Now you can access the data from the
C# code works almost identically to Java, with only a few minor differences. You can see an example of C# code in
First of all, naming follows standard C# style with
PascalCasing identifiers, e.g.
GetRootAsMyRootType. Also, values (except vectors and unions) are available as properties instead of parameterless accessor methods as in Java. The performance-enhancing methods to which you can pass an already created object are prefixed with
FlatBuffers doesn't support dictionaries natively, but there is support to emulate their behavior with vectors and binary search, which means you can have fast lookups directly from a FlatBuffer without having to unpack your data into a
Dictionary or similar.
To use it:
keyattribute on this field, e.g.
name:string (key). You may only have one key field, and it must be of string or scalar type.
CreateMySortedVectorOfTablesin C# or
FlatBufferBuilderobject) in Java, which will first sort all offsets such that the tables they refer to are sorted by the key field, then serialize it.
LookupByKeyto access elements of the vector, e.g.:
Monster.lookupByKey(tablesVectorOffset, "Frodo", dataBuffer), which returns an object of the corresponding table type, or
nullif not found.
LookupByKeyperforms a binary search, so should have a similar speed to
Dictionary, though may be faster because of better caching.
LookupByKeyonly works if the vector has been sorted, it will likely not find elements if it hasn't been sorted.
There currently is no support for parsing text (Schema's and JSON) directly from Java or C#, though you could use the C++ parser through native call interfaces available to each language. Please see the C++ documentation for more on text parsing.