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.csEntityeValueObjectclasses (onde para umaEntitypropriedadeIdera do tipoId.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);
}
}
Id.Empty..., ou teria que implementá-lo de outra forma em um método de extensão ... Gosto da idéia, thx por pensar nisso. Se nenhuma outra solução surgir, eu me contentaria com isso, pois isso indica claramente a intenção.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
fonte
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.
fonte