PeLib VS SharpLab

I'm usually working with the third edition of the ISO 23271 standard, which corresponds to ECMA 335 5th Edition. There is also the book ".NET IL Assembler" (2014) by Serge Lidin which gives some additional context and a good structure to learn the details. My compiler is written in C++, not depending on the .Net framework; I don't use the reflection and emit features of .Net, but https://github.com/rochus-keller/Pelib/ to generate assemblies; also the generated code only requires minimal mscorlib.dll features, so I can use a minimal CLR.

Most of my languages have VM backends; see e.g. https://github.com/rochus-keller/Oberon; I implemented different backends generating LuaJIT bytecode; a year ago I switched to Mono which is based on ECMA-335; here is a discussion why I switched: https://github.com/rochus-keller/Oberon/releases/tag/IDEv0.9.0; I implemented utility libraries for both LuaJIT and CIL bytecode; see https://github.com/rochus-keller/LjTools/, https://github.com/rochus-keller/Pelib/ and https://github.com/rochus-keller/MonoTools/. I evaluated many VMs and think the mentioned ones are best suited. There were a lot of challenges with both technologies, what is to be expected, and too much to describe here.

And as I understand now achieving optimal performance with CoreCLR requires inside know-how of RyuJIT and Roslyn (which I don't have anyway), i.e. ECMA-335 alone is not sufficient; the actual compilation target to achieve optimal performance with CoreCLR is therefore Roslyn, not ECMA-335; of course I could generate C# instead of IL, but then I would depend on the framework and slow down the compiler. My current code generator based on https://github.com/rochus-keller/PeLib is about 30 times faster than ILASM.

Do these all compile to the exact same thing?

https://sharplab.io/#v2:CYLg1APgAgTAjAWAFBQMwAJboMLoN7LpHoCW...

Yes, so you are right.

Recently, while creating some experimental C# source code generators (xafero/csharp-generators), I was just concatenating strings together. Like you do, you know, if things have to go very quickly. If you have a simple use case, use a formatted multi-line string or some template library like scriban. But I searched for a way to generate more and more complicated logic easily - like for example, adding raw SQL handler methods to my pre-generated DBSet-like classes for my ADO.NET experiment. You could now say: Use Roslyn and that's really fine if you look everything up in a website like SharpLab, which shows immediately the syntax tree of our C# code.

One results in MOVSX, the other in MOVZX [1]. The difference thus is sign/zero extension when moving to the larger register. However, they seem to perform pretty much identical if I'm reading Agner Fog's instruction tables correctly.

[1] https://sharplab.io/#v2:C4LghgzgtgPgAgJgIwFgBQcDMACR2DC2A3ut...

If you don't have an IDE, you can use SharpLab.io or dotnet fiddle

The closest online tool I can think of would be SharpLab, but you can only choose between Roslyn's git branches instead of C# versions.

Your code is destructuring two properties and discarding one of them. It doesn't work with a single property: https://sharplab.io/#v2:C4LgTgrgdgNAJiA1AHwAICYAMBYAUBgRj2Nw...

I think that records don't generate a deconstruct method when they only have one property, but even if you manually define one you'll get an error on `var (varName) = ...`

- LinqPad is great and I love, but, IMO, it is not the best tool to start with. It does not provide intellisense or debugger in the free version. Assuming you do not want to pay for this licence just to play a little with the language, I'd suggest https://sharplab.io/. It is not as powerfull as LinqPad, but at least it gives you suggestions.