IDs fortemente digitados no Entity Framework Core

Estou tentando ter uma Idclasse fortemente tipada , que agora dura 'internamente'. Implementação abaixo. O problema que estou usando isso em minhas entidades é que o Entity Framework me dá uma mensagem de que o ID da propriedade já está mapeado para ele. Veja meu IEntityTypeConfigurationabaixo.

Nota: Não pretendo ter uma implementação rígida de DDD. Portanto, lembre-se disso ao comentar ou responder . Todo o ID por trás do digitado Idé para os desenvolvedores que vêm para o projeto, eles são fortemente tipados para usar o Id em todas as suas entidades, é claro traduzido para long(ou BIGINT) - mas fica claro para outros.

Abaixo da classe e configuração, que não funciona. O repositório pode ser encontrado em https://github.com/KodeFoxx/Kf.CleanArchitectureTemplate.NetCore31 ,

• Idclasse em (comentada agora): https://github.com/KodeFoxx/Kf.CleanArchitectureTemplate.NetCore31/blob/master/Source/Common/Kf.CANetCore31/DomainDrivenDesign/Id.cs
• Entitye ValueObjectclasses (onde para uma Entitypropriedade Idera do tipo Id.cs (acima): https://github.com/KodeFoxx/Kf.CleanArchitectureTemplate.NetCore31/tree/master/Source/Common/Kf.CANetCore31/DomainDrivenDesign
• Configurações em: https://github.com/KodeFoxx/Kf.CleanArchitectureTemplate.NetCore31/tree/master/Source/Infrastructure/Persistence/Kf.CANetCore31.Infrastructure.Persistence.Ef/EntityTypeConfigurations

Idimplementação de classe (marcada como obsoleta agora, porque abandonei a ideia até encontrar uma solução para isso)

namespace Kf.CANetCore31.DomainDrivenDesign
{
    [DebuggerDisplay("{DebuggerDisplayString,nq}")]
    [Obsolete]
    public sealed class Id : ValueObject
    {
        public static implicit operator Id(long value)
            => new Id(value);
        public static implicit operator long(Id value)
            => value.Value;
        public static implicit operator Id(ulong value)
            => new Id((long)value);
        public static implicit operator ulong(Id value)
            => (ulong)value.Value;
        public static implicit operator Id(int value)
            => new Id(value);


        public static Id Empty
            => new Id();

        public static Id Create(long value)
            => new Id(value);

        private Id(long id)
            => Value = id;
        private Id()
            : this(0)
        { }

        public long Value { get; }

        public override string DebuggerDisplayString
            => this.CreateDebugString(x => x.Value);

        public override string ToString()
            => DebuggerDisplayString;

        protected override IEnumerable<object> EquatableValues
            => new object[] { Value };
    }
}

EntityTypeConfigurationEu estava usando quando o ID não foi marcado como obsoleto para entidadePerson Infelizmente, porém, quando do tipo Id, o EfCore não quis mapeá-lo ... quando do tipo longo, não houve problema ... Outros tipos de propriedade, como você vê (com Name) funciona bem.

public sealed class PersonEntityTypeConfiguration
        : IEntityTypeConfiguration<Person>
    {
        public void Configure(EntityTypeBuilder<Person> builder)
        {
            // this would be wrapped in either a base class or an extenion method on
            // EntityTypeBuilder<TEntity> where TEntity : Entity
            // to not repeated the code over each EntityTypeConfiguration
            // but expanded here for clarity
            builder
                .HasKey(e => e.Id);
            builder
                .OwnsOne(
                e => e.Id,
                id => {
                   id.Property(e => e.Id)
                     .HasColumnName("firstName")
                     .UseIdentityColumn(1, 1)
                     .HasColumnType(SqlServerColumnTypes.Int64_BIGINT);
                }

            builder.OwnsOne(
                e => e.Name,
                name =>
                {
                    name.Property(p => p.FirstName)
                        .HasColumnName("firstName")
                        .HasMaxLength(150);
                    name.Property(p => p.LastName)
                        .HasColumnName("lastName")
                        .HasMaxLength(150);
                }
            );

            builder.Ignore(e => e.Number);
        }
    }

Entity classe base (quando eu ainda estava usando o Id, então quando não estava marcado como obsoleto)

namespace Kf.CANetCore31.DomainDrivenDesign
{
    /// <summary>
    /// Defines an entity.
    /// </summary>
    [DebuggerDisplay("{DebuggerDisplayString,nq}")]
    public abstract class Entity
        : IDebuggerDisplayString,
          IEquatable<Entity>
    {
        public static bool operator ==(Entity a, Entity b)
        {
            if (ReferenceEquals(a, null) && ReferenceEquals(b, null))
                return true;

            if (ReferenceEquals(a, null) || ReferenceEquals(b, null))
                return false;

            return a.Equals(b);
        }

        public static bool operator !=(Entity a, Entity b)
            => !(a == b);

        protected Entity(Id id)
            => Id = id;

        public Id Id { get; }

        public override bool Equals(object @object)
        {
            if (@object == null) return false;
            if (@object is Entity entity) return Equals(entity);
            return false;
        }

        public bool Equals(Entity other)
        {
            if (other == null) return false;
            if (ReferenceEquals(this, other)) return true;
            if (GetType() != other.GetType()) return false;
            return Id == other.Id;
        }

        public override int GetHashCode()
            => $"{GetType()}{Id}".GetHashCode();

        public virtual string DebuggerDisplayString
            => this.CreateDebugString(x => x.Id);

        public override string ToString()
            => DebuggerDisplayString;
    }
}

Person(o domínio e as referências aos outros ValueObjects podem ser encontrados em https://github.com/KodeFoxx/Kf.CleanArchitectureTemplate.NetCore31/tree/master/Source/Core/Domain/Kf.CANetCore31.Core.Domain/People )

namespace Kf.CANetCore31.Core.Domain.People
{
    [DebuggerDisplay("{DebuggerDisplayString,nq}")]
    public sealed class Person : Entity
    {
        public static Person Empty
            => new Person();

        public static Person Create(Name name)
            => new Person(name);

        public static Person Create(Id id, Name name)
            => new Person(id, name);

        private Person(Id id, Name name)
            : base(id)
            => Name = name;
        private Person(Name name)
            : this(Id.Empty, name)
        { }
        private Person()
            : this(Name.Empty)
        { }

        public Number Number
            => Number.For(this);
        public Name Name { get; }

        public override string DebuggerDisplayString
            => this.CreateDebugString(x => x.Number.Value, x => x.Name);
    }
}

Não pretendo ter uma implementação rígida de DDD. Portanto, lembre-se disso ao comentar ou responder. Todo o ID por trás do ID digitado é para os desenvolvedores que chegam ao projeto, eles são fortemente tipados para usar o ID em todas as suas entidades

Por que não adicionar um alias de tipo:

using Id = System.Int64;

Então, depois de pesquisar um longo tempo e tentar obter mais respostas, encontrei, aqui está então. Obrigado a Andrew Lock.

IDs fortemente tipados no EF Core: usando IDs de entidades fortemente tipados para evitar obsessão primitiva - Parte 4 : https://andrewlock.net/strongly-typed-ids-in-ef-core-using-strongly-typed-entity- ids-para-evitar-obsessão-primitiva-parte-4 /

TL; DR / Resumo de Andrew Neste post, descrevo uma solução para o uso de IDs fortemente tipados em suas entidades EF Core usando conversores de valor e um IValueConverterSelector personalizado. O ValueConverterSelector base na estrutura EF Core é usado para registrar todas as conversões de valor internas entre tipos primitivos. Ao derivar dessa classe, podemos adicionar nossos conversores de ID fortemente tipados a esta lista e obter uma conversão contínua em todas as nossas consultas EF Core

Eu acho que você está sem sorte. Seu caso de uso é extremamente raro. E o EF Core 3.1.1 ainda está lutando para colocar o SQL no banco de dados que não está quebrado em nada, exceto nos casos mais básicos.

Então, você teria que escrever algo que atravesse a árvore LINQ e isso provavelmente é uma tremenda quantidade de trabalho, e se você encontrar erros no EF Core - o que você vai - se divertir explicando isso nos seus tickets.