HI @andrewlock,

Do you have any plans to support .net core 3.0?

Thanks

When implementing a type like

[StronglyTypedId(backingType: StronglyTypedIdBackingType.Guid)]
public partial struct CustomerId { }

Then instead of

var customerId = new CustomerId(new Guid("04004919-0a3a-47b5-89e0-92215ab9ff0f"))

I want to write

var customerId = new CustomerId("04004919-0a3a-47b5-89e0-92215ab9ff0f"). 

Hello,

I have a Strongly Typed Id struct ConsentCollectionId

[StronglyTypedId(backingType: StronglyTypedIdBackingType.Guid, StronglyTypedIdConverter.SystemTextJson)]
public partial struct ConsentCollectionId { }

This type is used as a parameter in one of my controllers. Unfortunately, the generated open-api specification file contains the wrong type description:

Instead of

{
  "value": "3fa85f64-5717-4562-b3fc-2c963f66afa6"
}

it should be just

"3fa85f64-5717-4562-b3fc-2c963f66afa6"

Do you know if there is a way to change this?
As a work-around, I changed the type of the parameter back to Guid and do the mapping manually.

Kind regards,
Ilia

i use these in games

I had a bunch of public static readonly instances defined, and used reflection to bundle them all up into a readonly list at startup. The Empty value crept into that list by accident. I have other ways of fixing that little issue, but I thought maybe it would be a good idea to be able to suppress the Empty if someone needs to.

And since this is my first time communicating with you ... thank you Andrew, Great job :)

As suggested by @thomaslevesque

Just a small remark: Int should probably be renamed to Int32; int is the C# alias for Int32, but could mean other things in other languages (which, of course, isn't very important since it only generates C# code...)

e.g. in games could enumerate entities via ++ (may be minus too)

The SystemTextJsonConverter for long backing fields reads from the JSON reader as reader.GetInt32(); instead of Int64

1. Clone Project
2. Build
3. Remove project

And than for all projects:

dotnet restore
Determining projects to restore...
C:\Program Files\dotnet\sdk\5.0.104\NuGet.targets(131,5): error : The local source 'C:\Users*\source\repos*\StronglyTypedId\artifacts' doesn't exist. [C:\Users*\source\repos*\Test**.sln]

eg

/id

is good one

typed resources

Your approach requires some bit of code that could be omitted, I believe. My way is something like:

[StronglyTypedId]
public partial class Foo {
  public IdType Id { get;set; }
}

compiles to:

public partial class Foo {
  public struct IdType {
    // Implementation here
  }
}

When defining strong ids in a project and a child project which references the parent, we're seeing new CS0436 errors like this:

19>C:\Users\kfrancis\Projects\supercoolproject\aspnet-core\test\supercoolproject.Web.Tests\StronglyTypedIds\StronglyTypedIds.StronglyTypedIdGenerator\StronglyTypedIdDefaultsAttribute.cs(24,62,24,92): warning CS0436: The type 'StronglyTypedIdImplementations' in 'StronglyTypedIds\StronglyTypedIds.StronglyTypedIdGenerator\StronglyTypedIdImplementations.cs' conflicts with the imported type 'StronglyTypedIdImplementations' in 'supercoolproject.Application.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null'. Using the type defined in 'StronglyTypedIds\StronglyTypedIds.StronglyTypedIdGenerator\StronglyTypedIdImplementations.cs'.
19>C:\Users\kfrancis\Projects\supercoolproject\aspnet-core\test\supercoolproject.Web.Tests\StronglyTypedIds\StronglyTypedIds.StronglyTypedIdGenerator\StronglyTypedIdAttribute.cs(25,62,25,92): warning CS0436: The type 'StronglyTypedIdImplementations' in 'StronglyTypedIds\StronglyTypedIds.StronglyTypedIdGenerator\StronglyTypedIdImplementations.cs' conflicts with the imported type 'StronglyTypedIdImplementations' in 'supercoolproject.Application.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null'. Using the type defined in 'StronglyTypedIds\StronglyTypedIds.StronglyTypedIdGenerator\StronglyTypedIdImplementations.cs'.

[StronglyTypedId]
public partial struct GroupId
{
}

public class User
{
    public User(GroupId? groupId)
    {
        GroupId = groupId;
    }

    public GroupId? GroupId { get; }
}

var json = JsonConvert.SerializeObject(new User(groupId: null)); // "{\"GroupId\":null}"
var deserialize = JsonConvert.DeserializeObject<User>(json); // throws Newtonsoft.Json.JsonSerializationException: 'Error converting value {null} to type 'System.Guid'. Path 'GroupId', line 1, position 15.'

The issue is caused by Newtonsoft.Json's behaviour (ReadJson is called on GroupIdNewtonsoftJsonConverter with objectType = Nullable<GroupId>).

A couple of related issues from Newtonsoft.Json:
JamesNK/Newtonsoft.Json#1783
JamesNK/Newtonsoft.Json#2219

Version of StronglyTypeId: 0.2.1
Version of Newtonsoft.Json: tried with both 12.0.3 and 13.0.1

I suggest to add an additional project (StronglyTypedId.Interfaces) with

public interface IId<TBacking>
{
    TBacking Value { get; }
}

and probably with

public interface IId<TId, TBacking>
    where TId : IId<TId, TBacking>
{
    static abstract TId New();

   // Parse/TryParse
}

IId interfaces will drammatically help us to minimize boilerplate code:

1. Ids are stored in redis (and in rdbms via dapper) and we write the same (de)serialization code again and again, shared Parse/TryParse will help here
2. We configure swagger to treat ids as guids and we have to explicitely enumerate all ids during configuration. With IId in place it will be possible to enumerate all ids via reflection.

We store ids in separate libraries with contracts and we do not to pollute ids with additional attributes or add swagger/dapper packages to contract libraries.

Hi, thanks for the handy library. I think it would be rather nice to have Parse method to do

UserId.Parse("some guid")

instead of

new UserId(Guid.Parse("some guid"))

And I'd like to also see TryParse to make my parsing safer.

Summary

I'm having trouble integrating this library into my project which uses Dapper.Contrib to insert entities to a mysql database.

Dapper.Contrib throws System.InvalidCastException: 'Invalid cast from 'System.UInt64' to 'StronglyTypedIdTest.PersonId'. when calling InsertAsync. This is because of a combination of mysql's LAST_INSERT_ID() returning a ulong and Dapper.Contrib's InsertAsync function for mysql using LAST_INSERT_ID() and using the method Convert.ChangeType(id, idp.PropertyType) to set the Id property on the object.

Code to Reproduce

CREATE TABLE Persons(Id INT PRIMARY KEY AUTO_INCREMENT, Name VARCHAR(100));

using Dapper.Contrib.Extensions;
using MySqlConnector;
using StronglyTypedIds;

[assembly: StronglyTypedIdDefaults(
    backingType: StronglyTypedIdBackingType.Int,
    converters: StronglyTypedIdConverter.DapperTypeHandler | StronglyTypedIdConverter.TypeConverter)]

namespace StronglyTypedIdTest;


[StronglyTypedId]
public partial struct PersonId { }

public class Person
{
    [Key]
    public PersonId Id { get; set; }

    public string Name { get; set; }
}

public static class Program
{
    private const string ConnectionString = "xxxxxxxxxx";

    public static async Task Main()
    {
        Dapper.SqlMapper.AddTypeHandler(new PersonId.DapperTypeHandler());
        await using var conn = new MySqlConnection(ConnectionString);
        await conn.OpenAsync();
        await conn.InsertAsync(new Person { Name = "Andrew" });
    }
}

  <ItemGroup>
    <PackageReference Include="Dapper.Contrib" Version="2.0.78" />
    <PackageReference Include="MySqlConnector" Version="2.1.0" />
    <PackageReference Include="StronglyTypedId" Version="1.0.0-beta05">
	    <PrivateAssets>all</PrivateAssets>
	    <ExcludeAssets>runtime</ExcludeAssets>
    </PackageReference>
  </ItemGroup>

Solution

Unfortunately the way that the conversion happens with Convert.ChangeType makes it difficult to find a real solution. I wanted to log this issue to see if anybody else can figure one out.

Thanks for the great library and associated articles.

It would be really nice if there was the ability to optionally add an implicit operator to convert the wrapped type to the primitive one.

This would negate the need to manually use the created type converter or access the value or ToString members directly.

By specifying converters in attribute we automatically tie domain layer with infrastructure.

• Domain
  • OrderId(Converters: Dapper | EfCore) <-- produces code which depends on Microsoft.EntityFrameworkCore and Dapper
• Infrastructure.Dapper
• Infrastructure.EfCore
• Api

I'm trying to convert an existing Int32 Id property into a strongly typed Id but I'm having trouble getting EF Core 6.0 to do inserts for me.

It's a standard Int32 Id property with SQL Server generating my values for me but no matter what settings I try in my EF config I keep getting errors such as:

The property 'Tag.Id' does not have a value set and no value generator is available for properties of type 'TagId'. Either set a value for the property before adding the entity or configure a value generator for properties of type 'TagId' in 'OnModelCreating'.

I've gone through the posts on the blog and the documentation here and I can't see anything that would help me?

Example code

[StronglyTypedId(backingType: StronglyTypedIdBackingType.String)]
public partial struct UserId{ }

public class User{
    public UserId Id {get; set;}
}

...
var user = new User();
if(user.Id == UserId.Empty) --> throw exception (using Value.CompareTo when Value is null)

When I tried to access a route in ASP.NET with a strongly typed paramter I kept getting the following error:

Model bound complex types must not be abstract or value types and must have a parameterless constructor.

I had real trouble finding the problem as I had the code working prior to using the StronglyTypedId library itself. After much hunting I found the offending line:

In the example on your website here typeof(string) is used in place of typeof(int). The example is for a Guid and not an int but the behaviour is the same when used with ASP.NET routes (which is what I thought that snippet was for). FWIW the Long template also references int. Shall I fix?

HI @andrewlock,

Do you support .net standard?

Thanks

When I use OrderId in Controller/Action with wrong value (invalid guid), expected behavior is to fire a validation error. But the current behavior does not get into the validation and throws exception on

public override object ReadJson(Newtonsoft.Json.JsonReader reader, System.Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer)
{
    var guid = serializer.Deserialize<System.Guid>(reader); <------ here
    return new ReferralId(guid);
}

sample code for demonstration

public IActionResult (MyModel model){
     if (!ModelState.IsValid)
           return BadRequest(ModelState)

    .....
}

This throws exception before entering Action

[17:57:09 ERR] An unhandled exception has occurred while executing the request.
System.NullReferenceException: Object reference not set to an instance of an object.
   at Newtonsoft.Json.JsonSerializer.Deserialize[T](JsonReader reader)
   at ReferralId.ReferralIdNewtonsoftJsonConverter.ReadJson(JsonReader reader, Type objectType, Object existingValue, JsonSerializer serializer) in C:\ASB\source\Workspaces\Workspace\Atlas\Atlas\Atlas.Module.HR\obj\Debug\net5.0\ReferralEntity.K3SYoa3Q.generated.cs:line 84
   at Newtonsoft.Json.Serialization.JsonSerializerInternalReader.DeserializeConvertable(JsonConverter converter, JsonReader reader, Type objectType, Object existingValue)
   at Newtonsoft.Json.Serialization.JsonSerializerInternalReader.SetPropertyValue(JsonProperty property, JsonConverter propertyConverter, JsonContainerContract containerContract, JsonProperty containerProperty, JsonReader reader, Object target)
   at Newtonsoft.Json.Serialization.JsonSerializerInternalReader.PopulateObject(Object newObject, JsonReader reader, JsonObjectContract contract, JsonProperty member, String id)
--- End of stack trace from previous location ---
   at Microsoft.AspNetCore.Mvc.Formatters.NewtonsoftJsonInputFormatter.ReadRequestBodyAsync(InputFormatterContext context, Encoding encoding)
   at Microsoft.AspNetCore.Mvc.ModelBinding.Binders.BodyModelBinder.BindModelAsync(ModelBindingContext bindingContext)
   at Microsoft.AspNetCore.Mvc.ModelBinding.ParameterBinder.BindModelAsync(ActionContext actionContext, IModelBinder modelBinder, IValueProvider valueProvider, ParameterDescriptor parameter, ModelMetadata metadata, Object value, Object container)
   at Microsoft.AspNetCore.Mvc.Controllers.ControllerBinderDelegateProvider.<>c__DisplayClass0_0.<<CreateBinderDelegate>g__Bind|0>d.MoveNext()
--- End of stack trace from previous location ---
   at Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker.<InvokeInnerFilterAsync>g__Awaited|13_0(ControllerActionInvoker invoker, Task lastTask, State next, Scope scope, Object state, Boolean isCompleted)
   at Microsoft.AspNetCore.Mvc.Infrastructure.ResourceInvoker.<InvokeFilterPipelineAsync>g__Awaited|19_0(ResourceInvoker invoker, Task lastTask, State next, Scope scope, Object state, Boolean isCompleted)
   at Microsoft.AspNetCore.Mvc.Infrastructure.ResourceInvoker.<InvokeAsync>g__Logged|17_1(ResourceInvoker invoker)
   at Microsoft.AspNetCore.Routing.EndpointMiddleware.<Invoke>g__AwaitRequestTask|6_0(Endpoint endpoint, Task requestTask, ILogger logger)
   at Atlas.Infrastructure.Middleware.ExceptionHandlingMiddleware.InvokeAsync(HttpContext context) in C:\ASB\source\Workspaces\Workspace\Atlas\Atlas\Atlas.Infrastructure\Middleware\ExceptionHandlingMiddleware.cs:line 24
   at Hellang.Middleware.ProblemDetails.ProblemDetailsMiddleware.Invoke(HttpContext context)

Hello
What about refactoring the code on https://devblogs.microsoft.com/dotnet/introducing-c-source-generators/ ?

( The AArnot code generator is now obsolete)

I want to put into my list of examples - https://github.com/ignatandrei/RSCG_Examples

Allow to limit string to 50 chars and ushort to 14 bits. I want to use this in games.

because System.Text.Json will work only there

NewId is a sequential id generator analagous to sequential guids based on erlang's flake, and is the underlying id type i need to use for a few of my projects so having support would be ideal

Hello @andrewlock,
I am migrating from 0.2.1 to 1.0.0-beta02 and I have noticed that nesting:

public partial class Blog
{
  [StronglyTypedId(backingType: StronglyTypedIdBackingType.String, converters: StronglyTypedIdConverter.NewtonsoftJson | StronglyTypedIdConverter.SystemTextJson | StronglyTypedIdConverter.EfCoreValueConverter)]
  public partial struct PostId { }
}

Stopped triggering code generation, so calling a constructor is not possible and dotnet sdk 5.0.402 returns:
error CS1729: 'Blog.PostId' does not contain a constructor that takes 1 arguments

While it was working for 0.2.1. For now, I have just moved PostId outside to be directly under namespace scope and prefixed its name, then done some Find&Replace action.

With EF Core 6 the possibility of global conversions was introduced. But to set them up a parameterless Constructor is needed.
Currently this Feature is not documented but a pullrequest is on the way: https://github.com/dotnet/EntityFramework.Docs/pull/3716/commits. The only change needed to get it to work ist adding the parameterless constructor to the EfCoreValueConverter. After that the only thing the user has to do ist to add the converters in the ConfigureConventions method override.

What's the best way to add nullable support here? You discuss it in previous posts, but it doesn't seem to be part of the library.

The property 'Claim.CaseId' could not be mapped, because it is of type 'Nullable' which is not a supported primitive type or a valid entity type. Either explicitly map this property, or ignore it using the '[NotMapped]' attribute or by using 'EntityTypeBuilder.Ignore' in 'OnModelCreating'

CaseId is defined:

[StronglyTypedId(jsonConverter: StronglyTypedIdJsonConverter.SystemTextJson | StronglyTypedIdJsonConverter.NewtonsoftJson, backingType: StronglyTypedIdBackingType.Guid)]
    public partial struct CaseId { }

And used:

public class Claim {
    public CaseId? CaseId { get; set; }
}

I have also:

public class CaseIdValueConverter : ValueConverter<CaseId, Guid>
    {
        public CaseIdValueConverter(ConverterMappingHints mappingHints = null)
            : base(
                id => id.Value,
                value => new CaseId(value),
                mappingHints
            )
        { }
    }

and ReplaceService<IValueConverterSelector, StronglyTypedIdValueConverterSelector>()

To prevent code analysis warnings and errors.
Please add [System.CodeDom.Compiler.GeneratedCode(null, null)] to all generated code, with appropriated tool and version number.

Hi Andrew. In your excellent series of blog posts on Strongly Typed Id's, you make mention of some downsides to using a struct to model identity versus a class, due to implicit parameterless constructors. You also cite Vladamir Khorikov's article on the subject who makes further arguments for not choosing a struct for modelling identity and favoring a class. Classes have their downsides too of course, not least of which is having to null-check them all over the place, so they're not a panacea, but if you're trying to follow DDD best practices where protection of invariants is paramount, a class-based option would be desirable.

So, with all that said, have you considered enabling class-based strongly typed identifiers in your library in addition to struct-based ones?

ASP.Net Core 3.1 uses System.Text.Json to serialize objects. It would be good to support this new method of serialization.

I currently use the following (obviously it would need adapting to support the relevant use cases in this package).

public class MemberIdConverter : JsonConverter<MemberId>
{
    public override MemberId Read(
        ref Utf8JsonReader reader,
        Type typeToConvert,
        JsonSerializerOptions options) =>
            new MemberId(Guid.Parse(reader.GetString()));

    public override void Write(
        Utf8JsonWriter writer,
        MemberId value,
        JsonSerializerOptions options) =>
            writer.WriteStringValue(value.Value);
}

This issue depends upon #5

We love the idea of strongly typed ids and we're using the library.

When trying to finally get this working in a generic repository, efcore, json to client side scenario - we're getting the following:

WARN The type 'CabMD.MasterNumbers.Master_Number' is not a supported Dictionary key type. The unsupported member type is located on type 'CabMD.MasterNumbers.MasterNumber'. Path: $.

System.NotSupportedException: The type 'CabMD.MasterNumbers.Master_Number' is not a supported Dictionary key type. The unsupported member type is located on type 'CabMD.MasterNumbers.MasterNumber'. Path: $.
---> System.NotSupportedException: The type 'CabMD.MasterNumbers.Master_Number' is not a supported Dictionary key type.
at System.Text.Json.ThrowHelper.ThrowNotSupportedException_DictionaryKeyTypeNotSupported(Type keyType)
at System.Text.Json.JsonSerializerOptions.GetDictionaryKeyConverter(Type keyType)
at System.Text.Json.Serialization.Converters.DictionaryDefaultConverter3.GetKeyConverter(Type keyType, JsonSerializerOptions options) at System.Text.Json.Serialization.Converters.IDictionaryOfTKeyTValueConverter3.OnWriteResume(Utf8JsonWriter writer, TCollection value, JsonSerializerOptions options, WriteStack& state)
at System.Text.Json.Serialization.Converters.DictionaryDefaultConverter3.OnTryWrite(Utf8JsonWriter writer, TCollection dictionary, JsonSerializerOptions options, WriteStack& state) at System.Text.Json.Serialization.JsonConverter1.TryWrite(Utf8JsonWriter writer, T& value, JsonSerializerOptions options, WriteStack& state)
at System.Text.Json.Serialization.JsonConverter1.WriteCore(Utf8JsonWriter writer, T& value, JsonSerializerOptions options, WriteStack& state) --- End of inner exception stack trace --- at System.Text.Json.ThrowHelper.ThrowNotSupportedException(WriteStack& state, NotSupportedException ex) at System.Text.Json.Serialization.JsonConverter1.WriteCore(Utf8JsonWriter writer, T& value, JsonSerializerOptions options, WriteStack& state)
at System.Text.Json.Serialization.JsonConverter1.WriteCoreAsObject(Utf8JsonWriter writer, Object value, JsonSerializerOptions options, WriteStack& state) at System.Text.Json.JsonSerializer.WriteCore[TValue](JsonConverter jsonConverter, Utf8JsonWriter writer, TValue& value, JsonSerializerOptions options, WriteStack& state) at System.Text.Json.JsonSerializer.WriteCore[TValue](Utf8JsonWriter writer, TValue& value, Type inputType, JsonSerializerOptions options) at System.Text.Json.JsonSerializer.Serialize[TValue](Utf8JsonWriter writer, TValue& value, Type type, JsonSerializerOptions options) at System.Text.Json.JsonSerializer.Serialize[TValue](Utf8JsonWriter writer, TValue value, JsonSerializerOptions options) at Volo.Abp.Json.SystemTextJson.JsonConverters.ObjectToInferredTypesConverter.Write(Utf8JsonWriter writer, Object objectToWrite, JsonSerializerOptions options) at System.Text.Json.Serialization.JsonConverter1.TryWrite(Utf8JsonWriter writer, T& value, JsonSerializerOptions options, WriteStack& state)
at System.Text.Json.JsonPropertyInfo1.GetMemberAndWriteJson(Object obj, WriteStack& state, Utf8JsonWriter writer) at System.Text.Json.Serialization.Converters.ObjectDefaultConverter1.OnTryWrite(Utf8JsonWriter writer, T value, JsonSerializerOptions options, WriteStack& state)
at System.Text.Json.Serialization.JsonConverter1.TryWrite(Utf8JsonWriter writer, T& value, JsonSerializerOptions options, WriteStack& state) at System.Text.Json.Serialization.JsonConverter1.WriteCore(Utf8JsonWriter writer, T& value, JsonSerializerOptions options, WriteStack& state)
at System.Text.Json.Serialization.JsonConverter1.WriteCoreAsObject(Utf8JsonWriter writer, Object value, JsonSerializerOptions options, WriteStack& state) at System.Text.Json.JsonSerializer.WriteCore[TValue](JsonConverter jsonConverter, Utf8JsonWriter writer, TValue& value, JsonSerializerOptions options, WriteStack& state) at System.Text.Json.JsonSerializer.WriteCore[TValue](Utf8JsonWriter writer, TValue& value, Type inputType, JsonSerializerOptions options) at System.Text.Json.JsonSerializer.Serialize[TValue](TValue& value, Type inputType, JsonSerializerOptions options) at System.Text.Json.JsonSerializer.Serialize[TValue](TValue value, JsonSerializerOptions options) at Volo.Abp.Json.SystemTextJson.AbpSystemTextJsonSerializerProvider.Serialize(Object obj, Boolean camelCase, Boolean indented) at Volo.Abp.Json.AbpHybridJsonSerializer.Serialize(Object obj, Boolean camelCase, Boolean indented) at Volo.Abp.Caching.Utf8JsonDistributedCacheSerializer.Serialize[T](T obj) at Volo.Abp.Caching.DistributedCache2.<>c__DisplayClass49_0.<g__SetRealCache|0>d.MoveNext()

This is defined like the follow:

    [StronglyTypedId(jsonConverter: StronglyTypedIdJsonConverter.SystemTextJson | StronglyTypedIdJsonConverter.NewtonsoftJson, backingType: StronglyTypedIdBackingType.String)]
    public partial struct Master_Number { }

We're using the StronglyTypedId library, v0.2.1

Great project!

Would you be welcome to adding more documentation on how to integrate this with entity framework and dapper so that they get mapped properly to the DB?

emojis are very versatile now in unicode - may be there is patter for meta identity?

When creating an object like this:

[StronglyTypedId(backingType: StronglyTypedIdBackingType.Int, converters: StronglyTypedIdConverter.SystemTextJson)] public partial struct JobNumber { }

We get a bunch of warnings/errors CS1591 and because we use the <TreatWarningsAsErrors>true</TreatWarningsAsErrors> we cannot compile the code.

Is is possible for you to add #pragma CS1591 to the sources?

Hi,

Nice project !
Why not use the ISerialiazable interface avaible since .Net Standard 2.0 to allow json conversion without the need of a reference on JSonConverter ?
https://www.newtonsoft.com/json/help/html/SerializationGuide.htm#ISerializable

Maybe it could be an option ?

Need to disable CS1591 per file in generated code, and possibly tag with a generated code attribute to make VS ignore issues in generated files.

We use serialisers such as protobuf-net and others, it would be great if an extension point be made such as adding attributes to members (one workaround might be to add custom serialisation methods to a partial class or could we add [DataMember(Order = 1)]/[DataContract] by default).

Hello, do you plan to add serialization support for mongodb and MessagePack( binary serializer) . Or do they already exist, I couldnt find...

Thank you

If I use a Guid based strongly typed id EF Core throws the following exception

System.InvalidOperationException : The property 'Foo.Id' could not be mapped, because it is of type 'FooId' which is not a supported primitive type or a valid entity type. Either explicitly map this property, or ignore it using the '[NotMapped]' attribute or by using 'EntityTypeBuilder.Ignore' in 'OnModelCreating'.

I can work around that issue by initializing the property

public class Foo
{
    public FooId Id { get; set; } = FooId.New();
}

but auto-generation by convention would be really nice.

Is that possible?

It would be really nice to have the option to use ObjectId as a backing type, because MongoDb relies a lot on it and it would remove some convertion that otherwise must happen.

Hi!

Thanks for creating this library, I really like it. As I was using it within my project I had several ids with a backing type of String. On certain occasions, these ids were created using a default, parameterless constructor. When GetHashCode was invoked on those ids the NullReferenceException was thrown, and that what a bit against what I would expect.

I have attached a .CS file containing tests you can run to reproduce the issue (I had some issues with dotnetfiddle).

Tests.txt

Some of my thoughts on this:

• I found out that in the current beta version, there is a NullableString as a backing type. This is ok and GetHashCode works without issues here in all scenarios, but I would expect that using String as a backing type is reliable. By this, I mean that it is ok that creating such a struct with the default constructor ends up with the Value property being null, but I would not expect GetHashCode to throw.

• Creating structs with backing type String using default constructor (or default keyword) could potentially be undesirable. I could imagine some use cases where having such "id" would be ok, but Nullable String could be a better fit as a backing type. Could we have an analyzer that would raise a warning about creating structs with reference types like string, using the default constructor? This can prevent both intentional, but also accidental creation of such instances.

In the end, if you opt for addressing this, I would be happy to implement the solution and contribute to your project :)

The id structs generated don't implement some comparison operators (<,>, <=, or >=.) The CLR cannot automatically call the CompareTo implementation from Equals(object) or from the base comparison operator implementations.

It looks like there's a bug in EF that prevents it from recognizing strongly typed IDs (longs / int64) as potential identity columns.

Identity value generation cannot be used for the property 'Id' on entity type 'MyTask' because the property type is 'TaskId'. Identity value generation can only be used with signed integer properties.

Has anyone found a way to avoid this? I'd put this in the EF Core repo, but I'm guessing it wouldn't be prioritized.

As suggested by @thomaslevesque

the ability to generate Int64 ids could be useful.