bflat VS MessagePack for C# (.NET, .NET Core, Unity, Xamarin)

The sibling pretty much sums it up. But if you want more detail, read on:

Generally, there are three publishing options that each make sense depending on scenario:

JIT + host runtime: by definition portable, includes slim launcher executable for convenience, the platform for which can be specified with e.g. -r osx-arm64[0].

JIT + self-contained runtime: this includes IL assemblies and runtime together, either within a single file or otherwise (so it looks like AOT, just one bin/exe). These requires specifying RID, like in the previous option.

AOT: statically linked native binary, cross-OS compilation is not supported officially[1] because macOS is painful in general, and Windows<->Linux/FreeBSD is a configuration nightmare - IL AOT Compiler depends on Clang or MSVC and a native linker so it is subject to restrictions of those as a start. But it can be done and there are alternate, more focused toolchains, that offer it, like Bflat[1].

If you just want a hello world AOT application, then the shortest path to that is `dotnet new console --aot && dotnet publish -o {folder}`.

[0] https://learn.microsoft.com/en-us/dotnet/core/rid-catalog

[1] https://github.com/bflattened/bflat (can also build UEFI binaries, lol)

See here

See B flat

I've been wondering how to integrate modern .NET Core into a custom build system (buck2) and was wondering similar things. There's this project I think is cool called bflat[1] that basically makes the C# compiler more like the Go compiler in the sense it's a one-shot single-use tool that can cross compile binaries natively. It's done by one of the people on the .NET Runtime team as a side project, but quite neat.

I think in practice you're supposed to compile whole .dll's or assemblies all at once, which acts as the unit of compilation; I don't think the csharp compiler generates native object-files-for-every-.cs, the kind of approach you'd expect from javac or g++. Someone please correct me if I'm wrong though! I'd like to learn more about this.

[1] https://github.com/bflattened/bflat

You can compile without a GC using https://github.com/bflattened/bflat

nice. have you tried compile it using https://github.com/bflattened/bflat to have native executable? as long as you don't have PackgeReference it can be compiled using bflat instead of full dotnet

The creator actually addresses this issue:

Given it's a binary serialization framework, it should not be too difficult, because the domain is well-explored and numerous libraries exist in C# which address same goals that Fury does.

More popular/newer examples are https://github.com/Cysharp/MemoryPack (which is similar to Fury with its own spec, C#-code first schema), https://github.com/MessagePack-CSharp/MessagePack-CSharp or even gRPC / Protobuf tooling https://github.com/grpc/grpc-dotnet

With Unity/IL2CPP stuff: For general-purpose serialization libraries like JSON, you sometimes need to provide hints to make sure types are included: https://github.com/jilleJr/Newtonsoft.Json-for-Unity/wiki/Fi...

For schema serialization on known types, there are codegen tools (i.e. moc for MessagePack): https://github.com/neuecc/MessagePack-CSharp

MessagePack is migrating to Rosalyn code generators, so basically invisible codegen. Cysharp's newer serialization library, MessagePack, already uses this: https://github.com/Cysharp/MemoryPack

Thanks, I'm sure I'll need it, though I do have my own platform with serialization set up already that I'm hoping I can port relatively easily (It's backended with MessagePack C# which is a lovely serializer for Unity.)

In the Road map of features #119 for MessagePack-CSharp, they checked the box for:

Try MessagePack for serialization. It will help to reduce the size of the message and the time of serialization.

I mentioned JSON, but there are many formats that are much more efficient. I can mention FlatBuffers, MessagePack and ProtoBuf. These are the ones I've used myself, and personally I'm most comfortable with MessagePack and ProtoBuf. I don't think the performance would be an issue if you had to choose between these three, it's mostly the API that is different.

Biblioteca Nuget para C#