Vogen and Guids

[drusellers]

If I'm using a Guid to back my ValueObjects like

[ValueObject<Guid>]
public partial struct EmployeeId;

Is there an easy way to add a New() type function? Something that would replicate

EmployeeId.From(Guid.NewGuid());

But ideally, I only have to configure it once using the Assembly Attributes

[assembly: VogenDefaults(
    typeof(Guid),
    Conversions.EfCoreValueConverter | Conversions.TypeConverter | Conversions.SystemTextJson,
    typeof(ValueObjectValidationException))]

Conceptually, can Vogen do this as a standard with Guids

[ValueObject<Guid>]
public partial struct EmployeeId
{
    public static EmployeeId New() => EmployeeId.From(Guid.NewGuid());
}

[SteveDunn]

Hi @drusellers, thanks for the question. I think New() method is a good way to do it, although what does New mean in your domain in the context of an EmployeeId. Perhaps there's a more descriptive name for it? Or perhaps if it's just used in infrastructure (i.e. just a database key), then what you have is fine.

Vogen 'hoists' up certain methods from the primitive type, e.g. Parse, but it doesn't do it for Guid.
It could do it for Guid, but this would relate to the naming question above, which I guess would be different based on the domain it is being used.

[drusellers]

Ultimately, what I'm looking for is a way to define a common "factory" method that I would use to generate new instances of Vogen ValueTypes that match some pattern. In my case, my initial use of Vogen was to give me better Database PK's and I'm loving it for that so far.

It's not the biggest issues that I have to do MyType.From(Guid.NewGuid()) but since I have a lot of id's floating around, I thought I would at least ask about some method.

[SteveDunn]

I think Guids are suitably different from the other types to warrant a new static method. I've added this and will hopefully get around to it soon
#571

Thanks for your feedback!

[SteveDunn]

This has now been implemented. Thanks for your feedback!

[SteveDunn]

Static abstracts in interfaces allows us to define a factory for value objects of a specific type (or any type). This can be turned on in global config with the staticAbsstractsGeneration parameter:

[assembly: VogenDefaults(staticAbstractsGeneration: StaticAbstractsGeneration.MostCommon)]

MostCommon combines the settings to generate the equals methods, and the explicit casts, and the factory methods (From and TryFrom)

Once on, it will generate an IVogen<TSelf, TPrimitive> interface:

public interface IVogen<TSelf, TPrimitive> where TSelf : IVogen<TSelf, TPrimitive>
{
    static abstract explicit operator TSelf(TPrimitive value);
    static abstract explicit operator TPrimitive(TSelf value);

    static abstract bool operator ==(TSelf left, TSelf right);
    static abstract bool operator !=(TSelf left, TSelf right);

    static abstract bool operator ==(TSelf left, TPrimitive right);
    static abstract bool operator !=(TSelf left, TPrimitive right);

    static abstract bool operator ==(TPrimitive left, TSelf right);
    static abstract bool operator !=(TPrimitive left, TSelf right);

    static abstract TSelf From(TPrimitive value);
    static abstract bool TryFrom(TPrimitive value, out TSelf vo);
}

We can then implement that interface and use the static methods (such as From) to create instances. This example uses sequential guids (I copied the body of the method from the EFCore source):

    public static class GuidFactory<TSelf> where TSelf : IVogen<TSelf, Guid>
    {
        // ReSharper disable once StaticMemberInGenericType
        private static long _counter = DateTime.UtcNow.Ticks;

        static TSelf NewSequential()
        {
            var guidBytes = Guid.NewGuid().ToByteArray();
            var counterBytes = BitConverter.GetBytes(Interlocked.Increment(ref _counter));

            if (!BitConverter.IsLittleEndian)
            {
                Array.Reverse(counterBytes);
            }

            guidBytes[08] = counterBytes[1];
            guidBytes[09] = counterBytes[0];
            guidBytes[10] = counterBytes[7];
            guidBytes[11] = counterBytes[6];
            guidBytes[12] = counterBytes[5];
            guidBytes[13] = counterBytes[4];
            guidBytes[14] = counterBytes[3];
            guidBytes[15] = counterBytes[2];

            return TSelf.From(new Guid(guidBytes));
        }
    }

This can be used as follows:

var id1 = GuidFactory<CustomerId>.NewSequential();
var id2 = GuidFactory<CustomerId>.NewSequential();

await Task.Delay(TimeSpan.FromMicroseconds(50));

var id3 = GuidFactory<SupplierId>.NewSequential();
var id4 = GuidFactory<SupplierId>.NewSequential();

Console.WriteLine($"Customer ID 1 = {id1}");
Console.WriteLine($"Customer ID 2 = {id2}");

Console.WriteLine($"Supplied ID 1 = {id3}");
Console.WriteLine($"Supplied ID 2 = {id4}");

Which outputs the following:

Customer ID 1 = 2930454c-9889-4c52-161d-08dca48c5b35
Customer ID 2 = 40cbec7e-280f-4bf7-161e-08dca48c5b35
Supplied ID 1 = 9684f1f5-2246-4b9c-20ff-08dca48c5b35
Supplied ID 2 = 92b19132-141d-4245-2100-08dca48c5b35