C# Source Generators - a key to metaprogramming !!

C# Source generators - finally you are real !!

Guys, if you are interested in compile time metaprogramming then this blog is a good place to land.

Source code generator is a much awaited feature and now a reality in .Net 5 preview version. If you are not aware of what is source generator then don't worry, I expect most of the developers at the time when this blog is published are not aware of this feature. Take a deep breadth and relax!!

Source code generators are the new feature of C# compiler or you can say the compiler capability that can inspect a program at the compile time and generate new source files that can be added to source code while compiling the code. This functionality is a piece of code in .Net Standard 2.0 assembly. So C# developers now you can inspect the user code and generate C# source files that can be added to a compilation. Imagine the new possibilities at your door with this concept and we will discuss a few use cases in a while.

Source code generator design goals

• Generators produce one or more strings that represent C# source code to be added to the compilation.
• Explicitly additive only. Generators can add new source code to a compilation but may not modify existing user code.
• Can produce diagnostics. When unable to generate source, the generator can inform the user of the problem.
• May access additional files, that is, non-C# source texts.
• Run un-ordered, each generator will see the same input compilation, with no access to files created by other source generators.
• A user specifies the generators to run via list of assemblies, much like analyzers.

Source Generators let C# developers do the following

• Retrieve a compilation representing all user code being compiled. This object can be inspected and developers can write code that works with the syntax and semantic models for code being compiled, like with analyzers.
• Generate C# source files to be added to a compilation object during compilation, with additional source code provided as input while code is being compiled.

When combined, these two things are what make Source Generators so useful. You can inspect user code with all of the rich metadata that the compiler builds up during compilation, then emit C# code back into the same compilation that is based on the data you’ve analyzed! If you’re familiar with Roslyn Analyzers, you can think of Source Generators as analyzers that can emit C# source code.

Scenarios that benefit from Source Generators include

• To perform runtime reflection. By analyzing code when an app starts up, for example, a controller discovery phase could happen at compile time, resulting in faster startup times.
• To obviate the use of “stringly typed” APIs, such as how ASP.NET Core routing between controllers and Razor pages works. Routing could be strongly typed and the necessary strings generated as a compile-time detail.
• To help remove barriers to linker-based and ahead-of-time compilation optimizations.

If we talk about the runtime reflection, ASP.NET Core uses reflection when your web service first runs to discover constructs you’ve defined so that it can “wire up” things like controllers and razor pages. Although this enables you to write straightforward code with powerful abstractions, it comes with a performance penalty at runtime: when your web service or app first starts up, it cannot accept any requests until all the runtime reflection code that discovers information about your code is finished running! Although this performance penalty is not enormous, it is somewhat of a fixed cost that you cannot improve yourself in your own app.

With a Source Generator, the controller discovery phase of startup could instead happen at compile time by analyzing your source code and emitting the code it needs to “wire up” your app. This could result in some faster startup times, since an action happening at runtime today could get pushed into compile time.

When we talked about the stringly typed APIs, Source Generators can offer is obviating the use of some “stringly-typed” APIs, such as how ASP.NET Core routing between controllers and razor pages work. With a Source Generator, routing can be strongly typed with the necessary strings being generated as a compile-time detail. This would reduce the amount of times a mistyped string literal leads to a request not hitting the correct controller.

Will try to add the real time examples soon! Excited to try my hands on this feature.