https://github.com/distantcam/AutoCtor
A Roslyn source generator for creating constructors.
https://github.com/distantcam/AutoCtor
csharp csharp-sourcegenerator dotnet roslyn source-generator
Last synced: about 2 months ago
JSON representation
A Roslyn source generator for creating constructors.
- Host: GitHub
- URL: https://github.com/distantcam/AutoCtor
- Owner: distantcam
- License: mit
- Created: 2022-07-09T03:56:12.000Z (almost 3 years ago)
- Default Branch: main
- Last Pushed: 2024-04-13T11:40:12.000Z (about 1 year ago)
- Last Synced: 2024-04-13T15:00:55.660Z (about 1 year ago)
- Topics: csharp, csharp-sourcegenerator, dotnet, roslyn, source-generator
- Language: C#
- Homepage:
- Size: 431 KB
- Stars: 75
- Watchers: 3
- Forks: 5
- Open Issues: 1
-
Metadata Files:
- Readme: readme.md
- Funding: .github/FUNDING.yml
- License: license
Awesome Lists containing this project
- RSCG_Examples - https://github.com/distantcam/AutoCtor
- csharp-source-generators - AutoCtor -   AutoCtor is a Roslyn Source Generator that will automatically create a constructor for your class for use with constructor Dependency Injection. (Source Generators / Dependency Injection (IoC Container))
README
# AutoCtor
[](https://github.com/distantcam/AutoCtor/actions/workflows/build.yml)
[](https://www.nuget.org/packages/AutoCtor/)
[](https://www.nuget.org/packages/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](#nuget-packages)
* [Usage](#usage)
* [Your code](#your-code)
* [What gets generated](#what-gets-generated)
* [More Features](#more-features)
* [Post constructor Initialisation](#post-constructor-initialisation)
* [Initialise with parameters](#initialise-with-parameters)
* [Initialise readonly fields with ref or out](#initialise-readonly-fields-with-ref-or-out)
* [Argument Guards](#argument-guards)
* [Property Initialisation](#property-initialisation)
* [More examples](#more-examples)
* [Embedding the attributes in your project](#embedding-the-attributes-in-your-project)
* [Preserving usage of the `[AutoConstruct]` attribute](#preserving-usage-of-the-autoconstruct-attribute)
* [Stats](#stats)
## NuGet packages
https://nuget.org/packages/AutoCtor/
## Usage
### Your code
```cs
[AutoConstruct]
public partial class ExampleClass
{
private readonly IService _service;
}
```
snippet source | anchor
### What gets generated
```cs
public ExampleClass(IService service)
{
_service = service;
}
```
snippet source | anchor
Back to Contents
## 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.
```cs
[AutoConstruct]
public partial class PostConstructMethod
{
private readonly IService _service;
[AutoPostConstruct]
private void Initialize()
{
}
}
```
snippet source | anchor
```cs
public PostConstructMethod(IService service)
{
_service = service;
Initialize();
}
```
snippet source | anchor
### Initialise with parameters
Post constructor methods can also take parameters. These parameters will be passed in from the constructor.
```cs
public partial class PostConstructMethodWithParameters
{
private readonly IService _service;
[AutoPostConstruct]
private void Initialize(IInitialiseService initialiseService)
{
}
}
```
snippet source | anchor
```cs
public PostConstructMethodWithParameters(IService service, IInitialiseService initialiseService)
{
_service = service;
Initialize(initialiseService);
}
```
snippet source | anchor
### Initialise readonly fields with ref or out
If a parameter is marked `ref` or `out` and matches the type of a readonly field, it can set that field during construction.
```cs
public partial class PostConstructWithOutParameters
{
private readonly IService _service;
private readonly IOtherService _otherService;
[AutoPostConstruct]
private void Initialize(IServiceFactory serviceFactory, out IService service)
{
service = serviceFactory.CreateService();
}
}
```
snippet source | anchor
```cs
public PostConstructWithOutParameters(IOtherService otherService, IServiceFactory serviceFactory)
{
_otherService = otherService;
Initialize(serviceFactory, out _service);
}
```
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.
```xml
true
```
In each `AutoConstruct` attribute you can add a setting to enable/disable guards.
```cs
[AutoConstruct(GuardSetting.Enabled)]
public partial class GuardedClass
{
private readonly Service _service;
}
```
snippet source | anchor
```cs
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.
```cs
// 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
Back to Contents
## More examples
You can also initialise readonly fields, and AutoCtor will not include them in the constructor.
```cs
[AutoConstruct]
public partial class ClassWithPresetField
{
private readonly IService _service;
private readonly IList _list = new List();
}
```
snippet source | anchor
```cs
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.
```cs
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
```cs
public ClassWithBase(IAnotherService anotherService, IService service) : base(anotherService)
{
_service = service;
}
```
snippet source | anchor
Back to Contents
## 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 `` element. This ensures the attributes in your project are referenced, instead of the _AutoCtor.Attributes.dll_ library.
Your project file should look like this:
```xml
AUTOCTOR_EMBED_ATTRIBUTES
```
Back to Contents
## 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.
```xml
AUTOCTOR_USAGES
```
Back to Contents
## Stats
