.NET 8, EF Core - Unable to create a 'DbContext' of type

KerimCETINBAS

Şöyle bir hata alıyorum.

`
The exception 'The types of the properties specified for the foreign key {'ProductId' : ProductId} on entity type 'ProductVariant' do not m
atch the types of the properties in the principal key {'Id' : AggregateRootId<Guid>} on entity type 'Product'. Provide properties that use the same types in the same order.' was thrown while attempting to create an instance. For the different patterns sup
ported at design time, see https://go.microsoft.com/fwlink/?linkid=851728

product sınıfı, uzun olmasın diye alakasız fieldları ve methodları sildim

public class Product: AggregateRoot<ProductId, Guid>
{
    
    #pragma warning disable CS8618 
    public Product() {}
    #pragma warning restore CS8618 


    public Product(
        ProductId id,
        List<ProductVariant>? variants) : base(id)
    {
        _variants = variants ?? [];
    }
    
 

    private List<ProductVariant> _variants = [];
    public IReadOnlyList<ProductVariant> Variants => _variants.AsReadOnly();
    
}

ProductVariant sinifi

public class ProductVariant: Entity<ProductVariantId>
{
    public ProductVariant(
        ProductVariantId id,
        ProductId productId,
        Product product,): base(id)
    {
        Product = product;
        ProductId = productId;
    }

    #pragma warning disable CS8618 
    private ProductVariant() {}
    #pragma warning restore CS8618
 

    public ProductId ProductId { get; }
    public Product Product { get; }

}

productId

public sealed class ProductId: AggregateRootId<Guid>
{
    
    public override Guid Value { get; protected set; }

    // ReSharper disable once ConvertToPrimaryConstructor
    public ProductId(Guid value)
    {
        Value = value;
    }

    public ProductId()
    {
        Value = Guid.NewGuid();
    }
    
    public override IEnumerable<object> GetEqualityComponents()
    {
        yield return Value;
    }

}

productVariantId

public class ProductVariantId(Guid value): ValueObject
{

    public override IEnumerable<object> GetEqualityComponents()
    {
        yield return Value;
    }

    public Guid Value { get; } = value;
}

base sınıflarımda sunlar, alakasiz fieldları ve metodları sildim yoksa çok uzun oluyor

public abstract class AggregateRoot<TId, TIdType> : Entity<TId>  
    where TId : AggregateRootId<TIdType> {
    
    public new AggregateRootId<TIdType> Id { get; protected set; }
    protected AggregateRoot(TId id) : base(id) {
        Id = id;
    }

    #pragma warning disable CS8618 
    protected AggregateRoot() { }
    #pragma warning restore CS8618 
}

public abstract class AggregateRootId<TId>: ValueObject
{
    public abstract TId Value { get; protected set; }
}

public abstract class Entity<TId>: IEquatable<Entity<TId>>, IHasDomainEvents
{
    /// <summary>
    /// Gets or inits the value of the id
    /// </summary>
    // ReSharper disable once NullableWarningSuppressionIsUsed
    public TId Id { get; protected set; } = default!;

    protected Entity(TId id) {
        Id = id;
    }

    /// <summary>
    /// Initializes a new instance of the <see cref="Entity{TId}"/> class
    /// </summary>
    protected Entity() {  }
    

}

public abstract class ValueObject: IEquatable<ValueObject> {

    protected ValueObject()
    {  
    }
    
}

fluent api configurationlarım

product configuration, uzun olmasın diye alakasız kısımları sildim

public class Product: IEntityTypeConfiguration<Domain.Aggregates.Product.Product>
{
    public void Configure(EntityTypeBuilder<Domain.Aggregates.Product.Product> builder)
    {
        builder.ToTable($"{nameof(Domain.Aggregates.Product.Product)}s");

        builder.HasKey(x => x.Id);
        builder.Property(x => x.Id)
            .ValueGeneratedNever()
            .HasConversion(
                id => id.Value,
                value => new ProductId(value));
        
  

        builder.HasMany(x => x.Variants)
            .WithOne(x => x.Product)
            .HasForeignKey(x => x.ProductId)
            .HasPrincipalKey(x => x.Id);


    }
}

product variant configuration sınıfım

public class ProductVariant: IEntityTypeConfiguration<Domain.Aggregates.Product.Entities.ProductVariant>
{
    public void Configure(EntityTypeBuilder<Domain.Aggregates.Product.Entities.ProductVariant> builder)
    {
        builder.ToTable($"{nameof(Domain.Aggregates.Product.Entities.ProductVariant)}s");
        builder.HasKey(x => x.Id);

        builder.Property(x => x.Id)
            .ValueGeneratedNever()
            .HasConversion(
                id => id.Value,
                value => new ProductVariantId(value));

        builder.Property(x => x.ProductId)
            .ValueGeneratedNever()
            .HasConversion(
                 id => id.Value,
                 value => new ProductId(value));

        builder.HasOne(x => x.Product)
            .WithMany(x => x.Variants)
            .HasForeignKey(x => x.ProductId)
            .HasPrincipalKey(x => x.Id);
    }
}

sorunun sebebinin az cok ne olduğunu biliyor gibiyim ama nasıl çözecegimi kavrayamadım

Ef core primary key türü olarak ProductId yerine base class taki AggregateRootId<Guid> olarak algılıyor. ProductVariant sınıfında ise foreign keyin türü ProductId
`

By_Surmeneli

KerimCETINBAS

Yapay Zeka Cevabı

Görünüşe göre, Product sınıfınızda Id property'si için kullanılan tür AggregateRootId<Guid>, fakat ProductVariant sınıfında bu property ProductId türünde. Bu, Entity Framework Core'un veritabanı ilişkisini doğru bir şekilde yapılandıramamasına neden oluyor.

Bu sorunu çözmek için birkaç adım izleyebiliriz. İlk olarak, Product ve ProductVariant sınıflarının foreign key ve principal key türlerinin uyumlu olduğundan emin olmalıyız. Ayrıca, Entity Framework Core'a foreign key ve principal key türlerini nasıl dönüştüreceğini doğru bir şekilde belirtmemiz gerekiyor.

1. Product ve ProductVariant Sınıflarının Yapılandırmalarını Düzeltmek
Product ve ProductVariant sınıflarınızın Fluent API yapılandırmalarını aşağıdaki şekilde güncelleyebilirsiniz:

Product Yapılandırması

public class ProductConfiguration : IEntityTypeConfiguration<Product>
{
    public void Configure(EntityTypeBuilder<Product> builder)
    {
        builder.ToTable("Products");

        builder.HasKey(x => x.Id);
        builder.Property(x => x.Id)
            .ValueGeneratedNever()
            .HasConversion(
                id => id.Value,
                value => new ProductId(value));

        builder.HasMany(x => x.Variants)
            .WithOne(x => x.Product)
            .HasForeignKey(x => x.ProductId)
            .HasPrincipalKey(x => x.Id);
    }
}

ProductVariant Yapılandırması

public class ProductVariantConfiguration : IEntityTypeConfiguration<ProductVariant>
{
    public void Configure(EntityTypeBuilder<ProductVariant> builder)
    {
        builder.ToTable("ProductVariants");
        builder.HasKey(x => x.Id);

        builder.Property(x => x.Id)
            .ValueGeneratedNever()
            .HasConversion(
                id => id.Value,
                value => new ProductVariantId(value));

        builder.Property(x => x.ProductId)
            .ValueGeneratedNever()
            .HasConversion(
                 id => id.Value,
                 value => new ProductId(value));

        builder.HasOne(x => x.Product)
            .WithMany(x => x.Variants)
            .HasForeignKey(x => x.ProductId)
            .HasPrincipalKey(x => x.Id);
    }
}

2. ProductId ve AggregateRootId<Guid> Uyumsuzluğunu Çözmek

ProductId türü, AggregateRootId<Guid> türünden türetilmiş olmasına rağmen, Entity Framework Core bunu otomatik olarak çözemez. Bu nedenle, ProductId property'si ile AggregateRootId<Guid> property'sinin aynı türde olduğunu belirtmemiz gerekiyor.

ProductId ve AggregateRootId<Guid> İlişkisini Belirtmek
Product sınıfınızda Id property'si AggregateRootId<Guid> türünde olduğu için, ProductId property'sinin de aynı türde olduğunu Entity Framework Core'a açıkça belirtmemiz gerekiyor. Bunu yapılandırmada HasConversion metodunu kullanarak yapabilirsiniz.

public class ProductId : AggregateRootId<Guid>
{
    public override Guid Value { get; protected set; }

    public ProductId(Guid value)
    {
        Value = value;
    }

    public ProductId()
    {
        Value = Guid.NewGuid();
    }

    public override IEnumerable<object> GetEqualityComponents()
    {
        yield return Value;
    }
}

Bu türü yapılandırmada kullanırken HasConversion metodunu kullanarak dönüşümü açıkça belirtmemiz gerekiyor.

ProductVariant Yapılandırması
ProductVariant sınıfında ProductId property'sini yapılandırırken HasConversion metodunu kullanarak dönüşümü belirttik:

builder.Property(x => x.ProductId)
    .ValueGeneratedNever()
    .HasConversion(
         id => id.Value,
         value => new ProductId(value));

Bu sayede Entity Framework Core, ProductId ve AggregateRootId<Guid> türlerini eşleştirebilir ve doğru bir şekilde dönüştürebilir.

Sonuç
Bu adımları izleyerek Product ve ProductVariant sınıflarınızın foreign key ve principal key türlerinin uyumlu olmasını sağlayabilir ve Entity Framework Core'un bu ilişkileri doğru bir şekilde oluşturmasına yardımcı olabilirsiniz.

KerimCETINBAS

Hocam yapay zeka çözebilecek olsa buraya yazmazdım... Yapay zeka zaten benim kodumun bire bir aynısını öneriyor

By_Surmeneli

KerimCETINBAS

Olabilir hocam sadece fikir vermesi babında yazdım, ben yapay zeka ile bir çok python vb proje geliştirdim. C# olmadığından deneme yapamıyorum. Ama Yapay Zeka'nın Python kodlama konusunda bir çok konuda yardımını gördüm.

backbone

Merhaba,

uygulamanin asagidaki satiri icermesinden kaynakli olabilir mi ? Yorumunuzda belirttiginiz "Ef core primary key türü olarak ProductId yerine base class taki AggregateRootId<Guid> olarak algılıyor." bana bunu gösteriyor sanki.

public sealed class ProductId: AggregateRootId<Guid>

Ve EF Core uygulamasi da ProductId sinifinin asagidaki kodlarini tercih ediyor diye tahmin ediyorum. Cünkü zaten bu sinifta "AggregateRootId<Guid>" 'den miras almis.

public ProductId(Guid value)
    {
        Value = value;
    }

Projenize tam hakim olmadigim icin sizden aldigim bilgiler dahilinde cözüm üretebiliyorum. Bunun icin saniyorum tehlikeli yöntemleri kullanabilirsiniz. 🙂 Buda; eger ID icin müracaat eden sinifi yani cagirani tespit edebilirseniz o zaman ufak bir oynamayla istediginiz cözümü saniyorum ki uygulayabilirsiniz.

StackFrame frm = new StackFrame(skipFrames: 1, needFileInfo: true);
string method = frm.GetMethod().Name;
string className = frm.GetMethod().DeclaringType.Name;
string decType = frm.GetMethod().DeclaringType.ToString();
string fileName = frm.GetFileName();

Bu yukaridaki kodlarla uygulamanizin ProductId'yi nerede cagiriyorsa oradaki kisminda cagirana ait bilgileri alip gerekli degisikligi yapmak fikri olabilir mi bilmiyorum. Stabil bir cözüm degil ama yinede fikir vermesi acisindan yazmak istedim.

Saygilarimla

KerimCETINBAS

backbone selam hocam;

Evet kesinlikle sorun dedığiniz gibi

public abstract class AggregateRoot<TId, TIdType> :
    Entity<TId>  where TId : AggregateRootId<TIdType> {
    
    public new AggregateRootId<TIdType> Id { get; protected set; }
    protected AggregateRoot(TId id) : base(id) {
        Id = id;
    }

    protected AggregateRoot() { }
}

burdaki public new AggregateRootId<TIdType> Id { get; protected set; }

ikinci set edilmeyen yeni bir shadow property yaratilmasına sebep oluyor.

https://stackoverflow.com/questions/78027831/troubleshooting-foreign-key-relationships-in-ef-core-with-strongly-typed-ids-in burdada hemen hemen ayni codebaseile soyle bir cozum uretmisler

edit: bu yöntem bende çalışmadı

public abstract class AggregateRoot<TId, TIdType> :
    Entity<TId>  where TId : AggregateRootId<TIdType> {
    
    // redundant fieldi ortadan kaldir
    // public new AggregateRootId<TIdType> Id { get; protected set; }
    protected AggregateRoot(TId id) : base(id) {
        Id = id;
    }

    protected AggregateRoot() { }
}

aggregateRoot'u miras alan sınıftada Id yı explicit olarak set ederek çözülebilir gibi duruyor.

public class Product: AggregateRoot<ProductId, Guid>
{
    public Product(
        ProductId id) : base(id)
    {
       // Id yi explicit olarak set etmek
       Id = id;
    }
}

ama mumkunse domain yapisini degistirmeden EntityFrameworkun AggregateRootId<Guid> yerıne ProductId kabul etmesini sağlamak istiyordum ama ef core 8 de reflection apideki değişiklikle olusan bir bug sanırsam. Bunla ilgili bir sürü issue var ama çoğu wontfix ile labellenmiş.

bir kaç gün içinde içime sinen bi çözüm üretemezsem dapper geçmeyi planlıyorum. Şuan duzgun bi database migration tool arıyorum. Plain sql ile version <Up> <Down> destekleyen bir tool varsa önerilere açığım.

şöyle bir şey buldum https://github.com/pressly/goose basit yorum satırı annotationları ile version up ve down yapısı eklenebiliyor

-- +goose Up
CREATE TABLE post (
    id int NOT NULL,
    title text,
    body text,
    PRIMARY KEY(id)
);

-- +goose Down
DROP TABLE post;

ama projeye doğrudan olmasa bile birde exstradan go bağımlığı eklemeye çekiniyorum biraz

KerimCETINBAS

backbone

Merhaba hocam;

AggregateRoot base classını biraz değiştirdim

public abstract class AggregateRoot<TId> :
    Entity<TId> where TId: notnull {
    protected AggregateRoot(TId id) : base(id) {
        Id = id;
    }
    
    protected AggregateRoot() {}
}

Suan baska bi aggregate bunu referans gösterirse side effecte acık kalmaz dimi.

backbone

KerimCETINBAS hocam Abstract'in kullanimi itibariyle "acik" kelimesine karsi cok dikkatli olmaniz gerekiyor.
Ben bu sekilde bir "Abstract Factory" + "Strategy" Pattern ile gelistirmeler yaptim. Yalniz bahsettigim cok büyük devasa yazilimlar. Ve sadece bu bahsettiginiz her ne sekilde olursa olsun "acik" konusu yüzünden Abstract Factory'nin yapisini Interface'e cevirmek zorunda kaldim. Ardindan Strategy tasarimi da yine ufak degisiklerle implementasyonlarini etkilemeden taban degisimi gerceklestirdim.

Burada dikkatli olunmasi gereken konu Abstract'in kontrollü bir sekilde devir edilmesini saglamak. Yani biraz daha örnek vermem gerekirse; kendi Id sistemim ve Abstract'in tekbasina degistiremeyecegi sekilde Multithreading ile icten sarmaladim. Bagimliliklarini Abstract'a degil Strategy'e ve oradanda configürasyon sistemine sifreli sekilde bagladim. Ve ORM'i kendi kodlamamla dolayisiyla da sorunsuz, kontrollü bir mekanizma ortaya cikardim. A bu arada tam anlamiyla bir Infinite State Machine'di.

Burada yukaridaki önerim aslinda size uygun degildi farkindayim ama en azindan baslangic icin giris yapmak istedim.

Diger yandan projenize uygun gercek cözüm önerisi olarak;

Her C# yazilimcisinin bildigi gibi bir sinifin bir babasi olur ki bu da miras yolunda bir Class'i teskil eder. Ancak bircok amcasi olabilir ki bu da Interface'dir. Iki seceneginiz var diye düsünüyorum.

1 - Bir Abstract sinif olusturun ve bu Abstract sinifta Id verme isini kendiniz üstlenin diyecegim ama bunu söylemeye dilim varmiyor, Cok is olabilir gibi geldi bana. Bu teklifim icin üzgünüm.

2 - Hemen bir Strategy Pattern ile AggregateRoot constructor'ina Id alacagi duruma müdahale edin ya da edilebilir mi bilmiyorum. Bu Strategy tanimlamasini Dependency Injection ile sinif bazinda bildiginiz gibi tanimlayin.

Ardindan asagidaki ksimi iptal edin.

protected AggregateRoot(TId id) : base(id) {
        Id = id; // <<<< ------ Bu kisim iptal
    }

Kugulama yoluyla gittigim icin eger bir yerde hata yapiyorsam kusurumu bagislayin lütfen. Asagidaki kisimda örneklendirme mevcut inceleyin yanlisim varsa düzelteyim ya da üstüne konusalim.

Interface :

    public interface IGetIdStrategy
    {
        TId Process<TId>(TId parameter) where TId : AggregateRootId<TIdType>;
    }

Karsilayan Class :

public class GetIdStrategy
{
    private IGetIdStrategy _strategy;

public GetIdStrategy(IGetIdStrategy strategy)
{
    _strategy = strategy;
}

public TId Process<TId>(TId parameter) where TId : AggregateRootId<TIdType>
{
    return _strategy.Process(parameter);
}
}

Ve degistirilmis AggregateRoot Class:

    public abstract class AggreagateRoot<TId, TIdType> : Entity<TId>
    where TId : AggregateRootId<TIdType>
    {
        private GetIdStrategy _idStrategy;

    public new AggregateRootId<TIdType> Id { get; protected set; }
    protected AggregateRoot(TId id) : base(id)
    {
        //Id = id;
        _idStrategy = new GetIdStrategy(new IdFactory());
        Id = _idStrategy.Process(id);
    }
}

Burada GetIdStrategy sinifi size sizin istediginiz türden ve istediginiz siniftan bir id döndürecek mantik olarak. Kodlarimda hata veriyor cünkü proje bende yok ve bilemiyorum nasil hata kontrolü yapacagimi. Ancak düsünce acisindan size fikir vermek istedim.

Saygilarimla