Incremental Roslyn Source Generators: Using 3rd-Party Libraries – Part 6

We previously talked about how to change the source code generation based on current project dependencies. In this article, the Source Generator itself needs a 3rd-party library, in our case Newtonsoft.Json. This library is a development dependency and will not be rolled out to production.

In diesem Artikel:

pg
Pawel Gerr ist Architekt und Consultant bei Thinktecture. Er hat sich auf .NET Core Backends spezialisiert und kennt Entity Framework von vorne bis hinten.

More information about the Smart Enums and the source code can be found on GitHub:

I recommend to read part 5 of the series because this article is based on the results of the previous one.

In this article, the Source Generator will generate C# code based on the content of JSON, deserialized using the library Newtonsoft.Json. I choose Newtonsoft.Json over System.Text.Json because the latter comes with the framework and is available by default, i.e., it doesn’t suit well as an example.

Expected Results

The DemoCodeGenerator, implemented in the previous part of this series, will generate not just the property Items but a few attributes as well.

				
					namespace DemoConsoleApplication
{
   [Translation("en", "Product category")]
   [Translation("de", "Produktkategorie")]
   partial class ProductCategory
   {
      ...
				
			

JSON will be the source for the translations.

				
					{
  "ProductCategory": {
    "en": "Product category",
    "de": "Produktkategorie"
  }
}

				
			

The TranslationAttribute, as with the EnumGenerationAttribute, is implemented in the project DemoLibrary because both of them are going to be published along with the production code. (See part 1 for more information)

				
					namespace DemoLibrary;

[AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
public class TranslationAttribute : Attribute
{
   public string Language { get; }
   public string Translation { get; }

   public TranslationAttribute(string language, string translation)
   {
      Language = language;
      Translation = translation;
   }
}

				
			

Refactoring

For readers coming from Part 5 of this series, a few preparations are necessary to be able to tell apart the important changes from the refactorings.

The method Generate of the interface ICodeGenerator gets an additional argument translations.

				
					public interface ICodeGenerator : IEquatable<ICodeGenerator> 
{ 
      string Generate(DemoEnumInfo enumInfo, IReadOnlyDictionary<string, string> translations);
      ...
				
			

The DemoCodeGenerator is using a StringBuilder for generation of the C# code, so it is easier to render additional code in between. The code is split before partial class {name} for future generation of the TranslationAttribute.

				
					   public string Generate(DemoEnumInfo enumInfo, IReadOnlyDictionary<string, string> translations) 
   { 
      var ns = enumInfo.Namespace; 
      var name = enumInfo.Name; 
 
      var sb = new StringBuilder(@$"// <auto-generated /> 
#nullable enable 
 
// generation counter: {Interlocked.Increment(ref _counter)} 
 
using System.Collections.Generic; 
using DemoLibrary; 
 
{(ns is null ? null : $@"namespace {ns} 
{{")}"); 
 
      // TODO: TranslationAttribute

      sb.Append(@$" 
   partial class {name} 
   {{ 
      private static IReadOnlyList<{name}>? _items; 
      public static IReadOnlyList<{name}> Items => _items ??= GetItems(); 
 
      private static IReadOnlyList<{name}> GetItems() 
      {{ 
         return new[] {{ {String.Join(", ", enumInfo.ItemNames)} }}; 
      }} 
   }} 
{(ns is null ? null : @"} 
")}"); 
 
      return sb.ToString(); 
   } 
				
			

Adding 3rd-Party Library

A 3rd-party library installed via NuGet requires a few adjustments, so the Source Generator finds the required DLLs when (a) the Source Generator itself is installed via NuGet and (b) the Source Generator is referenced directly via project reference.

After installation of the NuGet package to DemoSourceGenerator.csproj, the package reference needs the attribute PrivateAssets set to all, so it stays a development dependency and is not rolled out to production. Additionally, the attribute GeneratePathProperty must be set to true to get a path to the assets of the NuGet package. The path is built from the package name by replacing the . with _ and by prefixing it with Pkg

				
					<Project Sdk="Microsoft.NET.Sdk">
   ...
   <ItemGroup>
      ...
      
      <PackageReference Include="Newtonsoft.Json"
                        Version="13.0.1"
                        PrivateAssets="all"
                        GeneratePathProperty="true" /> 
 
      <None Include="$(PkgNewtonsoft_Json)\lib\netstandard2.0\*.dll"
            Pack="true"
            PackagePath="analyzers/dotnet/cs"
            Visible="false" /> 
   </ItemGroup>
   
</Project>

				
			

As with the DLL of the Source Generator, all dependencies must be copied to analyzers/dotnet/cs when building a NuGet package.

If the Source Generator is not referenced directly by another project, then no further adjustments of the DemoSourceGenerator.csproj are necessary. Otherwise, the compiler needs a hint of where to search for further dependencies. Each dependency must be specified using the TargetPathWithTargetPlatformMoniker.

				
					<Project Sdk="Microsoft.NET.Sdk"> 
   ...
 
    
   <PropertyGroup> 
      <GetTargetPathDependsOn>
          $(GetTargetPathDependsOn);GetDependencyTargetPaths
      </GetTargetPathDependsOn> 
   </PropertyGroup> 
 
   <Target Name="GetDependencyTargetPaths"> 
      <ItemGroup> 
         <TargetPathWithTargetPlatformMoniker
            Include="$(PKGNewtonsoft_Json)\lib\netstandard2.0\Newtonsoft.Json.dll"
            IncludeRuntimeDependency="false" /> 
      </ItemGroup> 
   </Target> 
 
</Project> 

				
			

Parsing JSON

The last step is to parse JSON in DemoSourceGenerator and pass the translations to the code generators.

There are 2 flaws in this demo: JSON is hard-coded, and there is no try-catch when parsing JSON. Both issues are going to be addressed in the next part of this series.

				
					[Generator] 
public class DemoSourceGenerator : IIncrementalGenerator 
{ 
   private static readonly IReadOnlyDictionary<string, string> _noTranslations
        = new Dictionary<string, string>(); 
 
   private const string _TRANSLATIONS = @" 
{ 
   ""ProductCategory"": { 
      ""en"":  ""Product category"", 
      ""de"": ""Produktkategorie"" 
   } 
}"; 
 
   ...
 
   private static void GenerateCode( 
      SourceProductionContext context, 
      (DemoEnumInfo, ImmutableArray<ICodeGenerator>) tuple) 
   { 
      var (enumInfo, generators) = tuple; 
 
      if (generators.IsDefaultOrEmpty) 
         return; 
 
      var translationsByClassName = JsonConvert.DeserializeObject<
            Dictionary<string, IReadOnlyDictionary<string, string>>>(_TRANSLATIONS); 
 
      foreach (var generator in generators.Distinct()) 
      { 
         if (translationsByClassName is null
            || !translationsByClassName.TryGetValue(enumInfo.Name, out var translations)) 
        {
            translations = _noTranslations; 
        }

         var ns = enumInfo.Namespace is null ? null : $"{enumInfo.Namespace}."; 
         var code = generator.Generate(enumInfo, translations); 
 
         if (!String.IsNullOrWhiteSpace(code)) 
            context.AddSource($"{ns}{enumInfo.Name}{generator.FileHintSuffix}.g.cs", code); 
      } 
   } 
} 

				
			

The DemoCodeGenerator generates attributes according to the provided translations.

				
					public sealed class DemoCodeGenerator : ICodeGenerator 
{ 
   ...
   
   public string Generate(DemoEnumInfo enumInfo, IReadOnlyDictionary<string, string> translations) 
   { 
      ...
 
{(ns is null ? null : $@"namespace {ns} 
{{")}"); 
 
      GenerateTranslationAttributes(sb, translations); 
 
      sb.Append(@$" 
   partial class {name} 
      ...
   } 
 
   private static void GenerateTranslationAttributes( 
      StringBuilder sb, 
      IReadOnlyDictionary<string, string> translations) 
   { 
      foreach (var kvp in translations) 
      { 
         sb.Append(@" 
   [Translation(""").Append(kvp.Key).Append("\", \"").Append(kvp.Value).Append("\")]"); 
      } 
   } 
 
				
			

Summary

Referencing and using other NuGet packages inside a Source Generator works almost the same as with any other project. But your Source Generator might be not the only one using a 3rd-party dependency. A project referencing multiple Source Generators with incompatible dependencies will run into issues.

Kostenloser
Newsletter

Aktuelle Artikel, Screencasts, Webinare und Interviews unserer Experten für Sie

Verpassen Sie keine Inhalte zu Angular, .NET Core, Blazor, Azure und Kubernetes und melden Sie sich zu unserem kostenlosen monatlichen Dev-Newsletter an.

Newsletter Anmeldung
Diese Artikel könnten Sie interessieren
.NET
pg

Handling Complexity: Introducing Complex Value Objects in .NET

While simple value objects wrap single primitives, many domain concepts involve multiple related properties (e.g., a date range's start and end). This article introduces Complex Value Objects in .NET, which group these properties into a cohesive unit. This ensures internal consistency, centralizes validation, and encapsulates behavior. Discover how to implement these for clearer, safer code using the library Thinktecture.Runtime.Extensions, which minimizes boilerplate when handling such related data.
01.07.2025
.NET
pg

Smart Enums: Beyond Traditional Enumerations in .NET

Traditional C# enums often fall short when needing to associate data or behavior with constants, or ensure strong type safety. This article explores the "Smart Enum" pattern as a superior alternative. Leveraging the library Thinktecture.Runtime.Extensions and Roslyn Source Generators, developers can easily implement Smart Enums. These provide a robust, flexible, and type-safe way to represent fixed sets of related options, encapsulating both data and behavior directly within the Smart Enum. This results in more maintainable, expressive, and resilient C# code, overcoming the limitations of basic enums.
17.06.2025
.NET
pg

Value Objects: Solving Primitive Obsession in .NET

Overusing primitive types like string or int for domain concepts ("primitive obsession") causes bugs from missed validation, like invalid emails or negative monetary values. This article explores Value Objects as a .NET solution. Learn how these self-validating, immutable types prevent entire classes of errors, make code more expressive, and reduce developer overhead. We'll demonstrate creating robust domain models with minimal boilerplate, improving code quality without necessarily adopting full Domain-Driven Design, and see how Roslyn Source Generators make this practical.
03.06.2025
Database Access with Sessions
.NET
kp_300x300

Data Access in .NET Native AOT with Sessions

.NET 8 brings Native AOT to ASP.NET Core, but many frameworks and libraries rely on unbound reflection internally and thus cannot support this scenario yet. This is true for ORMs, too: EF Core and Dapper will only bring full support for Native AOT in later releases. In this post, we will implement a database access layer with Sessions using the Humble Object pattern to get a similar developer experience. We will use Npgsql as a plain ADO.NET provider targeting PostgreSQL.
15.11.2023
Old computer with native code
.NET
kp_300x300

Native AOT with ASP.NET Core – Overview

Originally introduced in .NET 7, Native AOT can be used with ASP.NET Core in the upcoming .NET 8 release. In this post, we look at the benefits and drawbacks from a general perspective and perform measurements to quantify the improvements on different platforms.
02.11.2023
.NET
kp_300x300

Optimize ASP.NET Core memory with DATAS

.NET 8 introduces a new Garbage Collector feature called DATAS for Server GC mode - let's make some benchmarks and check how it fits into the big picture.
09.10.2023