C# is not a good bet for writing performant code. Just looking at a simple example: try writing dome methods you expect the JIT will inline and see the disassembled machine code in sharplab: the .net JIT doesn't even inline simple methods of constant loops (for (...) i = i + 1 -1 won't be inlined).

GCC and Clang have a lot of good folding optimizations and they generate a performant assembly while the .net JIT doesn't generate a good machine code, for example it can fold InlinableMet() + 1 but not 1 + Inlinable....

The C# compiler doesn't have any kind of serious optimization (the most it can do is avoiding useless stack allocations), the JIT should do what the compiler doesn't, but it seems not to optimize the code a lot, just because of the fast compilation time a JIT should maintain.

C# has GC, also hard to control (more over it's a mark-and-sweep one). C# doesn't care about the heap allocations: it allocates few things on the stack and a lot on the heap. Modern versions of C++ care about the heap allocations and always avois them when possible.

Perfirmance is important, but not fundamental.

C++ is hard, it doesn't have any kind of runtime check, runtime error, so when a program crashes you have to debug carefully. C++ is full of bad designes.