UnitGenerator

C# Source Generator to create Value object pattern, also inspired by units of measure to support all arithmetic operators and serialization.

NuGet: UnitGenerator

Install-Package UnitGenerator

Introduction

For example, Identifier, UserId is comparable only to UserId, and cannot be assigned to any other type. Also, arithmetic operations are not allowed.

using UnitGenerator;

[UnitOf(typeof(int))]
public readonly partial struct UserId { }

or when using C#11 and NET7 you can use

using UnitGenerator;

[UnitOf<int>]
public readonly partial struct UserId { }

will generates

[System.ComponentModel.TypeConverter(typeof(UserIdTypeConverter))]
public readonly partial struct UserId : IEquatable<UserId> 
{
    readonly int value;
    
    public UserId(int value)
    {
        this.value = value;
    }

    public readonly int AsPrimitive() => value;
    public static explicit operator int(UserId value) => value.value;
    public static explicit operator UserId(int value) => new UserId(value);
    public bool Equals(UserId other) => value.Equals(other.value);
    public override bool Equals(object? obj) => // snip...
    public override int GetHashCode() => value.GetHashCode();
    public override string ToString() => value.ToString();
    public static bool operator ==(in UserId x, in UserId y) => x.value.Equals(y.value);
    public static bool operator !=(in UserId x, in UserId y) => !x.value.Equals(y.value);

    private class UserIdTypeConverter : System.ComponentModel.TypeConverter
    {
        // snip...
    }
}

However, Hp in games, should not be allowed to be assigned to other types, but should support arithmetic operations with int. For example double heal = target.Hp = Hp.Min(target.Hp * 2, target.MaxHp).

[UnitOf(typeof(int), UnitGenerateOptions.ArithmeticOperator | UnitGenerateOptions.ValueArithmeticOperator | UnitGenerateOptions.Comparable | UnitGenerateOptions.MinMaxMethod)]
public readonly partial struct Hp { }

// -- generates

[System.ComponentModel.TypeConverter(typeof(HpTypeConverter))]
public readonly partial struct Hp
    : IEquatable<Hp>
#if NET7_0_OR_GREATER
    , IEqualityOperators<Hp, Hp, bool>
#endif    
    , IComparable<Hp>
#if NET7_0_OR_GREATER
    , IComparisonOperators<Hp, Hp, bool>
#endif
#if NET7_0_OR_GREATER
    , IAdditionOperators<Hp, Hp, Hp>
    , ISubtractionOperators<Hp, Hp, Hp>
    , IMultiplyOperators<Hp, Hp, Hp>
    , IDivisionOperators<Hp, Hp, Hp>
    , IUnaryPlusOperators<Hp, Hp>
    , IUnaryNegationOperators<Hp, Hp>
    , IIncrementOperators<Hp>
    , IDecrementOperators<Hp>
#endif    
{
    readonly int value;

    public Hp(int value)
    {
        this.value = value;
    }

    public int AsPrimitive() => value;
    public static explicit operator int(Hp value) => value.value;
    public static explicit operator Hp(int value) => new Hp(value);
    public bool Equals(Hp other) => value.Equals(other.value);
    public override bool Equals(object? obj) => // snip...
    public override int GetHashCode() => value.GetHashCode();
    public override string ToString() => value.ToString();
    public static bool operator ==(in Hp x, in Hp y) => x.value.Equals(y.value);
    public static bool operator !=(in Hp x, in Hp y) => !x.value.Equals(y.value);
    private class HpTypeConverter : System.ComponentModel.TypeConverter { /* snip... */ }

    // UnitGenerateOptions.ArithmeticOperator
    public static Hp operator +(Hp x, Hp y) => new Hp(checked((int)(x.value + y.value)));
    public static Hp operator -(Hp x, Hp y) => new Hp(checked((int)(x.value - y.value)));
    public static Hp operator *(Hp x, Hp y) => new Hp(checked((int)(x.value * y.value)));
    public static Hp operator /(Hp x, Hp y) => new Hp(checked((int)(x.value / y.value)));
    public static Hp operator ++(Hp x) => new Hp(checked((int)(x.value + 1)));
    public static Hp operator --(Hp x) => new Hp(checked((int)(x.value - 1)));
    public static Hp operator +(A value) => new((int)(+value.value));
    public static Hp operator -(A value) => new((int)(-value.value));

    // UnitGenerateOptions.ValueArithmeticOperator
    public static Hp operator +(Hp x, in int y) => new Hp(checked((int)(x.value + y)));
    public static Hp operator -(Hp x, in int y) => new Hp(checked((int)(x.value - y)));
    public static Hp operator *(Hp x, in int y) => new Hp(checked((int)(x.value * y)));
    public static Hp operator /(Hp x, in int y) => new Hp(checked((int)(x.value / y)));

    // UnitGenerateOptions.Comparable
    public int CompareTo(Hp other) => value.CompareTo(other.value);
    public static bool operator >(Hp x, Hp y) => x.value > y.value;
    public static bool operator <(Hp x, Hp y) => x.value < y.value;
    public static bool operator >=(Hp x, Hp y) => x.value >= y.value;
    public static bool operator <=(Hp x, Hp y) => x.value <= y.value;

    // UnitGenerateOptions.MinMaxMethod
    public static Hp Min(Hp x, Hp y) => new Hp(Math.Min(x.value, y.value));
    public static Hp Max(Hp x, Hp y) => new Hp(Math.Max(x.value, y.value));
}

You can configure with UnitGenerateOptions, which method to implement.

[Flags]
enum UnitGenerateOptions
{
    None = 0,
    ImplicitOperator = 1,
    ParseMethod = 1 << 1,
    MinMaxMethod = 1 << 2,
    ArithmeticOperator = 1 << 3,
    ValueArithmeticOperator = 1 << 4,
    Comparable = 1 << 5,
    Validate = 1 << 6,
    JsonConverter = 1 << 7,
    MessagePackFormatter = 1 << 8,
    DapperTypeHandler = 1 << 9,
    EntityFrameworkValueConverter = 1 << 10,
    WithoutComparisonOperator = 1 << 11,
    JsonConverterDictionaryKeySupport = 1 << 12,
    Normalize = 1 << 13,
}

UnitGenerateOptions has some serializer support. For example, a result like Serialize(userId) => { Value = 1111 } is awful. The value-object should be serialized natively, i.e. Serialize(useId) => 1111, and should be able to be added directly to a database, etc.

Currently UnitGenerator supports MessagePack for C#, System.Text.Json(JsonSerializer), Dapper and EntityFrameworkCore.

[UnitOf(typeof(int), UnitGenerateOptions.MessagePackFormatter)]
public readonly partial struct UserId { }

// -- generates

[MessagePackFormatter(typeof(UserIdMessagePackFormatter))]
public readonly partial struct UserId 
{
    class UserIdMessagePackFormatter : IMessagePackFormatter<UserId>
    {
        public void Serialize(ref MessagePackWriter writer, UserId value, MessagePackSerializerOptions options)
        {
            options.Resolver.GetFormatterWithVerify<int>().Serialize(ref writer, value.value, options);
        }

        public UserId Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
        {
            return new UserId(options.Resolver.GetFormatterWithVerify<int>().Deserialize(ref reader, options));
        }
    }
}

UnitOfAttribute

When referring to the UnitGenerator, it generates a internal UnitOfAttribute.

namespace UnitGenerator
{
    [AttributeUsage(AttributeTargets.Struct, AllowMultiple = false)]
    internal class UnitOfAttribute : Attribute
    {
        public Type Type { get; }
        public UnitGenerateOptions Options { get; }
        public UnitArithmeticOperators ArithmeticOperators { get; set; }
        public string? ToStringFormat { get; set; }
        
        public UnitOfAttribute(Type type, UnitGenerateOptions options = UnitGenerateOptions.None) { ... }
    }

#if NET7_0_OR_GREATER
    [AttributeUsage(AttributeTargets.Struct, AllowMultiple = false)]
    internal class UnitOfAttribute<T> : Attribute
    {
        public Type Type { get; }
        public UnitGenerateOptions Options { get; }
        public UnitArithmeticOperators ArithmeticOperators { get; set; } = UnitArithmeticOperators.All;
        public string? ToStringFormat { get; set; }

        public UnitOfAttribute(UnitGenerateOptions options = UnitGenerateOptions.None)
        {
            this.Type = typeof(T);
            this.Options = options;
        }
    }
#endif
}

You can attach this attribute with any specified underlying type to readonly partial struct.

[UnitOf(typeof(Guid))]
public readonly partial struct GroupId { }

[UnitOf(typeof(string))]
public readonly partial struct Message { }

[UnitOf(typeof(long))]
public readonly partial struct Power { }

[UnitOf(typeof(byte[]))]
public readonly partial struct Image { }

[UnitOf(typeof(DateTime))]
public readonly partial struct StartDate { }

[UnitOf(typeof((string street, string city)))]
public readonly partial struct StreetAddress { }

Standard UnitOf(UnitGenerateOptions.None) generates value constructor, explicit operator, implement IEquatable<T>, override GetHashCode, override ToString, == and != operator, TypeConverter for ASP.NET Core binding, AsPrimitive method.

If you want to retrieve primitive value, use AsPrimitive() instead of .Value. This is intended to avoid casual getting of primitive values (using the arithmetic operator option if available).

When type is bool, also implements true, false, ! operators.

public static bool operator true(Foo x) => x.value;
public static bool operator false(Foo x) => !x.value;
public static bool operator !(Foo x) => !x.value;

When type is Guid or Ulid, also implements New() and New***() static operator.

public static GroupId New();
public static GroupId NewGroupId();

Second parameter UnitGenerateOptions options can configure which method to implement, default is None.

Optional named parameter: ArithmeticOperators can configure which generates operators specifically. Default is Number. (This can be used if UnitGenerateOptions.ArithmeticOperator is specified.)

Optional named parameter: ToStringFormat can configure ToString format. Default is null and output as ${0}.

UnitGenerateOptions

When referring to the UnitGenerator, it generates a internal UnitGenerateOptions that is bit flag of which method to implement.

[Flags]
internal enum UnitGenerateOptions
{
    None = 0,
    ImplicitOperator = 1,
    ParseMethod = 2,
    MinMaxMethod = 4,
    ArithmeticOperator = 8,
    ValueArithmeticOperator = 16,
    Comparable = 32,
    Validate = 64,
    JsonConverter = 128,
    MessagePackFormatter = 256,
    DapperTypeHandler = 512,
    EntityFrameworkValueConverter = 1024,
}

You can use this with [UnitOf].

[UnitOf(typeof(int), UnitGenerateOptions.ArithmeticOperator | UnitGenerateOptions.ValueArithmeticOperator | UnitGenerateOptions.Comparable | UnitGenerateOptions.MinMaxMethod)]
public readonly partial struct Strength { }

[UnitOf(typeof(DateTime), UnitGenerateOptions.Validate | UnitGenerateOptions.ParseMethod | UnitGenerateOptions.Comparable)]
public readonly partial struct EndDate { }

[UnitOf(typeof(double), UnitGenerateOptions.ParseMethod | UnitGenerateOptions.MinMaxMethod | UnitGenerateOptions.ArithmeticOperator | UnitGenerateOptions.ValueArithmeticOperator | UnitGenerateOptions.Comparable | UnitGenerateOptions.Validate | UnitGenerateOptions.JsonConverter | UnitGenerateOptions.MessagePackFormatter | UnitGenerateOptions.DapperTypeHandler | UnitGenerateOptions.EntityFrameworkValueConverter)]
public readonly partial struct AllOptionsStruct { }

You can setup project default options like this.

internal static class UnitOfOptions
{
    public const UnitGenerateOptions Default = UnitGenerateOptions.ArithmeticOperator | UnitGenerateOptions.ValueArithmeticOperator | UnitGenerateOptions.Comparable | UnitGenerateOptions.MinMaxMethod;
}

[UnitOf(typeof(int), UnitOfOptions.Default)]
public readonly partial struct Hp { }

ImplicitOperator

// Default
public static explicit operator U(T value) => value.value;
public static explicit operator T(U value) => new T(value);

// UnitGenerateOptions.ImplicitOperator
public static implicit operator U(T value) => value.value;
public static implicit operator T(U value) => new T(value);

ParseMethod

public static T Parse(string s)
public static bool TryParse(string s, out T result)

MinMaxMethod

public static T Min(T x, T y)
public static T Max(T x, T y)

ArithmeticOperator

public static T operator +(in T x, in T y) => new T(checked((U)(x.value + y.value)));
public static T operator -(in T x, in T y) => new T(checked((U)(x.value - y.value)));
public static T operator *(in T x, in T y) => new T(checked((U)(x.value * y.value)));
public static T operator /(in T x, in T y) => new T(checked((U)(x.value / y.value)));
public static T operator +(T value) => new((U)(+value.value));
public static T operator -(T value) => new((U)(-value.value));
public static T operator ++(T x) => new T(checked((U)(x.value + 1)));
public static T operator --(T x) => new T(checked((U)(x.value - 1)));

In addition, all members conforming to System.Numerics.INumber are generated.

If you want to suppress this and generate only certain operators, you can use the the ArithmeticOperatros option of [UnitOf] attribute as follows:

[UnitOf(
    typeof(int), 
    UnitGenerateOptions.ArithmeticOperator,
    ArithmeticOperators = UnitArithmeticOperators.Addition | UnitArithmeticOperators.Subtraction)]
public readonly partial struct Hp { }

Value	Generates
UnitArithmeticOperators.Addition	`T operator +(T, T)`
UnitArithmeticOperators.Subtraction	`T operator -(T, T)`
UnitArithmeticOperators.Multiply	`T operator *(T, T)`, `T operator +(T)`, `T operator-(T)`
UnitArithmeticOperators.Division	`T operator /(T, T)`, `T operator +(T)`, `T operator-(T)`
UnitArithmeticOperators.Increment	`T operator ++(T)`
UnitArithmeticOperators.Decrement	`T operator --(T)`

ValueArithmeticOperator

public static T operator +(in T x, in U y) => new T(checked((U)(x.value + y)));
public static T operator -(in T x, in U y) => new T(checked((U)(x.value - y)));
public static T operator *(in T x, in U y) => new T(checked((U)(x.value * y)));
public static T operator /(in T x, in U y) => new T(checked((U)(x.value / y)));

Comparable

Implements IComparable<T> and >, <, >=, <= operators.

public U CompareTo(T other) => value.CompareTo(other.value);
public static bool operator >(in T x, in T y) => x.value > y.value;
public static bool operator <(in T x, in T y) => x.value < y.value;
public static bool operator >=(in T x, in T y) => x.value >= y.value;
public static bool operator <=(in T x, in T y) => x.value <= y.value;

WithoutComparisonOperator

Without implements >, <, >=, <= operators. For example, useful for Guid.

[UnitOf(typeof(Guid), UnitGenerateOptions.Comparable | UnitGenerateOptions.WithoutComparisonOperator)]
public readonly partial struct FooId { }

Validate

Implements partial void Validate() method that is called on constructor.

// You can implement this custom validate method.
[UnitOf(typeof(int), UnitGenerateOptions.Validate)]
public readonly partial struct SampleValidate
{
    // impl here.
    private partial void Validate()
    {
        if (value > 9999) throw new Exception("Invalid value range: " + value);
    }
}

// Source generator generate this codes.
public T(int value)
{
    this.value = value;
    this.Validate();
}
 
private partial void Validate();

Normalize

Implements partial void Normalize(ref T value) method that is called on constructor.

// You can implement this custom normalize method to change value during initialization
[UnitOf(typeof(int), UnitGenerateOptions.Normalize)]
public readonly partial struct SampleValidate
{
    // impl here.
    private partial void Normalize(ref int value)
    {
        value = Math.Max(value, 9999);
    }
}

// Source generator generate this codes.
public T(int value)
{
    this.value = value;
    this.Normalize(ref this.value);
}
 
private partial void Normalize(ref int value);

JsonConverter

Implements System.Text.Json's JsonConverter. It will be used JsonSerializer automatically.

[JsonConverter(typeof(UserIdJsonConverter))]
public readonly partial struct UserId
{
    class UserIdJsonConverter : JsonConverter<UserId>
}

JsonConverterDictionaryKeySupport

Implements JsonConverter's WriteAsPropertyName/ReadAsPropertyName. It supports from .NET 6, supports Dictionary's Key.

var dict = Dictionary<UserId, int>
JsonSerializer.Serialize(dict);

MessagePackFormatter

Implements MessagePack for C#'s MessagePackFormatter. It will be used MessagePackSerializer automatically.

[MessagePackFormatter(typeof(UserIdMessagePackFormatter))]
public readonly partial struct UserId
{
    class UserIdMessagePackFormatter : IMessagePackFormatter<UserId>
}

DapperTypeHandler

Implements Dapper's TypeHandler by public accessibility. TypeHandler is automatically registered at the time of Module initialization.

public readonly partial struct UserId
{
    public class UserIdTypeHandler : Dapper.SqlMapper.TypeHandler<UserId>
}

[ModuleInitializer]
public static void AddTypeHandler()
{
    Dapper.SqlMapper.AddTypeHandler(new A.ATypeHandler());
}

EntityFrameworkValueConverter

Implements EntityFrameworkCore's ValueConverter by public accessibility. It is not registered automatically so you need to register manually.

public readonly partial struct UserId
{
    public class UserIdValueConverter : ValueConverter<UserId, int>
}

// setup handler manually
builder.HasConversion(new UserId.UserIdValueConverter());

Use for Unity

C# Source Generator feature is rely on C# 9.0. If you are using Unity 2021.2, that supports Source Generators. Add the UnitGenerator.dll from the releases page, disable Any Platform, disable Include all platforms and set label as RoslynAnalyzer.

It works in Unity Editor however does not work on IDE because Unity does not generate analyzer reference to .csproj. We provides CsprojModifer to analyzer support, uses Add analyzer references to generated .csproj supports both IDE and Unity Editor.

Unity(2020) does not support C# 9.0 so can not use directly. However, C# Source Genertor supports output source as file.

Create UnitSourceGen.csproj.

<Project Sdk="Microsoft.NET.Sdk">
    <PropertyGroup>
        <TargetFramework>net5.0</TargetFramework>

        <!-- add this two lines and configure output path -->
        <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
        <CompilerGeneratedFilesOutputPath>$(ProjectDir)..\Generated</CompilerGeneratedFilesOutputPath>
    </PropertyGroup>

    <ItemGroup>
        <!-- reference UnitGenerator -->
        <PackageReference Include="UnitGenerator" Version="1.0.0" />

        <!-- add target sources path from Unity -->
        <Compile Include="..\MyUnity\Assets\Scripts\Models\**\*.cs" />
    </ItemGroup>
</Project>

install .NET SDK and run this command.

dotnet build UnitSourceGen.csproj

File will be generated under UnitGenerator\UnitGenerator.SourceGenerator\*.Generated.cs. UnitOfAttribute is also included in generated folder, so at first, run build command and get attribute to configure.

License

This library is under the MIT License.

Name		Name	Last commit message	Last commit date
Latest commit History 127 Commits
.github/workflows		.github/workflows
sandbox		sandbox
src		src
tests/UnitGenerator.Tests		tests/UnitGenerator.Tests
.gitignore		.gitignore
LICENSE		LICENSE
README.md		README.md
UnitGenerator.sln		UnitGenerator.sln

License

Cysharp/UnitGenerator

Folders and files

Latest commit

History

Repository files navigation

UnitGenerator

Introduction

Table of Contents

UnitOfAttribute

UnitGenerateOptions

ImplicitOperator

ParseMethod

MinMaxMethod

ArithmeticOperator

ValueArithmeticOperator

Comparable

WithoutComparisonOperator

Validate

Normalize

JsonConverter

JsonConverterDictionaryKeySupport

MessagePackFormatter

DapperTypeHandler

EntityFrameworkValueConverter

Use for Unity

License

About

Resources

License

Stars

Watchers

Forks

Languages