Entity Framework Core error not seen before Class.TempProperty is of type 'object' which is not supported by current database provider

Question

I am using Entity Framework Core code-first with fluent API entity configurations, in an ASP .NET MVC Core application. My code currently compiles, but when I run add-migration in the Package Manager Console, it gives the error below:

The property 'Exam.TempId' is of type 'object' which is not supported by current database provider. Either change the property CLR type or manually configure the database type for it.

Searching Google for this error yields no results. Can anybody here help please?

"Exam" is a class in my domain model, but it doesn't have a "TempId" property so I guess that's something that Entity Framework is adding. It does have an "Id" property, but the type is int, not object.

I'll start by sharing the Exam class and the Exam configuration class. I can share more code if required. I'd be really grateful for any advice you can provide to resolve the problem.

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;

namespace MySite.Core.Models
{
    public class Exam : ActivatableEntity
    {
        private int _numberOfQuestionsToBeAttempted;

        private Exam()
        {
            Topics = new Collection<Topic>();
        }

        public Exam(IUser createdByUser,
            string name,
            string description,
            double timeAllowedInMinutes,
            bool shuffleTopicsTogether = true) :
            base(createdByUser)
        {
            Name = name;
            Description = description;
            Topics = new Collection<Topic>();
            TimeAllowedInMinutes = timeAllowedInMinutes;
            ShuffleTopicsTogether = shuffleTopicsTogether;
        } 

        public string Name { get; private set; }

        public string Description { get; private set; }

        public double TimeAllowedInMinutes { get; private set; }

        public bool ShuffleTopicsTogether { get; private set; }

        public IEnumerable<Question> PossibleQuestions
        {
            get
            {
                return Topics.SelectMany(t => t.PossibleQuestions);
            }
        }

        public int NumberOfQuestionsToBeAttempted
        {
            get
            {
                if (_numberOfQuestionsToBeAttempted != 0) return _numberOfQuestionsToBeAttempted;
                foreach (Topic topic in Topics)
                {
                    _numberOfQuestionsToBeAttempted += topic.NumberOfQuestionsToBeAttempted;
                }
                return _numberOfQuestionsToBeAttempted;
            }
        }

        public IEnumerable<Topic> Topics { get;  }

        public void Update(IUser updatedByUser, string name, string description, double timeAllowedInMinutes, bool shuffleTopicsTogether = true)
        {
            Name = name ?? throw new ArgumentNullException(nameof(name));
            Description = description;
            TimeAllowedInMinutes = timeAllowedInMinutes;
            ShuffleTopicsTogether = shuffleTopicsTogether;
            Update(updatedByUser);
        }
    }
}

Exam configuration class

using MySite.Core.Models;
using Microsoft.EntityFrameworkCore.Metadata;
using Microsoft.EntityFrameworkCore.Metadata.Builders;

namespace MySite.Persistence.EntityConfiguration
{
    public class ExamConfiguration
    {
        public ExamConfiguration(EntityTypeBuilder<Exam> entityBuilder)
        {
            entityBuilder.HasKey(e => e.Id);

            entityBuilder.HasOne(e => (ApplicationUser)e.CreatedByUser)
                .WithMany()
                .HasForeignKey(e => e.CreatedByUserId)
                .OnDelete(DeleteBehavior.SetNull);

            entityBuilder.HasOne(e => (ApplicationUser)e.LastUpdatedByUser)
                .WithMany()
                .HasForeignKey(e => e.LastUpdatedByUserId)
                .OnDelete(DeleteBehavior.SetNull);

            entityBuilder.Property(e => e.Name).IsRequired().HasMaxLength(50);

            entityBuilder.Property(e => e.Description).IsRequired().HasMaxLength(250);

            entityBuilder.HasMany(e => e.Topics)
                .WithOne(t => t.Exam).OnDelete(DeleteBehavior.Cascade);
        }
    }
}

As requested by posters, I'm adding the code for the base classes below:

using System;

namespace MySite.Core.Models
{
    public abstract class ActivatableEntity :
        UpdatableCreatableEntity,
        IActivatable
    {
        protected ActivatableEntity() { }

        protected ActivatableEntity(IUser createdByUser) : base(createdByUser) { }

        public int? LastActivatedByUserId { get; private set; }
        public IUser LastActivatedByUser { get; private set; }
        public DateTime? WhenLastActivated { get; private set; }
        public int? LastDeactivatedByUserId { get; private set; }
        public IUser LastDeactivatedByUser { get; private set; }
        public DateTime? WhenLastDeactivated { get; private set; }
        public bool IsActive { get; private set; }

        protected virtual void Activate(IUser activatedByUser)
        {
            LastActivatedByUser = activatedByUser ?? throw new ArgumentNullException(nameof(activatedByUser));

            LastActivatedByUserId = activatedByUser.Id;
            WhenLastActivated = DateTime.Now;
            IsActive = true;
        }

        protected virtual void Deactivate(IUser deactivatedByUser)
        {
            LastDeactivatedByUser = deactivatedByUser ?? throw new ArgumentNullException(nameof(deactivatedByUser));

            LastDeactivatedByUserId = deactivatedByUser.Id;
            WhenLastDeactivated = DateTime.Now;
            IsActive = false;
        }
    }

    public abstract class UpdatableCreatableEntity :
        CreatableEntity,
        IUpdatable
    {
        protected UpdatableCreatableEntity() { }

        protected UpdatableCreatableEntity(IUser createdByUser) : base(createdByUser) { }

        public int? LastUpdatedByUserId { get; private set; }
        public IUser LastUpdatedByUser { get; private set; }
        public DateTime? WhenLastUpdated { get; private set; }

        protected virtual void Update(IUser updatedByUser)
        {
            LastUpdatedByUser = updatedByUser ?? throw new ArgumentNullException(nameof(updatedByUser));
            LastUpdatedByUserId = updatedByUser.Id;
            WhenLastUpdated = DateTime.Now;
        }
    }

    public abstract class CreatableEntity :
        IIdentifiable,
        ICreatable
    {
        protected CreatableEntity() { }

        protected CreatableEntity(IUser createdByUser)
        {
            CreatedByUser = createdByUser ?? throw new ArgumentNullException(nameof(createdByUser));
            CreatedByUserId = createdByUser.Id;
            WhenCreated = DateTime.Now;
        }

        public int Id { get; private set; }
        public int? CreatedByUserId { get; private set; }
        public DateTime WhenCreated { get; private set; }
        public IUser CreatedByUser { get; private set; }
    }
}

Answer 1

I faced same problem and it confused me a lot. But luckily I was using version control, so I was able to trace reasons of the issue.

For me it was many-to-many relation entity model with constructor that assigns values to fields. I was relying to Visual Studio to generate properties for me automatically, and VS did poor job not detecting type of the property that later became a key.

VS created property of type object, which is too generic and hardly could be translated into underlying database abstractions. Hence the error.

I agree, quite not descriptive, hope they will fix that in future versions.

So try to search for properties of object type and check, are they used as keys, if yes, try to replace them with specific types supported by your database provider.

Reported error for developers: #9817.