public static void Run()
{
// These types are generated from SchemaFilesExample.fbs
FooBarContainer container = new FooBarContainer
{
fruit = Fruit.Pears,
initialized = true,
location = "location",
list = new List <FooBar>
{
new FooBar
{
name = "name",
postfix = 1,
rating = 3,
sibling = new Bar
{
ratio = 3.14f,
size = ushort.MaxValue,
time = int.MinValue,
parent = new Foo {
count = 3, id = 4, length = 8, prefix = 10
},
}
}
},
};
// Serializer is pregenerated, so no first-run penalty for FlatBufferSerializer.
byte[] destination = new byte[1024];
int maxBytes = FooBarContainer.Serializer.GetMaxSize(container);
int bytesWritten = FooBarContainer.Serializer.Write(destination, container);
var parsed = FooBarContainer.Serializer.Parse(destination);
}
public static void Run()
{
// These types are generated from SchemaFilesExample.fbs
FooBarContainer container = new FooBarContainer
{
fruit = Fruit.Pears,
initialized = true,
location = "location",
list = new List <FooBar>
{
new FooBar
{
name = "name",
postfix = 1,
rating = 3,
sibling = new Bar
{
ratio = 3.14f,
size = ushort.MaxValue,
time = int.MinValue,
parent = new Foo(), // structs are nullable types, but are not meant to be null.
}
}
},
};
byte[] destination = new byte[1024];
// Generated types can still use a runtime-generated serializer
int maxBytes = FlatBufferSerializer.Default.GetMaxSize(container);
int bytesWritten = FlatBufferSerializer.Default.Serialize(container, destination);
var parsed = FlatBufferSerializer.Default.Parse <FooBarContainer>(destination);
}
private static void RunBenchmarkSet(
string runName,
ISerializer <FooBarContainer> serializer,
FooBarContainer container)
{
int traversalCount = 5;
byte[] destination = new byte[serializer.GetMaxSize(container)];
SpanWriter spanWriter = new SpanWriter();
InputBuffer inputBuffer = new ArrayInputBuffer(destination);
serializer.Write(spanWriter, destination, container);
(string, Action)[] items = new (string, Action)[]
public static void Run()
{
FooBarContainer container = new FooBarContainer
{
fruit = Fruit.Pears,
initialized = true,
location = "location",
list = new List <FooBar>
{
new FooBar
{
name = "name",
postfix = 1,
rating = 3,
sibling = new Bar
{
ratio = 3.14f,
size = ushort.MaxValue,
time = int.MinValue,
// Nested structs are not intended to have null values,
// but it is possible due to FlatSharp modeling
// them as reference types. However, null structs
// do not cause a problem when serializing or parsing.
parent = null !,
}
}
},
};
// Simple use case: make a deep copy of an object you're using.
var copy = new FooBarContainer(container);
Debug.Assert(!object.ReferenceEquals(copy.list, container.list), "A new list is created");
for (int i = 0; i < container.list.Count; ++i)
{
var originalItem = container.list[i];
Debug.Assert(copy.list is not null);
var copyItem = copy.list[i];
Debug.Assert(!object.ReferenceEquals(copyItem, originalItem));
}
// Now let's look at how this can be useful when operating on deserialized objects.
var serializer = new FlatBufferSerializer(FlatBufferDeserializationOption.Lazy);
byte[] data = new byte[1024];
serializer.Serialize(container, data);
var deserialized = serializer.Parse <FooBarContainer>(data);
// Take a deserialized item and "upcast" it back to the original type.
// This performs a full traversal of the object and allows the underlying buffer to be reused.
Debug.Assert(deserialized.GetType() != container.GetType(), "The deserialized type is a subclass of the FooBarContainer type");
copy = new FooBarContainer(deserialized);
Debug.Assert(copy.GetType() == container.GetType(), "By using the copy constructor, we can get an instance of the original type.");
// Next: Some deserialization modes, such as Lazy, don't permit mutation of the object.
// Using the copy constructor can convert this to an object that we can mutate!
try
{
// will throw
deserialized.fruit = Fruit.Apples;
Debug.Assert(false);
}
catch
{
}
// Modifying the copy is just fine, though.
copy.fruit = Fruit.Apples;
}
public static void Main(string[] args)
{
Console.WriteLine($"x64={Environment.Is64BitProcess}");
FooBar[] fooBars = new FooBar[5];
for (int i = 0; i < fooBars.Length; i++)
{
var foo = new Foo
{
id = 0xABADCAFEABADCAFE + (ulong)i,
count = (short)(10000 + i),
prefix = (sbyte)('@' + i),
length = (uint)(1000000 + i)
};
var bar = new Bar
{
parent = foo,
ratio = 3.14159f + i,
size = (ushort)(10000 + i),
time = 123456 + i
};
var fooBar = new FooBar
{
name = Guid.NewGuid().ToString(),
postfix = (byte)('!' + i),
rating = 3.1415432432445543543 + i,
sibling = bar,
};
fooBars[i] = fooBar;
}
var defaultContainer = new FooBarContainer
{
fruit = benchfb.Enum.Bananas,
initialized = true,
location = "http://google.com/flatbuffers/",
list = fooBars,
};
var serializer = FooBarContainer.Serializer;
RunBenchmarkSet(
"GreedyBuildTime",
serializer,
defaultContainer);
RunBenchmarkSet(
"GreedyRuntime",
new FlatBufferSerializer(new FlatBufferSerializerOptions(FlatBufferDeserializationOption.GreedyMutable)).Compile <FooBarContainer>(),
defaultContainer);
/*
*
* RunBenchmarkSet(
* "Lazy",
* new FlatBufferSerializer(new FlatBufferSerializerOptions(FlatBufferSerializerFlags.GenerateMutableObjects)).Compile<FooBarContainer>(),
* defaultContainer);
*
* RunBenchmarkSet(
* "Greedy",
* new FlatBufferSerializer(new FlatBufferSerializerOptions(FlatBufferSerializerFlags.GreedyDeserialize | FlatBufferSerializerFlags.GenerateMutableObjects)).Compile<FooBarContainer>(),
* defaultContainer);*/
}
