Skip to content

A Roslyn source generator for creating constructors.

License

Notifications You must be signed in to change notification settings

distantcam/AutoCtor

Repository files navigation

AutoCtor

Build Status NuGet Status Nuget Downloads

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

Contents

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

Alt