### Install RandomFixtureKit via NuGet

Source: https://github.com/cysharp/randomfixturekit/blob/master/README.md

Use this command to install the RandomFixtureKit package using the NuGet Package Manager Console.

```powershell
Install-Package RandomFixturekit
```

--------------------------------

### Implement Custom Generator for Sequential IDs

Source: https://github.com/cysharp/randomfixturekit/blob/master/README.md

Provides an example of creating a custom IGenerator to generate sequential IDs for a specific class property, demonstrating how to control value generation logic.

```csharp
// for example, increment Id on create MyClass value.
public class MyClass
{
    public int Id { get; set; }
    public int Age { get; set; }
    public string Name { get; set; }

    public override string ToString()
    {
        return (Id, Age, Name).ToString();
    }
}

// Create IGenerator.
public class MyClassSequentialIdGenerator : IGenerator
{
    int sequence = 0;
    IGenerator fallbackGenerator = new Int32Generator();

    // this generator called if requires int value.
    public Type Type => typeof(int);

    public object Generate(in GenerationContext context)
    {
        // check target int field belongs MyClass.
        if (context.FieldInfo != null)
        {
            // auto-implemented property's field: <Id>k__BackingField
            if (context.FieldInfo.DeclaringType == typeof(MyClass) && context.FieldInfo.Name.StartsWith("<Id>"))
            {
                return (sequence++);
            }
        }

        return fallbackGenerator.Generate(context);
    }
}

// setup generator to use
var resolver = new CompositeResolver(new[] { new MyClassSequentialIdGenerator() }, new[] { StandardResolver.NonNull });
var fixture = new Fixture(resolver); // fixture is instance version of FixtureFactory

var foo = fixture.CreateMany<MyClass>(100);
foreach (var item in foo)
{
    Console.WriteLine(item);
}
```

--------------------------------

### Configure Value Generation with Resolvers

Source: https://github.com/cysharp/randomfixturekit/blob/master/README.md

Shows how to use different resolvers like NotNull and EdgeCase for value generation, and how to create custom composite resolvers.

```csharp
// default is NotNull resolver, the value is completely random
var value1 = FixtureFactory.Create<int>(resolver: StandardResolver.NotNull);

// you can change the EdgeCaseResolver, 
var value2 = FixtureFactory.Create<int>(resolver: StandardResolver.EdgeCase);

// you can change the default resolver.
FixtureFactory.Default = StandardResolver.EdgeCase;

// or make the new you combine resolver.
// this configuration uses string => fill Japanese Hiragana and others as NonNullResolver
var resolver = new CompositeResolver(new[] {
        new JapaneseHiraganaGenerator(stringLength:9),
    }, new[] {
        StandardResolver.NonNull
    });

// for fill interface type, need to map before call create
FixtureFactory.RegisterMap<IFoo, Foo>();
var v = FixtureFactory.Create<IFoo>(); // return Foo object
```

--------------------------------

### Generate Single and Multiple Values

Source: https://github.com/cysharp/randomfixturekit/blob/master/README.md

Demonstrates how to create single random values or arrays of random values for specified types using FixtureFactory.Create and FixtureFactory.CreateMany.

```csharp
// get single value
var value = FixtureFactory.Create<Foo>();

// get array
var values = FixtureFactory.CreateMany<Bar>();

// get temporal value(you can use this values to use invoke target method)
var (x, y, z) = FixtureFactory.Create<(int, string, short)>();
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.