{"id":89800,"date":"2023-08-03T07:44:31","date_gmt":"2023-08-03T05:44:31","guid":{"rendered":"https:\/\/drafts.code-maze.com\/?p=89800"},"modified":"2023-08-16T09:15:52","modified_gmt":"2023-08-16T07:15:52","slug":"csharp-source-generators","status":"publish","type":"post","link":"https:\/\/code-maze.com\/csharp-source-generators\/","title":{"rendered":"Source Generators in C#"},"content":{"rendered":"

Traditionally, code generation in C# involved using external tools or templates to generate code before the compilation process, like the T4 template. However, with source generators, code generation becomes an integral part of the compilation itself.<\/p>\n

In this article, we’ll explore the basics of C# source generators and how to use this powerful feature to enable dynamic code generation during compilation, automating repetitive tasks, and improving developer productivity.<\/p>\n

To download the source code for this article, you can visit our GitHub repository<\/a>.<\/div>\n

Let’s start.<\/p>\n

Background<\/h2>\n

Source generators are a feature introduced in C# 9 that allows dynamic code generation during the compilation process. They integrate directly with the C# compiler (Roslyn)<\/code> and operate at compile time, analyzing source code and generating additional code based on analysis results.<\/p>\n

Source generators provide a streamlined, automated approach to code generation, eliminating the need for external tools or separate pre-compilation steps.<\/p>\n

By seamlessly integrating into the compilation process, source generators enhance productivity, reduce errors, and allow for more efficient development workflows.<\/p>\n

How to Use It<\/h2>\n

First, we should create a C# project that targets netstandard2.0<\/code> and add some standard packages to get access to the source generator types.<\/p>\n

We can start by creating a class library. Then, through the SDK, we can create a solution and a project in the current folder:<\/p>\n

dotnet new sln -n SourceGeneratorInCSharp\r\ndotnet new classlib --framework \"netstandard2.0\" -o .\/Generator\r\ndotnet sln add .\/Generator<\/pre>\n
Afterward, we need to replace the content of Generator.csproj<\/code>:<\/p>\n
<Project Sdk=\"Microsoft.NET.Sdk\">\r\n    <PropertyGroup>\r\n        <TargetFramework>netstandard2.0<\/TargetFramework>\r\n        <IncludeBuildOutput>false<\/IncludeBuildOutput>\r\n        <LangVersion>latest<\/LangVersion>\r\n    <\/PropertyGroup>\r\n\r\n    <ItemGroup>\r\n        <PackageReference Include=\"Microsoft.CodeAnalysis.CSharp.Workspaces\" \r\n            Version=\"4.4.0\" \r\n            PrivateAssets=\"all\" \/>\r\n    <\/ItemGroup>\r\n<\/Project><\/pre>\n
As we know, source code generators work like an analyzer and provide an option to generate source code at development time even if the code cannot be compiled. For this, we need a separate project to reference our generator.<\/p>\n
Let’s create a console application for this:<\/p>\n
dotnet new console --framework \"net7.0\" -o SourceGeneratorInCSharp\r\ndotnet sln add SourceGeneratorInCSharp<\/pre>\n
In the SourceGeneratorInCSharp.csproj<\/code> we need to change the content:<\/p>\n
<Project Sdk=\"Microsoft.NET.Sdk\">\r\n    <PropertyGroup>\r\n        <OutputType>Exe<\/OutputType>\r\n        <TargetFramework>net7.0<\/TargetFramework>\r\n        <LangVersion>latest<\/LangVersion>\r\n        <ImplicitUsings>enable<\/ImplicitUsings>\r\n        <Nullable>enable<\/Nullable>\r\n    <\/PropertyGroup>\r\n\r\n    <ItemGroup>\r\n        <ProjectReference Include=\"..\\Generator\\Generator.csproj\" \r\n            OutputItemType=\"Analyzer\" \r\n            ReferenceOutputAssembly=\"false\"\/>\r\n    <\/ItemGroup>\r\n<\/Project>\r\n<\/pre>\n
So far, everything we’ve done has been pretty much standard stuff, so let’s get into the code.<\/p>\n
Implementing a Simple Generator<\/h2>\n
A source generator has two defining characteristics, implementing the IIncrementalGenerator\u00a0<\/code>interface and decorating with the [Generator]<\/code> attribute, which makes a project consider a class as a source generator:<\/p>\n
[Generator]\r\npublic sealed class ExampleGenerator : IIncrementalGenerator\r\n{\r\n    public void Initialize(IncrementalGeneratorInitializationContext context)\r\n    {\r\n    }\r\n}\r\n<\/pre>\n
The generator only requires the implementation of a single method, Initialize<\/code>. In this method, we can register our static source code as well as create a pipeline to identify the syntax of interest and transform this syntax into source code.<\/p>\n
Also, we are using the IIncrementalGenerator interface instead of ISourceGenerator because it is way more performant, and with the ISourceGenerator interface, a new ISyntaxReceiver is created for every generation, which creates a lot of generation phases. With bigger projects, this can quickly lead to performance issues. The IIncrementalGenerator was optimized to provide better performance for our applications.<\/strong><\/p>\n
Now, let’s implement a generator that will output a simple source code:<\/p>\n
[Generator]\r\npublic sealed class ExampleGenerator : IIncrementalGenerator\r\n{\r\n    public void Initialize(IncrementalGeneratorInitializationContext context)\r\n    {\r\n        context.RegisterPostInitializationOutput(ctx =>\r\n        {\r\n            var sourceText = $$\"\"\"\r\n                namespace SourceGeneratorInCSharp\r\n                {\r\n                    public static class HelloWorld\r\n                    {\r\n                        public static void SayHello()\r\n                        {\r\n                            Console.WriteLine(\"Hello From Generator\");\r\n                        }\r\n                    }\r\n                }\r\n                \"\"\";\r\n\r\n            ctx.AddSource(\"ExampleGenerator.g\", SourceText.From(sourceText, Encoding.UTF8));\r\n        });\r\n    }\r\n}<\/pre>\n
In the example, we use a string literal to represent the code we want to emit.<\/p>\n
The RegisterPostInitializationOutput<\/code> only allows us to add fixed source code, as we don’t have any access to the user code at this point.<\/p>\n
To emit the files, we utilize the AddSource()<\/code> method, which requires two parameters. The first parameter serves as a distinct identifier for the emitted source, while the second parameter represents the actual source text. This text is obtained from our hard-coded string and includes the corresponding encoding information.<\/p>\n
After we build, if everything is set up properly, we can see the generated code file under the analyzer in the Console<\/code> project solution explorer:<\/p>\n
\"Generated<\/a><\/p>\n
If we double-click the ExampleGenerator.g.cs<\/code> we can see the output code, including warnings from Visual Studio that this file isn\u2019t editable:<\/p>\n
\"Code<\/a><\/p>\n
Implementing a More Complex Generator<\/h2>\n
Now that we’ve seen how a generator works through a simple example, let’s tackle something different. Before we build a more complex generator, let’s consider a scenario for our practice.<\/p>\n
For many corporate applications, we have a series of architectural patterns that are followed, such as the use of entities, repositories, services, and controllers, most of which have the same implementation. This tends to be a very manual and time-consuming task. The code we need to write to create the entire structure tends to be repetitive and error-prone.<\/p>\n
Using C# source code generators to generate some of these parts can save us a lot of time. So let’s implement the service class as an example.<\/p>\n
Adding a Marker Attribute<\/h3>\n
We need to think about how we are going to choose which models we are going to generate service classes for. We can do this for all models in the project, but that would cause services to be generated even for the models we don’t need. For that, we can use a marker attribute. A marker attribute is a simple attribute that has no functionality and exists only to be located.<\/p>\n
We’re going to create a simple marker attribute, but we’re not going to define this attribute directly in the code. Instead, we will create a string containing C# code for the [GenerateService]<\/code>\u00a0 attribute. We will have the generator automatically add this to the build of the consuming project and the attribute will be available at runtime. It is necessary to do this because when referencing our Generator<\/code> project we set the ReferenceOutputAssembly<\/code> to false.<\/p>\n
If ReferenceOutputAssembly<\/code> is set to false, the output of the referenced project is not included as a Reference<\/a> of this project, but it is still guaranteed that the other project builds before this one.<\/p>\n
Let’s create the attribute:<\/p>\n
public class SourceGenerationHelper\r\n{\r\n    public const string Attribute = \"\"\"\r\n        namespace Generator\r\n        {\r\n            [System.AttributeUsage(System.AttributeTargets.Class)]\r\n            public class GenerateServiceAttribute : System.Attribute\r\n            {\r\n            }\r\n        }\r\n        \"\"\";\r\n}<\/pre>\n
Creating the Source Generator<\/h3>\n
As mentioned earlier, our starting point is a class that implements the IIncrementalGenerator<\/code> interface and is decorated with the [Generator]<\/code> attribute:<\/p>\n
[Generator]\r\npublic sealed class ServiceGenerator : IIncrementalGenerator\r\n{\r\n    public void Initialize(IncrementalGeneratorInitializationContext context)\r\n    {\r\n        context.RegisterPostInitializationOutput(ctx => ctx.AddSource(\r\n            \"GenerateServiceAttribute.g.cs\",\r\n            SourceText.From(SourceGenerationHelper.Attribute, Encoding.UTF8)));\r\n    }\r\n}<\/pre>\n
In the implementation, we used the RegisterPostInitializationOutput<\/code> method, which allows us to register a callback that will be called once. It’s useful for efficiently adding “constant” fonts to the build, like our marker attribute. Now we have the attribute available for use in our SourceGeneratorInCSharp<\/code> project.<\/p>\n
Development of the Generator Pipeline<\/h3>\n
Now we need to create a pipeline for filtering and transforming, which by design memorizes the results in each layer to avoid redoing the work if there are no changes:<\/p>\n
[Generator]\r\npublic sealed class ServiceGenerator : IIncrementalGenerator\r\n{\r\n    public void Initialize(IncrementalGeneratorInitializationContext context)\r\n    {\r\n        context.RegisterPostInitializationOutput(ctx => ctx.AddSource(\r\n            \"GenerateServiceAttribute.g.cs\",\r\n            SourceText.From(SourceGenerationHelper.Attribute, Encoding.UTF8)));\r\n\r\n        IncrementalValuesProvider<ClassDeclarationSyntax> enumDeclarations = context.SyntaxProvider\r\n            .CreateSyntaxProvider(\r\n                predicate: static (s, _) => IsSyntaxTargetForGeneration(s),\r\n                transform: static (ctx, _) => GetTargetForGeneration(ctx));\r\n\r\n        IncrementalValueProvider<(Compilation, ImmutableArray<ClassDeclarationSyntax>)> compilationAndEnums\r\n                = context.CompilationProvider.Combine(enumDeclarations.Collect());\r\n\r\n        context.RegisterSourceOutput(compilationAndEnums,\r\n            (spc, source) => Execute(source.Item1, source.Item2, spc));\r\n        }\r\n}<\/pre>\n
\nIn the first stage of the pipeline, we use the CreateSyntaxProvider<\/code> method to filter the input list. The predicate, IsSyntaxTargetForGeneration<\/code>, provides a first layer of filtering. The transform, GetTargetForGeneration<\/code>, is used just to transform the result of the first filtering.<\/p>\n
The next pipeline stage simply combines our collection of ClassDeclarationSyntax<\/code> issued in the first stage with the current compilation.<\/p>\n
With that, we generate the source code using the custom Execute<\/code> method.<\/p>\n
Implementing the Stages<\/h3>\n
The IsSyntaxTargetForGeneration<\/code> predicate is a method that will be called very often to check if the given SyntaxNode<\/code> is relevant to our generator.<\/p>\n
Syntax nodes are one of the main elements of syntax trees. These nodes represent declarations, statements, clauses, and expressions. Each category of syntax nodes is represented by a separate class derived from Microsoft.CodeAnalysis.SyntaxNode:<\/code><\/p>\n
public static bool IsSyntaxTargetForGeneration(SyntaxNode syntaxNode)\r\n{\r\n    return syntaxNode is ClassDeclarationSyntax classDeclarationSyntax &&\r\n        classDeclarationSyntax.AttributeLists.Count > 0 &&\r\n        classDeclarationSyntax.AttributeLists\r\n            .Any(al => al.Attributes\r\n                .Any(a => a.Name.ToString() == \"GenerateService\"));\r\n}<\/pre>\n
In our implementation, we check if the syntaxNode<\/code> object is an instance of the ClassDeclarationSyntax<\/code> class and that it has an attribute with the name \"GenerateService\"<\/code>.<\/p>\n
In the transformation stage, we must extract and return a syntax node of type ClassDeclarationSyntax<\/code> from the given context:<\/p>\n
public static ClassDeclarationSyntax GetTargetForGeneration(GeneratorSyntaxContext context)\r\n{\r\n    var classDeclarationSyntax = (ClassDeclarationSyntax)context.Node;\r\n\r\n    return classDeclarationSyntax;\r\n}<\/pre>\n
Working With Templates<\/h3>\n
Before starting work on the Execute<\/code> method, let’s create a template to use for code generation. A simple string builder would suffice, however, we can use a template engine. At this point, we can use the Scriban<\/a> template engine.<\/p>\n
Scriban<\/code>, which is a swift, robust, secure, and lightweight scripting language and engine designed for .NET. By adopting this approach, we can store the templates in individual files, thereby maintaining a well-organized solution.<\/p>\n
To use this template tool we need to install some packages. Let\u2019s inspect the content of the Generator.csproj<\/code> file:<\/span><\/p>\n
<Project Sdk=\"Microsoft.NET.Sdk\">\r\n    <ItemGroup>\r\n        <PackageReference Include=\"Microsoft.CodeAnalysis.CSharp.Workspaces\" \r\n            Version=\"4.6.0\" \r\n            PrivateAssets=\"all\" \/>\r\n        <PackageReference Include=\"Microsoft.CSharp\" Version=\"4.7.0\" \/>\r\n        <PackageReference Include=\"Scriban\" Version=\"5.7.0\" IncludeAssets=\"Build\"\/>\r\n        <PackageReference Include=\"System.Threading.Tasks.Extensions\" Version=\"4.5.4\" \/>\r\n    <\/ItemGroup>\r\n<\/Project><\/pre>\n
Now, let’s create a file named Services.scriban<\/code> inside the Templates<\/code> folder, with the content:<\/p>\n
using {{class_namespace}};\r\n\r\nnamespace {{class_assembly}}.Services \r\n{\r\n    public partial class {{class_name}}Service\r\n    {\r\n        private static readonly List<{{class_name}}> _list = new();\r\n\r\n        public virtual List<{{class_name}}> All()\r\n        {\r\n            return _list;\r\n        }\r\n\r\n        public virtual void Add({{class_name}} item)\r\n        {\r\n            _list.Add(item);\r\n        }\r\n\r\n        public virtual void Update({{class_name}} item)\r\n        {\r\n            var existing = _list.Single(x => x.Id == item.Id);\r\n\r\n            _list.Remove(existing);\r\n            _list.Add(item);\r\n        }\r\n\r\n        public virtual void Delete(int id)\r\n        {\r\n            var existing = _list.Single(x => x.Id == id);\r\n\r\n            _list.Remove(existing);\r\n        }\r\n    }\r\n}<\/pre>\n
Now, we need to mark the file as an embedded resource in Generator.csproj<\/code> file:<\/p>\n
<ItemGroup>\r\n    <None Remove=\"Templates\\**\\*.scriban\" \/>\r\n    <EmbeddedResource Include=\"Templates\\**\\*.scriban\" \/>\r\n<\/ItemGroup><\/pre>\n
Development of Source Generators<\/h3>\n
After doing that, we can go back to our Execute<\/code> method in ServiceGenerator<\/code> and implement it:<\/p>\n
public void Execute(Compilation compilation, \r\n    ImmutableArray<ClassDeclarationSyntax> classes, \r\n    SourceProductionContext context)\r\n{\r\n    foreach (var classSyntax in classes)\r\n    {\r\n        \/\/ Converting the class to a semantic model to access much more meaningful data.\r\n        var model = compilation.GetSemanticModel(classSyntax.SyntaxTree);\r\n\r\n        \/\/ Parse to declared symbol, so you can access each part of code separately,\r\n        \/\/ such as interfaces, methods, members, contructor parameters etc.\r\n        var symbol = model.GetDeclaredSymbol(classSyntax);\r\n\r\n        var className = symbol.Name;\r\n\r\n        if (!className.Contains(\"Model\"))\r\n        {\r\n            var error = Diagnostic.Create(DiagnosticsDescriptors.ClassWithWrongNameMessage,\r\n                classSyntax.Identifier.GetLocation(),\r\n                className);\r\n\r\n            context.ReportDiagnostic(error);\r\n\r\n            return;\r\n        }\r\n\r\n        var classNamespace = symbol.ContainingNamespace?.ToDisplayString();\r\n\r\n        var classAssembly = symbol.ContainingAssembly?.Name;\r\n\r\n        \/\/ Get the template string\r\n        var text = GetEmbededResource(\"Generator.Templates.Service.scriban\");\r\n\r\n        var template = Template.Parse(text);\r\n\r\n        var sourceCode = template.Render(new { \r\n            ClassName = className, \r\n            ClassNamespace = classNamespace, \r\n            ClassAssembly = classAssembly \r\n        });\r\n\r\n        context.AddSource(\r\n            $\"{className}{\"Service\"}.g.cs\",\r\n            SourceText.From(sourceCode, Encoding.UTF8)\r\n        );\r\n    }\r\n}<\/pre>\n
Inside the loop, we convert the class syntax node to a semantic model using the Compilation.GetSemanticModel<\/code> method. The semantic model provides more detailed information about the code, allowing access to meaningful data such as interfaces, methods, members, and constructor parameters.<\/p>\n
After we use the model.GetDeclaredSymbol<\/code> method to obtain the symbol for the class. A symbol represents a declared code element and provides information about its properties, including its name, containing namespace, and containing assembly.<\/p>\n
The GetEmbededResource<\/code> method was called to retrieve the template string from an embedded resource.\u00a0<\/p>\n
We use the Template.Parser<\/code> method to prepare our template for rendering and through the Render<\/code> method we get our generated source code.<\/p>\n
Finally, the generated source code is added to the compilation using context.AddSource<\/code>. The method takes a name for the generated file (constructed from the class name) and the source code is represented as SourceText<\/code>.<\/p>\n
Debugging Source Generators<\/h3>\n
When developing source generators, we often need to debug the generators themselves. Since these generators run during the build process, we can’t debug them like casual C# projects, so we have to debug them some other way. If we want to attach our debugger to the compiler, the generator will run so fast that we won’t have enough time for that. Then we can use another trick, we can just wait until the debugger is attached.<\/p>\n
At the beginning of the methods, add code to launch the debugger:<\/p>\n
public void Execute(Compilation compilation, \r\n    ImmutableArray<ClassDeclarationSyntax> classes, \r\n    SourceProductionContext context)\r\n{\r\n    Debugger.Launch();\r\n    ...\r\n}\r\n<\/pre>\n
Emitting Diagnostic Messages<\/h3>\n
Sometimes we may want to provide some diagnostic feedback to the developer to let them know when things aren’t going as expected. The context provided in the Execute<\/code> method provides the context.ReportDiagnostic<\/code> method, used to log diagnostic messages.<\/p>\n
A diagnostic entity requires a message, message type, title, diagnostic code, and help link. The location is optional to identify the exact location of the problem in the source code, and we can pass optional arguments for the descriptor.<\/p>\n
To keep things clean, we can store diagnostic descriptors in a separate static class:<\/p>\n
public static class DiagnosticsDescriptors\r\n{\r\n    public static readonly DiagnosticDescriptor ClassWithWrongNameMessage\r\n        = new(\"ERR001\",                                        \/\/ id\r\n            \"Worng name\",                                      \/\/ title\r\n            \"The class '{0}' must be contains 'Model' prefix\", \/\/ message\r\n            \"Generator\",                                       \/\/ category\r\n            DiagnosticSeverity.Error,\r\n            true);\r\n}<\/pre>\n
To report a diagnostic message we just call ReportDiagnostic<\/code> method:<\/p>\n
public void Execute(Compilation compilation, \r\n    ImmutableArray<ClassDeclarationSyntax> classes, \r\n    SourceProductionContext context)\r\n{\r\n    ...\r\n    if (!className.Contains(\"Model\"))\r\n    {\r\n        var error = Diagnostic.Create(DiagnosticsDescriptors.ClassWithWrongNameMessage,\r\n            classSyntax.Identifier.GetLocation(),\r\n            className);\r\n\r\n        context.ReportDiagnostic(error);\r\n\r\n        return;\r\n    }\r\n}<\/pre>\n
Executing Source Generators<\/h3>\n
We’re done with the Generator<\/code> project, so now let’s get it working.<\/p>\n
There is still no content in our Analyzers<\/code> because we don’t use the [GenerateService]<\/code> attribute, so we can’t generate any code. Let’s start by creating a new model with our attribute, called PersonModel<\/code>:<\/p>\n
[GenerateService]\r\npublic class PersonModel\r\n{\r\n    public int Id { get; set; }\r\n\r\n    public string? Name { get; set; }\r\n}<\/pre>\n
The project needs to be built and upon completion, we will see the generated code in the Solution Explorer analyzer:<\/p>\n
using SourceGeneratorInCSharp.Models;\r\n\r\nnamespace SourceGeneratorInCSharp.Services \r\n{\r\n    public partial class PersonModelService\r\n    {\r\n        private static readonly List<PersonModel> _list = new();\r\n\r\n        public virtual List<PersonModel> All()\r\n        {\r\n            return _list;\r\n        }\r\n\r\n        public virtual void Add(PersonModel item)\r\n        {\r\n            _list.Add(item);\r\n        }\r\n\r\n        public virtual void Update(PersonModel item)\r\n        {\r\n            var existing = _list.Single(x => x.Id == item.Id);\r\n\r\n            _list.Remove(existing);\r\n            _list.Add(item);\r\n        }\r\n\r\n        public virtual void Delete(int id)\r\n        {\r\n            var existing = _list.Single(x => x.Id == id);\r\n\r\n            _list.Remove(existing);\r\n        }\r\n    }\r\n}<\/pre>\n
With the PersonModelService<\/code> generated, let’s use:<\/p>\n
namespace SourceGeneratorInCSharp\r\n{\r\n    using Services;\r\n\r\n    public class Program\r\n    {\r\n        public static void Main(string[] args)\r\n        {\r\n            var personModelService = new PersonModelService();\r\n\r\n            personModelService.Add(new() { Id = 1, Name = \"Mathew\" });\r\n            personModelService.All().ForEach(x => Console.WriteLine(x.Name));\r\n        }\r\n    }\r\n}<\/pre>\n
Testing Source Generators<\/h3>\n
Testing is a very important part of every developer process and as you might expect, writing code generators is no exception.<\/p>\n
Let’s create a MsTest<\/code> project and add it to the current solution:<\/p>\n
dotnet new mstest -o Tests\r\ndotnet sln add SourceGeneratorInCSharp<\/pre>\n
Before creating the test, we need to create a helper method that uses a Roslyn<\/code> resource to perform the code compilation and return the generated output:<\/p>\n
public static class Helper\r\n{\r\n    public static string GetGeneratedOutput(string sourceCode)\r\n    {\r\n        var syntaxTree = CSharpSyntaxTree.ParseText(sourceCode);\r\n\r\n        var references = AppDomain.CurrentDomain.GetAssemblies()\r\n            .Where(assembly => !assembly.IsDynamic)\r\n            .Select(assembly => MetadataReference.CreateFromFile(assembly.Location))\r\n            .Cast<MetadataReference>();\r\n\r\n        var compilation = CSharpCompilation.Create(\"SourceGeneratorTests\",\r\n            new[] { syntaxTree },\r\n            references,\r\n            new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));\r\n\r\n        \/\/ Source Generator to test\r\n        var generator = new ServiceGenerator();\r\n\r\n        CSharpGeneratorDriver.Create(generator)\r\n            .RunGeneratorsAndUpdateCompilation(compilation, \r\n                out var outputCompilation, \r\n                out var diagnostics\r\n            );\r\n\r\n        return outputCompilation.SyntaxTrees.Skip(1).LastOrDefault()?.ToString();\r\n    }\r\n}<\/pre>\n
After that, we can create the test:<\/p>\n
[TestClass]\r\npublic class SourceGeneratorsUnitTest\r\n{\r\n    [TestMethod]\r\n    public void WhenGeneratePersonModelService_ThenReturnCorrectOutput()\r\n    {\r\n        var input = \"\"\"\r\n            using Generator.Attributes;\r\n\r\n            namespace SourceGeneratorInCSharp.Models\r\n            {\r\n                [GenerateService]\r\n                public class PersonModel\r\n                {\r\n                    public int Id { get; set; }\r\n\r\n                    public string? Name { get; set; }\r\n                }\r\n            }\r\n            \"\"\";\r\n\r\n        var expectedResult = \"\"\"\r\n            using SourceGeneratorInCSharp.Models;\r\n\r\n            namespace SourceGeneratorTests.Services \r\n            {\r\n                public partial class PersonModelService\r\n                {\r\n                    private static readonly List<PersonModel> _list = new();\r\n\r\n                    public virtual List<PersonModel> All()\r\n                    {\r\n                        return _list;\r\n                    }\r\n\r\n                    public virtual void Add(PersonModel item)\r\n                    {\r\n                        _list.Add(item);\r\n                    }\r\n\r\n                    public virtual void Update(PersonModel item)\r\n                    {\r\n                        var existing = _list.Single(x => x.Id == item.Id);\r\n\r\n                        _list.Remove(existing);\r\n                        _list.Add(item);\r\n                    }\r\n\r\n                    public virtual void Delete(int id)\r\n                    {\r\n                        var existing = _list.Single(x => x.Id == id);\r\n\r\n                        _list.Remove(existing);\r\n                    }\r\n                }\r\n            }\r\n            \"\"\";\r\n\r\n        var output = Helper.GetGeneratedOutput(input);\r\n\r\n        Assert.AreEqual(expectedResult, output);\r\n    }\r\n}<\/pre>\n
After all of this, we can go ahead and explain some additional points.<\/p>\n
Generating Using SyntaxFactory<\/h2>\n
Another approach to generating source code is using SyntaxFactory<\/code>. It is located at Microsoft.CodeAnalysis.CSharp<\/code>, and provides a comprehensive set of methods for creating syntax nodes and tokens, giving developers the means to programmatically generate C# code.<\/p>\n
We can rewrite the first example:<\/p>\n
[Generator]\r\npublic sealed class ExampleGeneratorSyntaxFactory : IIncrementalGenerator\r\n{\r\n    public void Initialize(IncrementalGeneratorInitializationContext context)\r\n    {\r\n        context.RegisterPostInitializationOutput(ctx =>\r\n        {\r\n            var classBlock = SyntaxFactory.NamespaceDeclaration(SyntaxFactory.ParseName(\"SourceGeneratorInCSharp\"))\r\n                .AddMembers(\r\n                    SyntaxFactory.ClassDeclaration(\"SyntaxFactoryHelloWorld\")\r\n                    .AddModifiers(\r\n                        SyntaxFactory.Token(SyntaxKind.PublicKeyword),\r\n                        SyntaxFactory.Token(SyntaxKind.StaticKeyword)\r\n                    )\r\n                    .AddMembers(\r\n                        SyntaxFactory.MethodDeclaration(\r\n                            SyntaxFactory.ParseTypeName(\"void\"),\r\n                            \"SayHello\"\r\n                        )\r\n                        .AddModifiers(\r\n                            SyntaxFactory.Token(SyntaxKind.PublicKeyword),\r\n                            SyntaxFactory.Token(SyntaxKind.StaticKeyword)\r\n                        )\r\n                        .AddBodyStatements(\r\n                            SyntaxFactory.ExpressionStatement(\r\n                                SyntaxFactory.InvocationExpression(\r\n                                    SyntaxFactory.MemberAccessExpression(\r\n                                        SyntaxKind.SimpleMemberAccessExpression,\r\n                                        SyntaxFactory.IdentifierName(\"Console\"),\r\n                                        SyntaxFactory.IdentifierName(\"WriteLine\")\r\n                                    ))\r\n                                    .WithArgumentList(\r\n                                        SyntaxFactory.ArgumentList()\r\n                                            .AddArguments(\r\n                                                SyntaxFactory.Argument(\r\n                                                    SyntaxFactory.LiteralExpression(\r\n                                                        SyntaxKind.StringLiteralExpression,\r\n                                                        SyntaxFactory.Literal(\"Hello From Generator\")\r\n                                                    )\r\n                                                )\r\n                                            )\r\n                                    )\r\n                            )\r\n                        )\r\n                    )\r\n                ).NormalizeWhitespace();\r\n\r\n            ctx.AddSource(\"ExampleGeneratorSyntaxFactory.g\",\r\n                SourceText.From(classBlock.ToFullString(), Encoding.UTF8));\r\n        });\r\n    }\r\n}<\/pre>\n
As we can see, a lot of methods need to be used to generate even a simple scenario and we can\u2019t immediately see what the code will look like, without checking the results of the generation.<\/p>\n
Emitting Compiler Generated files<\/h2>\n
By default, source generators do not produce artifacts directly. Instead, they generate additional source code during the compilation process, which is compiled along with the rest of the project source code, thus only being viewable through an IDE. This can be a problem, since for this type of file, we can’t do a code review.<\/p>\n
To enable persisting source generator files to the file system, we can set the EmitCompilerGeneratedFiles<\/code> property in our Console<\/code> project file:<\/p>\n
<PropertyGroup>\r\n    <EmitCompilerGeneratedFiles>true<\/EmitCompilerGeneratedFiles>\r\n<\/PropertyGroup><\/pre>\n
By setting the property alone, the compiler will save the generated files to the disk. And then, we can see that the source-generated files are written to the obj<\/code> folder:<\/p>\n
\"Output<\/a><\/p>\n
This can be a problem as the bin<\/code> and obj<\/code>\u00a0folders are normally excluded from source control. We can specify the CompilerGeneratedFilesOutputPath<\/code> property to determine the location of the compiler-emitted files. This property allows us to set a custom path relative to the project root folder:<\/p>\n
<PropertyGroup>\r\n    <EmitCompilerGeneratedFiles>true<\/EmitCompilerGeneratedFiles>\r\n    <CompilerGeneratedFilesOutputPath>Generated<\/CompilerGeneratedFilesOutputPath>\r\n<\/PropertyGroup><\/pre>\n
This will write the files to the Generated<\/code> folder in the project:<\/p>\n
\"Custom<\/a>\u00a0<\/p>\n
Now, when we try to build for a second time after the files have already been written, we get an error:<\/p>\n
Error CS0111 Type 'HelloWorld' already defines a member called 'SayHello' with the same parameter types<\/code><\/p>\n
To resolve this issue, the solution is to remove the emitted files from the project compilation, by using a wildcard pattern to exclude all the .cs files in those folders:<\/p>\n
<ItemGroup>\r\n    <!-- Exclude the output of source generators from the compilation -->\r\n    <Compile Remove=\"$(CompilerGeneratedFilesOutputPath)\/**\/*.cs\" \/>\r\n<\/ItemGroup><\/pre>\n
With this modification, the output of the source generator is now stored on the disk. This ensures it can be included in source control for easy review during pull requests. Also, and most importantly, it no longer affects the compilation process.<\/p>\n
Use Cases<\/h2>\n
Source generators can be used for some common use cases including:<\/p>\n