Mysql 基础提供程序不支持类型'；datetimeoffset'；

我正在尝试使用EF6将我的API与MySQL集成。 我已经安装了包MySql.Data.Entity（版本6.9.7）

最初，我使用Sql Server，因此日期字段的映射使用DateTimeOffSet类型。但是，在使用MySql时，我遇到了这种类型的问题，所以我将其改为DateTime。迁移运行成功，在MySql中创建了数据库，但在日志末尾显示了一个错误：

PM> Update-Database -StartUpProjectName WMoney.WebApi -Verbose
Using StartUp project 'WMoney.WebApi'.
Using NuGet project 'WMoney.Persistence.EntityFramework'.
Specify the '-Verbose' flag to view the SQL statements being applied to the target database.
Target database is: 'wmoney' (DataSource: localhost, Provider: MySql.Data.MySqlClient, Origin: Configuration).
No pending explicit migrations.
System.ArgumentException: The underlying provider does not support the type 'datetimeoffset'.
   at MySql.Data.MySqlClient.MySqlProviderManifest.GetEdmType(TypeUsage storeType)
   at System.Data.Entity.Migrations.Infrastructure.EdmModelDiffer.BuildColumnModel(EdmProperty property, ModelMetadata modelMetadata, IDictionary`2 annotations)
   at System.Data.Entity.Migrations.Infrastructure.EdmModelDiffer.BuildAlterColumnOperation(String table, EdmProperty targetProperty, ModelMetadata targetModelMetadata, EdmProperty sourceProperty, ModelMetadata sourceModelMetadata)
   at System.Data.Entity.Migrations.Infrastructure.EdmModelDiffer.<FindAlteredColumns>b__24a(<>f__AnonymousType2c`2 <>h__TransparentIdentifier242)
   at System.Linq.Enumerable.WhereSelectEnumerableIterator`2.MoveNext()
   at System.Collections.Generic.List`1..ctor(IEnumerable`1 collection)
   at System.Linq.Enumerable.ToList[TSource](IEnumerable`1 source)
   at System.Data.Entity.Migrations.Infrastructure.EdmModelDiffer.Diff(ModelMetadata source, ModelMetadata target, Lazy`1 modificationCommandTreeGenerator, MigrationSqlGenerator migrationSqlGenerator, String sourceModelVersion, String targetModelVersion)
   at System.Data.Entity.Migrations.Infrastructure.EdmModelDiffer.Diff(XDocument sourceModel, XDocument targetModel, Lazy`1 modificationCommandTreeGenerator, MigrationSqlGenerator migrationSqlGenerator, String sourceModelVersion, String targetModelVersion)
   at System.Data.Entity.Migrations.DbMigrator.IsModelOutOfDate(XDocument model, DbMigration lastMigration)
   at System.Data.Entity.Migrations.DbMigrator.Upgrade(IEnumerable`1 pendingMigrations, String targetMigrationId, String lastMigrationId)
   at System.Data.Entity.Migrations.Infrastructure.MigratorLoggingDecorator.Upgrade(IEnumerable`1 pendingMigrations, String targetMigrationId, String lastMigrationId)
   at System.Data.Entity.Migrations.DbMigrator.UpdateInternal(String targetMigration)
   at System.Data.Entity.Migrations.DbMigrator.<>c__DisplayClassc.<Update>b__b()
   at System.Data.Entity.Migrations.DbMigrator.EnsureDatabaseExists(Action mustSucceedToKeepDatabase)
   at System.Data.Entity.Migrations.Infrastructure.MigratorBase.EnsureDatabaseExists(Action mustSucceedToKeepDatabase)
   at System.Data.Entity.Migrations.DbMigrator.Update(String targetMigration)
   at System.Data.Entity.Migrations.Infrastructure.MigratorBase.Update(String targetMigration)
   at System.Data.Entity.Migrations.Design.ToolingFacade.UpdateRunner.Run()
   at System.AppDomain.DoCallBack(CrossAppDomainDelegate callBackDelegate)
   at System.AppDomain.DoCallBack(CrossAppDomainDelegate callBackDelegate)
   at System.Data.Entity.Migrations.Design.ToolingFacade.Run(BaseRunner runner)
   at System.Data.Entity.Migrations.Design.ToolingFacade.Update(String targetMigration, Boolean force)
   at System.Data.Entity.Migrations.UpdateDatabaseCommand.<>c__DisplayClass2.<.ctor>b__0()
   at System.Data.Entity.Migrations.MigrationsDomainCommand.Execute(Action command)
The underlying provider does not support the type 'datetimeoffset'.

我的类谁调用数据库 该错误已在行中发生： var existentUser=await_userRepository.AsQueryable（）.GetByEmail（电子邮件）

名称空间WMoney.Core
{
公共类UserCore:IUserCore
{
公共IUserRepository\u用户存储库；
公共用户核心（IWMoneyContext-wMoneyContext）
{
_userRepository=wMoneyContext.userRepository；
}
公共异步任务CreateUserAsync（字符串电子邮件、字符串密码）
{
var existentUser=await_userRepository.AsQueryable（）.GetByEmail（电子邮件）；
if（existentUser！=null）
{
抛出新的DuplicateWaitObjectException（）；
}
var user=新用户
{ 
电子邮件=电子邮件，
密码=密码
};
await\u userRepository.AddAsync（user，true）；
返回用户；
}
公共异步任务CheckUserAsync（字符串电子邮件、字符串密码）
{
var user=await\u userRepository.AsQueryable（）.GetByEmail（电子邮件）；
如果（用户！=null）
{
if（user.Password==密码）
{
返回true；
}
其他的
{
返回false；
}
}
其他的
{
抛出新的ArgumentException（string.Format（“没有用户使用电子邮件“{0}”，email））；
}
}
}
}

你能展示一下你的映射、你的上下文构造函数和一个有这个问题的类吗？我用你要求的信息更新了这篇文章。

MY CONTEXT CLASS:

namespace WMoney.Persistence.EntityFramework
{
    [DbConfigurationType(typeof(MySql.Data.Entity.MySqlEFConfiguration))]
    public class WMoneyContext : DbContext, IWMoneyContext
    {
        public WMoneyContext()
            : base("WMoneyConnectionString")
            {

            }

        public IUserRepository UserRepository
        { 
            get { return new UserRepository(this); }
        }

        public DbSet<Account> Accounts { get; set; }
        public DbSet<Category> Categories { get; set; }
        public DbSet<Transaction> Transactions { get; set; }
        public DbSet<TransactionType> TransactionTypes { get; set; }
        public DbSet<User> Users { get; set; }

        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            //base.OnModelCreating(modelBuilder);

            modelBuilder.Entity<Account>()
                .HasKey(a => a.AccountId)
                .Map(a => a.ToTable("TbAccount", "dbo"));

            modelBuilder.Entity<Account>()
                .HasRequired(a => a.User)
                .WithMany(a => a.Accounts)
                .HasForeignKey(a => a.UserId)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Category>()
                .HasKey(a => a.CategoryId)
                .Map(a => a.ToTable("TbCategory", "dbo"));

            modelBuilder.Entity<Category>()
                .HasRequired(a => a.User)
                .WithMany(a => a.Categories)
                .HasForeignKey(a => a.UserId)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Transaction>()
                .HasKey(a => a.TransactionId)
                .Map(a => a.ToTable("TbTransaction", "dbo"));

            modelBuilder.Entity<Transaction>()
                .HasRequired(a => a.Account)
                .WithMany(a => a.Transactions)
                .HasForeignKey(a => a.AccountId)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Transaction>()
                .HasRequired(a => a.Category)
                .WithMany(a => a.Transactions)
                .HasForeignKey(a => a.CategoryId)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Transaction>()
                .HasRequired(a => a.TransactionType)
                .WithMany(a => a.Transactions)
                .HasForeignKey(a => a.TransactionTypeId)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<TransactionType>()
                .HasKey(a => a.TransactionTypeId)
                .Map(a => a.ToTable("TbTransactionType", "dbo"));

            modelBuilder.Entity<User>()
                .HasKey(a => a.UserId)
                .Map(a => a.ToTable("TbUser", "dbo"));
        }



    }
}

namespace WMoney.Persistence.Model
{
    public class Transaction
    {
        public int TransactionId { get; set; }

        public int TransactionTypeId { get; set; }

        public DateTime Created { get; set; }

        public DateTime Date { get; set; }

        public int CategoryId { get; set; }

        public int AccountId { get; set; }

        public decimal Value { get; set; }

        [StringLength(200)]
        public string Description { get; set; }

        public virtual TransactionType TransactionType { get; set; }

        public virtual Category Category { get; set; }

        public virtual Account Account { get; set; }
    }
}

namespace WMoney.Core
{
    public class UserCore : IUserCore
    {
        public IUserRepository _userRepository;

        public UserCore(IWMoneyContext wMoneyContext)
        {
            _userRepository = wMoneyContext.UserRepository;
        }

        public async Task<User> CreateUserAsync(string email, string password)
        {
            var existentUser = await _userRepository.AsQueryable().GetByEmail(email);

            if (existentUser != null)
            {
                throw new DuplicateWaitObjectException();
            }

            var user = new User 
            { 
                Email = email,
                Password = password
            };

            await _userRepository.AddAsync(user, true);

            return user;
        }

        public async Task<bool> CheckUserAsync(string email, string password)
        {
            var user = await _userRepository.AsQueryable().GetByEmail(email);

            if (user != null)
            {
                if (user.Password == password)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
            else
            {
                throw new ArgumentException(string.Format("There's no user with email '{0}'", email));
            }
        }
    }
}