csharp-source-generators

official documentation

dotnet/roslyn feature design document

describing the compiler feature

dotnet/roslyn cookbook

to help with generator creation

dotnet/roslyn-sdk samples

show how to implement a source generator and use features like external package references ( generators). Includes AutoNotify, Csv, Maths, Mustache, and SettingsXml

an online Source Generator Playground to play with generator ideas 💡 without any setup noise.

davidwengier/SourceGeneratorTemplate

A basic template for writing a C# source generator, from the Roslyn dev

AutoCtor

AutoCtor is a Roslyn Source Generator that will automatically create a constructor for your class for use with constructor Dependency Injection

AutoRegisterInject

Automatically generate Microsoft Dependency Injection ServiceCollection registrations for your classes from attributes

DependencyInjection.SourceGenerators

This project is a C# source generator designed to simplify and automate the registration of dependencies in Microsoft's Dependency Injection service collection. By using this package, developers can enhance the clarity and efficiency of their code by reducing the need for manual service registration

DependencyManagement

The Dependency Management is a very fast dependency injection and components container, with many interesting features, and without reflection

GrpcInjection

- GrpcInjection is a tool that allow you to inject Services and Interceptor in time of compilation inside of GRPC Projects using C# source generator

Injectio

- Source generator that helps register discovered services in the dependency injection container

Jab

- Compile Time Dependency Injection

lambdajection

Framework for building AWS Lambdas using dependency injection and aspect-oriented programming

MrMeeseeks.DIE

An unambigous, convenient, flexible and feature rich compile time dependency injection container

Pure.DI

- dependency injection for .NET without any IoC/DI containers, frameworks, dependencies, and thus without any performance impact and side-effects

SourceInject

A source generator that allow you to generate your services for dependencies injection during compile time

StrongInject

- compile time dependency injection for .NET

Thunderboltloc

One of the very first IoC frameworks for .Net that has no reflection

AutoSpectre

Generates a service for prompting and populating a class using the Spectre.Console library

docopt.net

generates C# source code that parses command-line arguments into a strong-typed arguments class (also generated), given the as part of the CLI. In other words, write the help message for your program and get the entire parser generated for free!

Figgle

- Generate ASCII banner text at compile time (or run time) using figlet fonts

AutoDto

- A source generator that generates DTO models from BL to avoid same BL and DTO models

Flattening

- C# source generator for generating flattened classes from complex domain classes

GraphQL.Tools

- A GraphQL to C# compiler (code-generator) which turns your GraphQL schema into a set of C# classes, interfaces, and enums

Mapperly

- A source generator for generating object mappings. Inspired by MapStruct

MappingCloningExtensions

Generates extensions of objects for mapping and cloning using either attributes or fluent style. Also, supports deep copying and specfiying whether it can do a deep copy and the possibility of doing so safely

Mapster

- A fast, fun and performant object to object Mapper. Has better performance and is more memorry efficient than Automapper. Besides code generation, supports also Fluent API

MapTo

- A convention based object to object mapper similar to Automapper

NextGenMapper

Easy-to-use mapper without configuration

SourceMapper

- generates Mappers code based on attributes used on interfaces or abstract classes. It is inspired by Java

SourceMapper

A source generator that creates extension methods for cloning and mapping

CoreWCF

CoreWCF provides support of WCF server side code on .NET Core / .NET6. CoreWCF allows users to inject services into implementation using a source generator to provide an implementation that fits the expected . The supplied implementation fetch services from the DI container the same way the attribute works in ASP.NET core MVC Controllers. The source generator supports both a dedicated attribute and the ASP.NET Core MVC attribute

Imp.NET

- a fast, high-level, object-oriented C# networking library that supports the invocation of remote methods through proxy interface objects

IoTHubClientGenerator

Build a C# Azure IoT Device client program in seconds!

ComputeSharp

A .NET library to run C# code in parallel on the GPU through DX12 and dynamically generated HLSL compute shaders, which are transpiled from C# and precompiled at build-time using source generators

Svg to C# Source Generators

SVGC compiles SVG drawing markup to C# using SkiaSharp as rendering engine. SVGC can be also used as codegen for upcoming C# 9 Source Generator feature

BetterEnums

C# Enums with values and better performance as a source generator

Credfeto.Enumeration.Source.Generation

Enum to text generator for enums - generates strongly typed enums for all enums in the assembly, and using attribute for third party enums. Also includes an analyzer to ensure that all enum usages use the extension method rather than

Enum.Source.Generator

A C# source generator to create an enumeration (enum) class from an enum type. With this package, you can work on enums very, very fast without using reflection

EnumClass

Generate Kotlin's from C# with additional features like Switch function (instead of statement). It also contains support libraries like generator for JsonConverter for generated classes

EnumerationClassGenerator

- A C# source generator to create an enumeration class from an enum type

EnumFastToStringDotNet

- Automatically generates enum extension methods that implement a switch expression based ToString method

EnumUtilitiesGenerator

- A source generator to generate compile-time mapping of enums and description attributes

FastEnumGenerator

An enum like generator where you create a partial class with private enum and it will generate an enum like record struct even including returning the words and a list

JOS.Enumeration

Enumeration class powered by source generation

Generator.Equals

generates equality and hashing for classes and records, supports a number of strategies for comparing collections and properties

RSCG_UtilityTypes

Add Omit and Pick attributes to generate classes from existing class, like in TypeScript

Strongly

Easily generate serializable domain value types

ValueObjectGenerator

C# source generator is for ValueObjects (ie.Wrapper classes)

Vogen

C# source generator and code analyser that generates strongly typed domain identities

WrapperValueObject

- for creating simple value objects wrapping primitive types

Immutype

- generates extension methods to support immutability

Visor

C# optics library with incremental code generator (maintained fork of )

AnyOf

The Source Generator creates a type to handle multiple defined types as input parameters for methods

dotVariant

A type-safe and space-efficient sum type for C# (comparable to discriminated unions in C or C++)

Dunet

A simple source generator for in C#

Funcky Discriminated Unions

A source generator that generates methods for all your discriminated unions needs. ✨ Can be used with or without the functional programming library Funcky

N.SourceGenerators.UnionTypes

Discriminated union type source generator

Unions

for generating meaningful, efficient union types

AutoDeconstructable

Generator for efficient and automatic flat text serializer/deserializer using in library

Azura

Generates binary [de]serializers on Streams at design time

CSV-Parser-Generator

A Parser for CSV with support for uncommon line separators (e.g. Unicode) and instantiation of read-only objects and working nullable handling

ProtobufSourceGenerator

- A source generator that generates partial helper classes where member properties are attributed with ProtoMember attribute

SerdeDn (serde-sn)

is a port of the popular Rust serialization/deserialization library to .NET. Basic cases are fully automated using a C# source generator

SpreadCheetah

Create Excel files with a C# Source Generator for generating the rows

StackXML

Stack based zero-allocation XML serializer and deserializer

StructPacker

binary serializer that auto-generates C# serialization code to achieve peak runtime performance and efficiency

Tinyhand

- Tiny and simple data format/serializer using a source generator

GeneratedJsonConverters

- generate json converters for polymorph contracts and string based enum serialization

JsonByExampleGenerator

- generate classes based on example json files in your project

JsonDeserializeResourceSourceGenerator

Instead of having to do embedded resource, can instead have json as additional file and it will produce a c# string and will deserialize to a type specified

JsonPolymorphicGenerator

- Source Code Generator for System.Text.Json JsonDerivedType attributes on polymorphic classes

JsonSerializerContextGenerator

A source generator that produces nearly the same code ahs system.json.text but easier to use because you only have to put an attribute for a model class you want to produce for. Also, produces a method to register to make it easy to use that source generator when serializing/deserializing json

JsonSrcGen

- compile time JSON serializer generation

TeuJson

A Reflection-less and Lightweight Json Library using source generator

kli.Localize

- localize strings from json files via source code generation

MrMeeseeks.ResXToViewModelGenerator

Takes ResX files and generates localization ViewModels for a more convenient usage of localization in MVVM projects

ResXGenerator

Generates strongly-typed resource classes for looking up localized strings

Buildenator

Generate data builder classes for testing purposes (and not only) for your entities. Autofixture + Moq extensions

FluentAssertions.Eventual

- Generates a specialized waiting wrapper for assertions, offering a syntax similar to plain

ScenarioTests

Test your code like you would write a notebook. Simply and effective

GRPC-Mock-Server

- A source generator for stubbing GRPC services

InterfaceGenerator

- Auto generate interface definition by implementation, for when you need an abstraction for the sake of mocking

MockableStaticGenerator

A C# source generator to make an interface and a class wrapper to test static/extension methods

MockGen

A C# mocking library based on source generators

MockSourceGenerator

A C# mocking library that generates mocks at compile-time using a source generator

ProxyInterfaceGenerator

generate an interface and a Proxy class for classes. This makes it possible to wrap external classes which do not have an interface, in a Proxy class which makes it easier to Mock and use DI

Rocks

A mocking library based on the Compiler APIs (Roslyn + Mocks)

Lombok.NET

Generates boilerplate code and common code patterns. As the name suggests, it is the .NET version of Java's Lombok

DumplingsDevs.Pipelines

The most flexible mediation implementation in the .NET ecosystem with your own types

Immediate.Handlers

An implementation of the Mediator pattern in .NET using source generators, without using a central mediator instance

Mediator

- a high performance implementation of Mediator pattern in .NET using source generators

MediatR controllers generator

This generator generates controllers and their methods based on your requests

Plastic

This project provides encapsulation of things like Domain, Application Rules, Business Rules or Business Logic in Application

Data Builder Generator

Generate data builder patterns for your model classes

FluentBuilder

- A project which uses Source Generation to create a FluentBuilder for a specified model or DTO

M31.FluentAPI

- Generate fluent APIs for your C# classes with ease

avatar

A modern compile-time generated interception/proxy library

DudNet

A C# source generator for implementing a proxy pattern

MrMeeseeks.Visitor

Generates the boilerplate code for applications of the Visitor pattern

AutoInterface

interface-to-member source generator

AltaSoft.DomainPrimitives

- A C# toolkit purposefully designed to accelerate the development of domain-specific primitives within your applications. This streamlined solution empowers developers to efficiently encapsulate fundamental domain logic. Through this toolkit, you'll significantly reduce code complexity while improving the maintainability of your project

Architect.DomainModeling

A complete Domain-Driven Design (DDD) toolset for implementing domain models, including base types and source generators for ValueObjects, WrapperValueObjects, Entities, and Identities

GenerateHelperLibraries

A source generator where you can send any code to the client without having to do as a string. Helper for custom classes a client has to override in order to have additional features for source generators. Intended to be used from another source generator

Gobie

- Allows developers define and use custom source generation without writing any generator code themselves or learning the Roslyn APIs. Instead, devs define the generator they want, in C#, and can then use that generator throughout their project

Matryoshki

Metaprogramming framework based on C# source generators. It allows you to define behaviours with adornments and generate decorators for arbitrary types

SourceGeneratorQuery

- C# SourceGenerator helper which helps you query your files, and adds LINQ support

AjaxService.Gen

- Automatically Generate typescript Ajax calls based on your C# Api endpoints

ApiClientGenerator

Generates a strongly typed HttpClient based off MVC's default routing. Can be used to output into multiple projects, like Blazor WebAssembly

ControllerGenerator

Automatically generate controllers from services in a web application

HttpClientCodeGenerator

- HttpClientGenerator is a tool that uses the Roslyn code generator feature to write boilerplate HttpClient code for you

Ridge

Generates strongly-typed clients for API based on controller definition and internal application details

Safe-Routing

Analyses a project's razor pages and MVC controllers, producing strongly-typed representations of those routes as you type

TypedSignalR.Client

C# Source Generator to create strongly typed SignalR clients

H.NSwag.Generator

- C# Source Generator for NSwag

SourceApi

- API first Open API code generator based on json or yaml definitions. It generates base abstract controllers with docs, routes, that you inherit and implement in your controllers

ST.NSwag.ServerSourceGenerator

Generates Web API/ASP.NET Core controllers from a OpenAPI specification

BlazorInteropGenerator

Generates Blazor -> Javascript strongly typed interop methods, by parsing the Javascript it self and generating extension methods for IJSRuntime

BlazorOcticons

Github created as a components using source generator. The generated components are available via the NuGet package, the generator itself is available as a separate NuGet package. The project is an example using the generated components

MiniRazor

Portable Razor compiler & code generator

RazorPageRouteGenerator

Generates methods with parameters for Razor and Blazor pages, so you can navigate without having to guess URLs or parameters

Avalonia.NameGenerator

Generates typed references to named XAML controls

boilerplatezero

WPF Dependency Property and Routed Event generator

DependencyPropertyGenerator

Dependency property and routed event source generator for WPF/UWP/WinUI/Uno/Avalonia/MAUI platforms

WinUI-ObservableSettings

- Generate boilerplates to read and write settings in packaged WinUI 3 app

PropertyChanged.SourceGenerator

- Powerful INotifyPropertyChanged Source Generator, which generates INPC boilerplate for you as part of your build. Supports features such as automatic and manual dependencies between properties, notifications when specific properties change, and more

ValueChangedGenerator

for generating PropertyChanged from inner struct members

DevExpress.Mvvm.CodeGenerators

Generates boilerplate code for your View Models (INotifyPropertyChanged, Commands, IDataErrorInfo, DevExpress services). Compatible with the Prism and MVVM Light libraries

Microsoft MVVM Toolkit

A modular MVVM library with support for source generators to reduce boilrplate and improve performance

MvvmGen

A lightweight MVVM library for XAML applications that generates your ViewModels with a C# Source Generator

AdaskoTheBeAsT.Identity.Dapper

- Custom Dapper implementation for Microsoft.Extensions.Identity.Stores (part of ASP.NET Core Identity)

Breezy

Micro ORM with source generator

MapDataReader

- Fast mapping to a custom class

SqlMarshal

Native AOT friendly-performant mini-ORM. Generation of wrappers for accessing SQL using ADO.NET

dot-env-generator

A source generator for C# that turns files into runtime constants

EnvVariablesGenerator

Generate code from files that can be changed after build

NotNot.AppSettings

Automatically create strongly typed C# settings objects from AppSettings.json

SourceConfig

- Generates configuration POCO objects, lists, dictionaries in AOT based on *.json config files

StronglyTypedEmbeddedResources

Generates strongly typed names for Embedded Resources automatically

TxtToListGenerator

A source generator where if you have a text file as additional file and you have a list ordered by return carriages, then it produces either a list of int or a list of string in c#

Transplator

A simple C# source generator for text templates

Weave

Weave is a text templating engine for .NET that is all about attention to detail. Weave handles the tricky work of making your rendered text beautiful

AutoConstructor

C# source generator that generates a constructor from readonly fields/properties in a class or struct

AutoFilterer.Generators

AutoFilterer.Generators aims to generate filter DTOs from entities automatically via using dotnet source generators

AutomaticInterface

Generate an Interface from a class

AutoInvoke

A generator that generates a method that invokes a specified generic method, for every Type in your project that satisfies a defined constraint

BigMachines

BigMachines is State Machine library for .NET

BitsKit

A C# library for efficient bit-level reading and writing also adding bit field support

CacheSourceGenerator

Generates an IMemoryCache wrapper around a method call

Cloneable

auto-generate Clone method

Durian

Extends the default capabilities of C# by mimicking features from other languages

Fairy

generates C# code based on Sitecore Content Serialization (SCS) files

FastGenericNew

The ultimate fast alternative to / . Built on SourceGenerator V2 (Incremental Generator)

GitBuildInfo.SourceGenerator

- for dumping the git information (commit hash, branch, the head description) into assembly level metadata attributes

Hangfire.RecurringJob

- Automatically generates the recurring job registration code

IDisposableGenerator

- a Source Generator for Generating the Dispose functions in Disposables. All you have to do is mark them with attributes and it will work from there

Lazysh

Lazy implementation of any interface

LinqGen

Alloc-free and fast replacement for Linq, with code generation

LoggingDecoratorGenerator

Generates logger decorator class for an interface. Uses Microsoft.Extensions.Logging.ILogger to log and requires it in decorator class constructor

MemberAccessGenerator

generates and/or methods that return property value for a given property name or index (e.g. in positional records)

MrMeeseeks.StaticDelegateGenerator

Makes static classes and members injectable as dependency by generating delegating interfaces and their implementing classes

Navitski.Crystalized

Generates domain model based on schema files. Generated model supports undo/redo, saving to/loading from SQLite and Json files, precise changes tracking and more

net_automatic_interface

.Net Core Source Generator for Automatic Interfaces

PolySharp

Provides generated, source-only polyfills for C# language features, to easily use all runtime-agnostic features downlevel

PrimaryConstructor

Generate primary constructor from readonly fields

PrimitiveStaticDataGenerator

for creating methods that return optimized static data from primitive values

PrintMembersGenerator

helps re-defining C# record's PrintMembers method to force include/exclude certain members

QuickConstructor

A reliable and feature-rich source generator that can automatically emit a constructor from the fields and properties of a class. It can also generate null checks based on nullable reference types annotations

SmallSharp

Create, edit and run multiple C# 9.0 top-level programs in the same project by just selecting the startup program from the start button

SmartAnnotations

A library that uses source generators to automatically generate data annotations for your models. It provides a strongly-typed mechanism (fluent like API) to define your annotation rules

StringLiteralGenerator

for optimizing UTF-8 binaries

SyncMethodGenerator

- Generates a synchronized method from your async code

ThisAssembly

Exposes project and assembly level information as constants in the ThisAssembly class

ToString

- C# source generator for implementing override like type

TupleOverloadGenerator

- Overload array parameter with tuples avoiding heap allocations

ValueLink

A C# Library for creating and managing multiple links between objects

AttributeFactoryGenerator

- Generate factories to easily parse actual attribute instances from symbol data

AttributesSourceGeneratorHelper

A source generator to help another generator by producing attributes. Anything that inherits from Attribute will be sent to the client so you don't have to build strings for attributes

CommonSourceGeneratorsHelpers

A generator to create many helpers for source generators to use to make up that its very difficult to reference third party libraries in source generators including extensions and a source code string builder

HotReload

- A simple hack to enable hot reload in Visual Studio Intellisense when developing a source generator project together with an example dependent client project inside a single solution

SourceGeneratorUtils

An essential library equipped with utility functions and helpers to aid in writing source files for source generators or for general purposes. Based on the source generator architecture for best-practices

SourceGenerator.Helper.CopyCode

- A simple Generator that generates a string representation to an annotated Type

(2022-02-01) Complete series about how to create an incremental source generator, using the APIs introduced in .NET 6

(2022-01-15) Generating CRUD controller from DTO model using text template

(2021-01-27) that shows how to implement a simple DSL

(2021-01-19) demonstrates the comparison between Source Generators, T4 template and Reflection, etc

(2020-12-16) explores how source generators can be used to automatically generate an API for a system using the MediatR library and the CQRS pattern

(2020-11-20) introduces source generators and briefly mentions how they are being worked into the ReSharper product

(2020-11-09) contains a rich and deep dive into a real world generator with lots of useful tips

(2020-10-10) demonstrates how to profile your source generator using the

(2020-10-09) contains debugging tips

(2020-09-17) rich story of how ThisAssembly generator was written using Scriban templates

(2020-08-25) that shows some simple samples

(2020-04-29) that announces the feature

(2020-11-13) Roslyn dev takes deep dive into the topic

(2020-10-08) shows how Generators work and how they can be tested

(2020-08-12) has Roslyn PMs discussing the feature

RyanAlameddine/SourceGeneratorDemo

contains 3 demos: hello world, INPC and OpCode class

TMC-CSharp/CodeExerciseLibrary

Library to help creating C# exercises. Generates missing methods and classes inside tests on the fly by using Source Generators

DpdtInject

DI container based on C# Source Generators. Its goal is to remove everything possible from runtime and make resolving process as faster as we can. This is achieved by transferring huge piece of resolving logic to the compilation stage into the source generator

jakubsturc/talk-csharp-source-generators

contains 4 generators: AutoNotify, ConsoleWritelineHijack, HelloWorld and SettingsXml, plus nice presentation slides

Compile Time Method Execution Generator

proof of concept that allows executing a method during compilation, so that it can be really fast during runtime

Elskom/Sdk

Dumps git repository data to assembly level metadata attributes that can be checked at runtime for things like trapping if a user is using an possibly unstable build of the libraries built in the repository and so the user can see a message about it (and optionally opt into running the possibly unstable code)

Heroicons.AspNetCore

that are easy to use in ASP.NET Core MVC as TagHelpers

NetFabric.Hyperlinq

generates overloads for its extension methods

RestEase

uses Source Generator to generate interface implementations on compile time instead of in runtime via Reflection.Emit

WarHub/wham

generates code for immutable tree object graph based on red-green node approach used in Roslyn; generates custom XmlSerializer that supports C#9 records and ImmutableArray