CNugent.LightFixture 0.5.1

About

LightFixture is intended a faster (if less flexible) replacement for libraries like AutoFixture. While those libraries are excellent, they can become slow as the amount of anonymous data increases.

LightFixture provides source-generated factories and enables user-provided implementations to be provided for resolving anonymous data.

Installation

LightFixture is available as CNugent.LightFixture.

You can add it to your project with dotnet add {project} package CNugent.LightFixture.

Benchmark compared to AutoFixture

This is based on the LightFixture.Benchmark project within this repo.

Usage

To get started with source generated providers, you can use something like the following

[DataFactory(typeof(SampleData)]
public partial class SampleDataProvider;

public sealed class SampleData
{
    public int Int { get; set; }
    
    public double? Double { get; set; }
}

Marking generates a data provider customization automatically generates all needed factories for the type trees specified. Multiple attributes can be specified together .

Data can be resolved from a DataProvider like so

var dataProvider = new DataProviderBuilder()
    .Customize(new SampleDataProvider())
    .Build();

var data = dataProvider.Resolve<SampleData>().Value;

To provide your own customizations, you can write something like

internal sealed class GuidProvider : IDataProviderCustomization
{
    public static readonly GuidProvider Instance = new();

    private GuidProvider()
    {
    }

    public void Apply(DataProviderBuilder builder)
    {
        builder.Register<Guid>(static (_, _) => Guid.NewGuid());
    }
}

or register more directly by calling either of the following on DataProviderBuilder

public DataProviderBuilder Register<T>(
    Func<DataProvider, CreationRequest?, ResolvedData<T>> factory,
    bool overrideExisting = false)
    
public DataProviderBuilder Register(
    Type type,
    Func<DataProvider, CreationRequest?, ResolvedData<object>> factory,
    bool overrideExisting = false)

Postprocessors for more granular customization can be added like so.

// specified type
builder.AddPostProcessor<BasicType>((dataProvider, bt) => bt.Value = 42);

// or less specically
buider.AddPostProcessor((dataProvider, obj) => 
{
    if(obj is BasicType bt) 
    {
        bt.Value = 42;
    }
});

Properties can be ignored during source generation like so.

[DataFactory(typeof(SampleData)]
[DataFactoryIgnoreProperty(typeof(SampleData), nameof(SampleData.Double))]
public partial class SampleDataProvider;

public sealed class SampleData
{
    public int Int { get; set; }
    
    public double? Double { get; set; }
}

LightFixture supports registration of open generics

public sealed record Wrapper<T>(T Value);

// Enables resolution of Wrapper<string>, Wrapper<int>, etc.
[DataFactory(typeof(Wrapper<>))]
public partial class SampleDataProvider;