docs.microsoft.com

official documentation.

dotnet/roslyn feature design document

describing the compiler feature.

dotnet/roslyn-sdk samples

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

SourceGeneratorPlayground

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

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.

CircleDI

The world only full-power circular Service Provider. It can resolve circular dependencies, has compile time safety and optimal performance.

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…

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.

Immediate.Injections

Source generated dependency injection registrations

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.

ServiceScan.SourceGenerator

Type scanning source generator for Microsoft.Extensions.DependencyInjection services registrations inspired by Scrutor.

SourceDepend

Simply tag members with a [Dependency] attribute and those will be added to the constructor, saving you from manual coding the constructor.

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

ConsoleAppFramework

Zero Dependency, Zero Overhead, Zero Reflection, Zero Allocation, AOT Safe CLI Framework powered by C# Source Generator.

docopt.net

generates C# source code that parses command-line arguments into a strong-typed arguments class (also generated), given just the POSIX-style usage in plain text 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

Facet

A source generator that instantly scaffolds DTOs, ViewModels and typed LINQ projections.

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 MapStruct

SourceMapper

A source generator that creates extension methods for cloning and mapping.

FastCloner

A source generator for deep cloning of objects with automatic reflection-based fallback for types that cannot be cloned ahead of time.

CoreWCF

CoreWCF provides support of WCF server side code on .NET Core / .NET6. CoreWCF allows users to inject services into OperationContract implementation using a source generator to provide an OperationContract implementation that fits the expected ServiceContract. The supplied implementation fetch…

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 EnumText attribute for third party enums. Also includes an analyzer to ensure that all enum usages use the .GetName extension method rather than .ToString.

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 enum class from C# enum with additional features like Switch function (instead of switch 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.

EnumUtilities

A source generator that creates extension methods and utilities for enums with flags support, atomic operations (InterlockedAdd, InterlockedOr, etc.), and JSON converter generation.

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

NetEscapades.EnumGenerators

A source generator for generating fast "reflection" methods for enums

RapidEnum

RapidEnum is a Source Generator that provides fast-running enum utilities for C#/.NET. It is faster than the .NET API and achieves zero allocation for all methods.

ComparisonOperatorsGenerator

A Source Generator package that generates the >, >=, <, <= operators for a partial type (class, struct or record) which implements IComparable<T>.

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

StronglyTypedId

A Rosyln-powered generator for strongly-typed IDs

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 suspended Tinkoff project)

AnyOf

The Source Generator creates a AnyOf<First, TSecond, ...> 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 discriminated unions in C#.

Funcky Discriminated Unions

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

MatchGenerator

Bring exhaustive pattern matching to C# enums and unions with zero boilerplate.

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 Deconstructable aspect in NTP library.

Azura

Generates binary [de]serializers on Streams at design time.

Csv-CSharp

Csv-CSharp is a highly performant CSV (TSV) parser for .NET and Unity. It is designed to parse UTF-8 binaries directly and leverage Source Generators to enable serialization/deserialization between CSV (TSV) and object arrays with zero (or very low) allocation.

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.

GenPack

is a library that uses the .NET source generator to automatically generate packets as classes once you define a schema for the packets. It's easy to use and the results are useful.

MemoryPack

Zero encoding extreme performance binary serializer for C# and Unity.

MessagePack for C#

Extremely Fast MessagePack Serializer for C#(.NET, .NET Core, Unity, Xamarin). / msgpack.org[C#]

ProtobufSourceGenerator

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

protobuf-net

protobuf-net is a contract based serializer for .NET code, that happens to write data in the "protocol buffers" serialization format engineered by Google.

SerdeDn (serde-sn)

is a port of the popular serde.rs 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.

VYaml

VYaml is a pure C# YAML 1.2 implementation, which is extra fast, low memory footprint with focued on .NET and Unity.

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 as 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.

CacheSourceGenerator

Generates an IMemoryCache wrapper around a method call.

Immediate.Cache

Generates cache wrappers for Immediate.Handlers handlers.

EasyValidate

High-performance, type-safe .NET source generator that uses attributes to automatically generate validation for properties, fields, and method parameters. Easy Validate supports async validation, integrates with dependency injection, and includes rich analyzers and code fixers for a seamless…

Immediate.Validations

Source generated validations for easy integration with Immediate.Handlers

Validly

A performant, zero-allocation, and highly customizable validation library that generates validation logic based on attributes, with usage similar to DataAnnotations.

ValidationModules

High-performance validation library that uses attributes or fluent style validation. Built-in support for dependency injection, localization, and a plethora of analyzers, combine to make a great development experience.

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 FluentAssertions assertions, offering a syntax similar to plain FluentAssertions.

ScenarioTests

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

Forged

A fake data generation library that respects and enforces required properties.

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.

KnockOff

Source-generated mocking library with a hybrid stub+mock design. Stubs are real classes you define once and reuse across your test project, with full mock capabilities (Return, Verify, When chains) built in.

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).

ActorSrcGen

Generates boilerplate to turn simple C# classes into TPL Dataflow compatible pipelines with robust and performant asynchronous and concurrent code.

InlineComposition

A source generator that merges the content of other classes into one class. A simple workaround for struct inheritance or multiple inheritance.

JinShil.MixinSourceGenerator

A simple, but powerful source generator that implements the mixin design pattern by copying members—along with their attributes and XML documentation comments—verbatim from one or more source classes/structs into anaother, forming a composition of said classes/structs.

Lombok.NET

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

Minerals.AutoMixins

Package for automatic mixin design pattern generation using an incremental source generator.

Minerals.AutoCQRS

NuGet package that provides interfaces for implementing the CQRS pattern (Commands, Queries, and Pipelines) along with automatic dependency injection and no MediatR package overhead.

DumplingsDevs.Pipelines

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

Foundatio Mediator

Blazingly fast, convention-based C# mediator powered by source generators and interceptors.

Immediate.Handlers

The fastest source generator implementation of the Mediator pattern in .NET, 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 MediatR 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.

StepwiseBuilderGenerator

Generate stepwise (fluent) builders effortlessly.

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.

Visitor.NET

First-ever acyclic generic extensible typesafe implementation of Visitor pattern for .NET without any usage of dynamic cast. Implementation powered by Source Generators

AutoInterface

interface-to-member source generator.

Minerals.AutoInterfaces

Package for automatic interface generation using an incremental source generator.

SuperFluid

Generates the interfaces to represent a fluent API with grammar

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…

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.

Minerals.AutoDomain

This package provides a fast method of defining domain layer components with their specific implementation, such as aggregates, entities and domain events. Package has built-in strongly typed IDs.

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.

comptime

Comptime brings meta-programming capabilities to C#, enabling compile-time code generation and evaluation.

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

EndpointHelpers

Generates URL helpers, link generators and redirects from controller actions.

HttpClientCodeGenerator

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

Immediate.Apis

Generates minimal APIs bindings for Immediate.Handlers handlers.

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.

Blazor.TSRuntime

An improved JSRuntime with automatic JS-module loading and caching, compile time errors instead of runtime errors and nice IntelliSense guidance.

BlazorInteropGenerator

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

BlazorOcticons

Github Octicons created as a .razor 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 website 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 Avalonia 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)

AutoDbSet

Source Generator to automatically create DbSet<T> properties on the DbContext from marked entities

Breezy

Micro ORM with source generator.

Dynatello

A source generator for the low-level API of DynamoDB.

EntityLengths.Generator

Source Generator designed to automatically generate string length constants from Entity Framework configurations and data annotations.

MapDataReader

Fast mapping IDataReader to a custom class

NpgsqlSourceGenerators

Source Generator to automatically register marked enums with NpgSQL for use with PostgreSQL

SqlMarshal

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

TableStorage

Streamlined way of working with Azure Data Tables that mimics Entity Framework's way of working with DbSets. Source Generators for the Table Entities to avoid any reflection calls being made, making it easier to use Azure Data Tables in a NativeAOT project.

Unflat

ORM for zero allocation fast parsing into complex classes/structs with custom type parsers support

Daikoz.SQLWrapper

Generate ADO wrapper from SQL query on MariaDB and MySQL database. SQL Query checker and keep performance.

ConfigBinder

Source-generated zero-reflection configuration binding for IOptions<T> pattern, with optional validation using Immediate.Validation

dot-env-generator

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

EnvVariablesGenerator

Generate code from .env 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.

TemplatePropertyGenerator

Generates strongly typed stringformatters based on Stringformats

AssemblyVersionInfo

AssemblyVersionInfo is a very simple source generator that generates constant strings of your assembly name and version. The intended usage is for the System.CodeDom.Compiler.GeneratedCodeAttribute.

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.

AutoInterface

AutoInterface is a source generator that generates an interface based on your class/struct. Basically, you write your class and get the corresponding interface for free.

AutoInvoke

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

AutoLoggerMessage

Automatically migrates your logging calls to the LoggerMessage (high-performance logging) version

AutomaticInterface

Generate an Interface from a class.

BigMachines

BigMachines is State Machine library for .NET.

BitsKit

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

BuildInformationGenerator

Adds build information, like build time, commit id and branch, as simple constants.

Cloneable

auto-generate Clone method.

Credfeto.Version.Information.Generator

Minimal source generator for embedding build information as compile time constants. Constants added to VersionInformation class in each assembly for Version, Product, Company and Copyright.

CsCodeGenerator

Easy C# class and code generation, POCO object and Methods creation.

DataAnnotationValuesExtractor

Extracts values from data annotation attributes, like maximum string length, and exposes them as strongly-typed constants.

DisposeGenerator

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.

Dolly

auto-generate Clone & DeepClone method.

Durian

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

Fairy

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

FastGenericNew

The ultimate fast alternative to Activator.CreateInstance<T> / new T(). 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 package that implements the dispose and async dispose patterns.

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 GetMember(int) and/or GetMember(string) 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.

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 ReadOnlySpan<T> static data from primitive values.

PrintMembersGenerator

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

PropertyThrowGenerator

source generator that adds validation to partial properties annotated with ThrowIf... attributes. The generated setters call the appropriate Argument...Exception.ThrowIf... helper methods before assigning the value. Also supports MVVM ObservableProperties.

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.

Tenekon.MethodOverloads.SourceGenerator

A C# source generator that creates combinatorial extension method overloads by treating a selected parameter window as optional and emitting legal, unique subsequences.

ThisAssembly

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

ToString

C# source generator for implementing ToString override like record type.

TupleOverloadGenerator

Overload params 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 System.Text.Json source generator architecture for best-practices.

SourceGenerator.Helper.CopyCode

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

Tweeted

by @raboof on May 25 2021 at 23:00:

Tweeted

by @raboof on Nov 16 2020 at 20:57:

Tweeted

by @Chiser99 on Sep 02 2020 at 06:41:

I made a thing:

dotnet/roslyn-sdk samples

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

Series: Creating a source generator

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

Mastering at Source Generators

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

Using C# Source Generators to create an external DSL

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

4 ways to generate code in C# — Including Source Generators in .NET 5

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

.NET 5 Source Generators - MediatR - CQRS - OMG!

(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.

Source Generators in .NET 5 with ReSharper

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

Source Generators - real world example

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

How to profile C# 9.0 Source Generators

(2020-10-10) demonstrates how to profile your source generator using the performance profiling tools built into Visual Studio.

How to Debug C# 9 Source Code Generators

(2020-10-09) contains debugging tips.

How to generate code using Roslyn source generators in real world scenarios

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

.NET Blog 'New C# Source Generator Samples' post

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

.NET Blog 'Introducing C# Source Generators' post

(2020-04-29) that announces the feature.

C# Source Generators - Write code that writes code - David Wengier

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

.NET Languages and Runtime Community Standup - Source Generators

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

Channel 9 'Source Generators in C#'

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

Compile Time Method Execution Generator

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

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.

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.

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…

Heroicons.AspNetCore

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

HydraScript

TypeScript & Go inspired small interpreted programming language written in C# that uses Source Generator to build large regular expression for lexical analysis. The regex value is passed to [GeneratedRegex] attribute, so this internal generator generates the input for another generator.

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.