J'essaie d'avoir une Idclasse fortement typée , qui tient désormais "longtemps" en interne. Mise en œuvre ci-dessous. Le problème que j'utilise dans mes entités est que Entity Framework me donne un message indiquant que l' ID de propriété y est déjà mappé. Voir monIEntityTypeConfiguration ci dessous.
Remarque: je ne vise pas à avoir une implémentation DDD rigide. Veuillez donc garder cela à l'esprit lorsque vous commentez ou répondez . L'identifiant derrière le dactylographié Idest destiné aux développeurs qui viennent au projet, ils sont fortement typés pour utiliser l'ID dans toutes leurs entités, bien sûr traduit en long(ouBIGINT ) - mais c'est clair pour les autres.
Ci-dessous la classe et la configuration, ce qui ne fonctionne pas. Le référentiel peut être trouvé sur https://github.com/KodeFoxx/Kf.CleanArchitectureTemplate.NetCore31 ,
Idclasse à (commenté maintenant): https://github.com/KodeFoxx/Kf.CleanArchitectureTemplate.NetCore31/blob/master/Source/Common/Kf.CANetCore31/DomainDrivenDesign/Id.csEntityet desValueObjectclasses (où pour uneEntitypropriétéIdétait du typeId.cs (ci-dessus): https://github.com/KodeFoxx/Kf.CleanArchitectureTemplate.NetCore31/tree/master/Source/Common/Kf.CANetCore31/DomainDrivenDesign- Configurations sur: https://github.com/KodeFoxx/Kf.CleanArchitectureTemplate.NetCore31/tree/master/Source/Infrastructure/Persistence/Kf.CANetCore31.Infrastructure.Persistence.Ef/EntityTypeConfigurations
Idimplémentation de classe (marquée obsolète maintenant, car j'ai abandonné l'idée jusqu'à ce que je trouve une solution pour cela)
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 };
}
}EntityTypeConfigurationJ'utilisais lorsque l'ID n'était pas marqué comme obsolète pour l'entitéPerson Malheureusement, quand de type ID, EfCore ne voulait pas le mapper ... quand de type long ce n'était pas un problème ... Autres types possédés, comme vous le voyez (avec Name) fonctionne bien.
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 de base (quand j'utilisais toujours Id, donc quand il n'était pas marqué comme obsolète)
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(le domaine et les références aux autres ValueObjects peuvent être trouvés sur 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 je devrais l'implémenter autrement dans une méthode d'extension alors ... J'aime l'idée, merci de réfléchir. Si aucune autre solution ne se présente, je me contenterais de cela, car cela indique clairement l'intention.Donc, après avoir cherché longtemps et essayé d'obtenir une réponse supplémentaire, je l'ai trouvée, la voici. Merci à Andrew Lock.
ID fortement typés dans EF Core: utilisation d'ID d'entité fortement typés pour éviter l'obsession primitive - Partie 4 : https://andrewlock.net/strongly-typed-ids-in-ef-core-using-strongly-typed-entity- ids à éviter-obsession-primitive-partie-4 /
TL; DR / Résumé d'Andrew Dans cet article, je décris une solution pour utiliser des ID fortement typés dans vos entités EF Core en utilisant des convertisseurs de valeur et un IValueConverterSelector personnalisé. Le ValueConverterSelector de base dans le cadre EF Core est utilisé pour enregistrer toutes les conversions de valeurs intégrées entre les types primitifs. En dérivant de cette classe, nous pouvons ajouter nos convertisseurs d'ID fortement typés à cette liste et obtenir une conversion transparente dans toutes nos requêtes EF Core
la source
Je pense que vous n'avez pas de chance. Votre cas d'utilisation est extrêmement rare. Et EF Core 3.1.1 a encore du mal à mettre SQL dans la base de données qui n'est cassée dans rien, sauf dans la plupart des cas de base.
Donc, vous devriez écrire quelque chose qui passe par l'arborescence LINQ et c'est probablement une énorme quantité de travail, et si vous tombez sur des bugs sur EF Core - que vous aurez - amusez-vous à expliquer cela dans vos tickets.
la source