distantcam/autoctor

A Roslyn source generator for creating constructors.

AutoCtor

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

Contents

• NuGet packages
• Usage
  • Your code
  • What gets generated
• More Features
  • Post constructor Initialisation
  • Argument Guards
  • Property Initialisation
• More examples
• Embedding the attributes in your project
• Preserving usage of the [AutoConstruct] attribute
• Stats

NuGet packages

https://nuget.org/packages/AutoCtor/

Usage

Your code

[AutoConstruct]
public partial class ExampleClass
{
    private readonly IService _service;
}

^{snippet source | anchor}

What gets generated

public ExampleClass(IService service)
{
    _service = service;
}

^{snippet source | anchor}

More Features

Post constructor Initialisation

You can mark a method to be called at the end of the constructor with the attribute [AutoPostConstruct]. This method must return void.

[AutoConstruct]
public partial class PostConstructMethod
{
    private readonly IService _service;

    [AutoPostConstruct]
    private void Initialize()
    {
    }
}

^{snippet source | anchor}

public PostConstructMethod(IService service)
{
    _service = service;
    Initialize();
}

^{snippet source | anchor}

Post constructor methods can also take parameters. These parameters will be passed in from the constructor.

public partial class PostConstructMethodWithParameters
{
    private readonly IService _service;

    [AutoPostConstruct]
    private void Initialize(IInitialiseService initialiseService)
    {
    }
}

^{snippet source | anchor}

public PostConstructMethodWithParameters(IService service, IInitialiseService initialiseService)
{
    _service = service;
    Initialize(initialiseService);
}

^{snippet source | anchor}

Argument Guards

Null guards for the arguments to the constructor can be added in 2 ways.

In your project you can add a AutoCtorGuards property.

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <AutoCtorGuards>true</AutoCtorGuards>
  </PropertyGroup>

</Project>

In each AutoConstruct attribute you can add a setting to enable/disable guards.

[AutoConstruct(GuardSetting.Enabled)]
public partial class GuardedClass
{
    private readonly Service _service;
}

^{snippet source | anchor}

public GuardedClass(Service service)
{
    _service = service ?? throw new ArgumentNullException(nameof(service));
}

^{snippet source | anchor}

Property Initialisation

AutoCtor can set properties that are considered as read only properties.

// AutoCtor will initialise these
public string GetProperty { get; }
protected string ProtectedProperty { get; }
public string InitProperty { get; init; }
public required string RequiredProperty { get; set; }

// AutoCtor will ignore these
public string InitializerProperty { get; } = "Constant";
public string GetSetProperty { get; set; }
public string FixedProperty => "Constant";
public string RedirectedProperty => InitializerProperty;

^{snippet source | anchor}

More examples

You can also initialize readonly fields, and AutoCtor will not include them in the constructor.

[AutoConstruct]
public partial class ClassWithPresetField
{
    private readonly IService _service;
    private readonly IList<string> _list = new List<string>();
}

^{snippet source | anchor}

public ClassWithPresetField(IService service)
{
    _service = service;
    // no code to set _list
}

^{snippet source | anchor}

If there is a single base constructor with parameters, AutoCtor will include that base constructor in the constructor it creates.

public abstract class BaseClass
{
    protected IAnotherService _anotherService;

    public BaseClass(IAnotherService anotherService)
    {
        _anotherService = anotherService;
    }
}

[AutoConstruct]
public partial class ClassWithBase : BaseClass
{
    private readonly IService _service;
}

^{snippet source | anchor}

public ClassWithBase(IAnotherService anotherService, IService service) : base(anotherService)
{
    _service = service;
}

^{snippet source | anchor}

Embedding the attributes in your project

By default, the [AutoConstruct] attributes referenced in your project are contained in an external dll. It is also possible to embed the attributes directly in your project. To do this, you must do two things:

1. Define the MSBuild constant AUTOCTOR_EMBED_ATTRIBUTES. This ensures the attributes are embedded in your project.
2. Add compile to the list of excluded assets in your <PackageReference> element. This ensures the attributes in your project are referenced, insted of the AutoCtor.Attributes.dll library.

Your project file should look like this:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <!--  Define the MSBuild constant    -->
    <DefineConstants>AUTOCTOR_EMBED_ATTRIBUTES</DefineConstants>
  </PropertyGroup>

  <!-- Add the package -->
  <PackageReference Include="AutoCtor"
                    PrivateAssets="all"
                    ExcludeAssets="compile;runtime" />
<!--                               ☝ Add compile to the list of excluded assets. -->

</Project>

Preserving usage of the [AutoConstruct] attribute

The [AutoConstruct] attributes are decorated with the [Conditional] attribute, so their usage will not appear in the build output of your project. If you use reflection at runtime you will not find the [AutoConstruct] attributes.

If you wish to preserve these attributes in the build output, you can define the AUTOCTOR_USAGES MSBuild variable.

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <!--  Define the MSBuild constant    -->
    <DefineConstants>AUTOCTOR_USAGES</DefineConstants>
  </PropertyGroup>

  <!-- Add the package -->
  <PackageReference Include="AutoCtor" PrivateAssets="all" />

</Project>

Stats

autoctor's Issues

Add version to auto generated header

Generic interface from another project not fully qualified

My setup is like this:

// Project A
namespace A;
public interface Interface<T, U>{}

// Project B
namespace B;
public abstract class BaseClass<T, U, V>
{
    private readonly Interface<T, U> _interface;
    public Class(Interface<T, U> i) => _interface = i;
}

[AutoConstruct]
public sealed class Class : BaseClass<object, int, string>
{
}

Which generates the interface parameter unqualified (Interface<qualifiedName, qualifiedName> instead of global::A.Interface<...>)

Feature Idea - Guard attributes

It might be nice to add attributes to mark fields as needing guards in the generated constructor. Something like this.

[GuardNull]
private readonly Service _service;

Generates

public MyClass(Service service)
{
    _service = serivce ?? throw new ArgumentNullException(nameof(service));
}

Are there other guards worth adding?

Init properties

Properties defined with an init can only be set at construction time.

https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/proposals/csharp-9.0/init

Should they also be handled by AutoCtor? If the goal of AutoCtor is to help with classes that are created by IoC it would make sense to also set these properties in the constructor too.

Also consider auto properties with just a getter defined.

Ignore static fields

Support for record types

Hi @distantcam,

This is more of an enhancement suggestion but that option seems to have disappeared?

My current project is making heavy use of the new-ish "record" type and the [AutoConstruct] code isn't currently compatible with the inline property constructors.

A quick example:

internal abstract record RequestBase(string Id)
{
    protected RequestBase(string id)
    {
        Id = id;
    }
}

[AutoConstruct]
internal partial record OrderRequest : RequestBase
{ }

Yields a generated constructor that is missing the required base parameter:

partial record OrderRequest
{
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("AutoCtor", "0.0.0.0")]
    public OrderRequest()
    {
    }
}

Duplicate services in constructor with base classes

Hello, I'm currently trying to implement your awesome project in my new project and I'm stumbling over the following issue concerning services with covariant type arguments.

[AutoConstruct]
public abstract partial class BaseClass {
    private readonly ILogger<BaseClass> logger;
}

[AutoConstruct]
public partial class DerivedClass : BaseClass {
    private readonly ILogger<DerivedClass> logger;
}

// Generated code:

partial class BaseClass {
    public BaseClass(ILogger<BaseClass> logger) {
        this.logger = logger;
    }
}

partial class DerivedClass {
    public DerivedClass(ILogger<BaseClass> logger, ILogger<DerivedClass> logger) : base(logger) {
        this.logger = logger;
    }
}

Two problems here:

1. This raises a compiler error due to the colliding name.
2. The logger type ILogger<DerivedClass> can and should be assigned to the base class logger ILogger<BaseClass> due to it being covariant ILogger<out TCategoryName>.

The problem here lies not in the covariance though, as the non-generic base ILogger also does not get assigned:

[AutoConstruct]
public abstract partial class BaseClass {
    private readonly ILogger logger;
}
// Same derived class

// Generated code:

partial class DerivedClass {
    public DerivedClass(ILogger logger, ILogger<DerivedClass> logger) : base(logger) {
        this.logger = logger;
    }
}

---

My most promising attempt at solving this backfired a bit, but should be a rather non-intrusive fix in comparison to the above solution. I used a generic type variable to assign the exact same logger type in the base class as used in the derived class.

[AutoConstruct]
public abstract partial class BaseClass<TLogger> {
    private readonly ILogger<TLogger> logger;
}

[AutoConstruct]
public partial class DerivedClass : BaseClass<DerivedClass> {
    private readonly ILogger<DerivedClass> logger;
}

// Generated code:

partial class BaseClass<TLogger> {
    public BaseClass(ILogger<TLogger> logger) {
        this.logger = logger;
    }
}

partial class DerivedClass {
    public DerivedClass(ILogger<TLogger> logger, ILogger<DerivedClass> logger) : base(logger) {
        this.logger = logger;
    }
}

This could not resolve the type in the base class. If it did, it would still assign a duplicate derived class logger.

---

Best possible solution would probably be a check if services in the derived class are assignable to any type in the base class, but I do not know if this produces any weird side effects. Do you have any other workaround?

Remove ThisAssembly.* packages because of SponsorLink

There's privacy concerns surrounding SponsorLink, which is part of ThisAssembly.

https://github.com/moq/moq/issues/1372
https://www.reddit.com/r/dotnet/comments/15ljdcc/does_moq_in_its_latest_version_extract_and_send/

Call Base constructor automatically

Example

public class CustomBase
{
    public CustomBase(string text)
    {
    }
}

[AutoConstruct]
public partial class Custom : CustomBase
{
    private readonly DbContext _dbContext;
}

Should call base constructor.

Post constructor initialization

Here's a proposal for doing post-constructor initialisation.

[AutoConstruct(nameof(Initialize))]
public partial class MyClass
{
    private readonly IService _service;

    private void Initialize()
    {
        // Do some post constructor setup here.
    }
}

The generated code.

partial class MyClass
{
    public MyClass(IService service)
    {
        _service = service;
        Initialize();
    }
}

• Does nameof work like that in an attribute?
• Does it matter if it's only after the fields are set? The benefit of that is the fields are available in the initialize method.
• Should there be a way of setting the "Initialize" name at a global level, so it doesn't need to be repeated in each attribute?
  • This is risky. It may end up calling a method when you don't want it to.
  • Might do this after the first version.

For a first implementation the initialize method must have no parameters and return void.

Support Deadlines

Here are the support deadlines for the various versions of Roslyn and Visual Studio compatibilities.

https://learn.microsoft.com/en-us/visualstudio/productinfo/vs-servicing
https://learn.microsoft.com/en-us/visualstudio/extensibility/roslyn-version-support?view=vs-2022

3.11.0 - Visual Studio 2019 version 16.11 - April 2029
4.0.1 - Visual Studio 2022 RTM - 11 July 2023
4.4.0 - Visual Studio 2022 version 17.4 - 9 July 2024
4.6.0 - Visual Studio 2022 version 17.6 - 14 January 2025
4.8.0 - Visual Studio 2022 version 17.8 - 8 July 2025
4.10.0 - Visual Studio 2022 version 17.10 - 13 January 2026

Add external dll for attributes

https://andrewlock.net/creating-a-source-generator-part-7-solving-the-source-generator-marker-attribute-problem-part1/
https://andrewlock.net/creating-a-source-generator-part-8-solving-the-source-generator-marker-attribute-problem-part2/

Support generic base classes

Currently this scenario is not supported.

public class BaseClass<T>
{
    public BaseClass(T t) { }
}

[AutoConstruct]
public class ChildClass : BaseClass<int>
{
}