Entity Framework Core: `SqlNullValueException: Data is Null.` 如何排查？

Question

我在 ASP.NET Core 應用程序和控制器操作中使用 Entity Framework Core，我沒有對工作代碼或數據庫進行任何更改，但我不知道 Entity Framework Core 執行的查詢是什么。

控制器動作：

[HttpGet]
// GET: Administration/Companies
public async Task<ActionResult> Index()
{
    var users = await UserManager.Users.ToListAsync();

    var companyEditVMs = await DB.Companies
    .OrderBy(company => company.CompanyId == 1 
        ? "_" + company.CompanyName 
        : company.CompanyName
    )
    Select(a => new CompanyEditVM(HttpContext, a, users.Where(b => b.CompanyId == a.CompanyId)))
    .ToListAsync();

    return View(companyEditVMs);
}

痕跡

SqlNullValueException: Data is Null. This method or property cannot be called on Null values.
System.Data.SqlClient.SqlBuffer.get_String()
System.Data.SqlClient.SqlDataReader.GetString(int i)
lambda_method(Closure , DbDataReader )
Microsoft.EntityFrameworkCore.Storage.Internal.TypedRelationalValueBufferFactory.Create(DbDataReader dataReader)
Microsoft.EntityFrameworkCore.Query.Internal.AsyncQueryingEnumerable<T>+AsyncEnumerator.BufferlessMoveNext(DbContext _, bool buffer, CancellationToken cancellationToken)
Microsoft.EntityFrameworkCore.SqlServer.Storage.Internal.SqlServerExecutionStrategy.ExecuteAsync<TState, TResult>(TState state, Func<DbContext, TState, CancellationToken, Task<TResult>> operation, Func<DbContext, TState, CancellationToken, Task<ExecutionResult<TResult>>> verifySucceeded, CancellationToken cancellationToken)
Microsoft.EntityFrameworkCore.Query.Internal.AsyncQueryingEnumerable<T>+AsyncEnumerator.MoveNext(CancellationToken cancellationToken)
Microsoft.EntityFrameworkCore.Query.Internal.AsyncLinqOperatorProvider+ExceptionInterceptor<T>+EnumeratorExceptionInterceptor.MoveNext(CancellationToken cancellationToken)
System.Linq.AsyncEnumerable.Aggregate_<TSource, TAccumulate, TResult>(IAsyncEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> accumulator, Func<TAccumulate, TResult> resultSelector, CancellationToken cancellationToken) in Aggregate.cs
KYC.Core.Areas.Commercial.Controllers.CompaniesController.Index() in CompaniesController.cs
-
        [HttpGet]
        // GET: Administration/Companies
        public async Task<ActionResult> Index()
        {
            var users = await UserManager.Users.ToListAsync();

            var companyEditVMs = await DB.Companies
                .OrderBy(company => company.CompanyId == 1 
                    ? "_" + company.CompanyName 
                    : company.CompanyName
                )
                .Select(a => new CompanyEditVM(HttpContext, a, users.Where(b => b.CompanyId == a.CompanyId)))
                .ToListAsync();
lambda_method(Closure , object )
Microsoft.Extensions.Internal.ObjectMethodExecutorAwaitable+Awaiter.GetResult()
Microsoft.AspNetCore.Mvc.Internal.ActionMethodExecutor+TaskOfActionResultExecutor.Execute(IActionResultTypeMapper mapper, ObjectMethodExecutor executor, object controller, object[] arguments)
System.Threading.Tasks.ValueTask<TResult>.get_Result()

我什至試着做var companies = await DB.Companies.ToListAsync() 。 我有完全相同的例外。

也許我希望能夠獲取 EF Core 執行的查詢以手動執行此操作，以便我可以嘗試找出查詢出了什么問題。

我想知道可能發生了什么。 特別是因為其他實體（如用戶或國家/地區）仍然可以從數據庫中獲取。

知道如何解決實際的潛在問題嗎？

[編輯]

“代碼”中唯一真正改變的是 nuget 引用，我基本上升級了幾乎所有東西，盡管它沒有破壞代碼中的引用，它似乎改變了 EF Core 以某種方式（瘋狂猜測）解釋數據庫的方式。

我確實將我的 git 存儲庫重置到了 nuget 包更新發生並且一切正常之前的點。，。 然后我決定將 EntityFrameworkCore 從 2.0.2 更新到 2.2.4（也嘗試使用 2.2.0 並最終得到相同的結果）並且問題再次發生......不確定 2.0.2 和 2.2 之間發生了什么變化。 0 觸發此異常（但模型相同，只是更改了 EF Core 版本）...

這是實體定義，它似乎是使用數據庫表/模式中的工具自動生成的：

    [Table("T_Companies")]
    public partial class Company : INotifyPropertyChanging, INotifyPropertyChanged
    {
        public override string ToString()
        {
            return CompanyId + " " + CompanyName;
        }

        private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(string.Empty);

        private int _CompanyId;

        private string _CompanyName;

        private int _CompanyTypeId;

        private int _CountryId;

        private string _CompanyVatNumber;

        private string _CompanyStreetAddress;

        private string _CompanyZipCode;

        private string _CompanyCity;

        private string _ContactLastName;

        private string _ContactFirstName;

        private bool? _Active;

        private int? _AccountId;

        private string _CallbackSalt;

        private int? _UserSpaceId;

        private string _Login;

        private string _Pwd;

        private bool _IsTechnicalAccount;

        private DateTime? _StatusDate;

        private int _BankStatusCode;

        private string _PivotalAccount;

        private CompanyType _CompanyType;

        private Country _Country;

        private bool _IsKycIdSent;

        #region Extensibility Method Definitions
        partial void OnLoaded();
        partial void OnCreated();
        partial void OnCompanyIdChanging(int value);
        partial void OnCompanyIdChanged();
        partial void OnCompanyNameChanging(string value);
        partial void OnCompanyNameChanged();

        partial void OnCompanyCityChanging(string value);
        partial void OnCompanyCityChanged();
        partial void OnCompanyZipCodeChanging(string value);
        partial void OnCompanyZipCodeChanged();
        partial void OnContactLastNameChanging(string value);
        partial void OnContactLastNameChanged();
        partial void OnActiveChanging(bool? value);
        partial void OnActiveChanged();
        partial void OnCompanyTypeIdChanging(int value);
        partial void OnCompanyTypeIdChanged();
        partial void OnCountryIdChanging(int value);
        partial void OnCountryIdChanged();
        partial void OnContactFirstNameChanging(string value);
        partial void OnContactFirstNameChanged();
        partial void OnCompanyVatNumberChanging(string value);
        partial void OnCompanyVatNumberChanged();
        partial void OnCompanyStreetAddressChanged();
        partial void OnCompanyStreetAddressChanging(string value);
        partial void OnAccountIdChanging(int? value);
        partial void OnAccountIdChanged();
        partial void OnCallbackSaltChanging(string value);
        partial void OnCallbackSaltChanged();
        partial void OnUserSpaceIdChanging(int? value);
        partial void OnUserSpaceIdChanged();
        partial void OnLoginChanging(string value);
        partial void OnLoginChanged();
        partial void OnPwdChanging(string value);
        partial void OnPwdChanged();
        partial void OnIsTechnicalAccountChanging(bool value);
        partial void OnIsTechnicalAccountChanged();
        partial void OnStatusDateChanging(DateTime? value);
        partial void OnStatusDateChanged();
        partial void OnBankStatusCodeChanging(int value);
        partial void OnBankStatusCodeChanged();
        partial void OnPivotalAccountChanging(string value);
        partial void OnPivotalAccountChanged();
        partial void OnIsKycIdSentChanging(bool value);
        partial void OnIsKycIdSentChanged();

        #endregion

        public Company()
        {
            OnCreated();
        }

        [Key, Column("CompanyId"), DatabaseGenerated(DatabaseGeneratedOption.Identity)]
        public int CompanyId
        {
            get => _CompanyId;
            set
            {
                if (_CompanyId != value)
                {
                    OnCompanyIdChanging(value);
                    SendPropertyChanging();
                    _CompanyId = value;
                    SendPropertyChanged("CompanyId");
                    OnCompanyIdChanged();
                }
            }
        }

        [DataType(DataType.Text), StringLength(1024), Column("CompanyName"), Required]
        public string CompanyName
        {
            get => _CompanyName;
            set
            {
                if (_CompanyName != value)
                {
                    OnCompanyNameChanging(value);
                    SendPropertyChanging();
                    _CompanyName = value;
                    SendPropertyChanged("CompanyName");
                    OnCompanyNameChanged();
                }
            }
        }

        [Column("CompanyTypeId"), Required]
        public int CompanyTypeId
        {
            get => _CompanyTypeId;
            set
            {
                if (_CompanyTypeId != value)
                {
                    OnCompanyTypeIdChanging(value);
                    SendPropertyChanging();
                    _CompanyTypeId = value;
                    SendPropertyChanged("CompanyTypeId");
                    OnCompanyTypeIdChanged();
                }
            }
        }


        [Column("CountryId"), Required]
        public int CountryId
        {
            get => _CountryId;
            set
            {
                if (CountryId != value)
                {
                    OnCountryIdChanging(value);
                    SendPropertyChanging();
                    _CountryId = value;
                    SendPropertyChanged("CountryId");
                    OnCountryIdChanged();
                }
            }
        }


        [DataType(DataType.Text), StringLength(100), Column("CompanyCity"), Required]
        public string CompanyCity
        {
            get => _CompanyCity;
            set
            {
                if (_CompanyCity != value)
                {
                    OnCompanyCityChanging(value);
                    SendPropertyChanging();
                    _CompanyCity = value;
                    SendPropertyChanged("CompanyCity");
                    OnCompanyCityChanged();
                }
            }
        }

        [DataType(DataType.Text), StringLength(100), Column("CompanyStreetAddress"), Required]
        public string CompanyStreetAddress
        {
            get => _CompanyStreetAddress;
            set
            {
                if (_CompanyStreetAddress != value)
                {
                    OnCompanyStreetAddressChanging(value);
                    SendPropertyChanging();
                    _CompanyStreetAddress = value;
                    SendPropertyChanged("CompanyStreetAddress");
                    OnCompanyStreetAddressChanged();
                }
            }
        }

        [DataType(DataType.Text), StringLength(30), Column("CompanyVatNumber"), Required]
        public string CompanyVatNumber
        {
            get => _CompanyVatNumber;
            set
            {
                if (_CompanyVatNumber != value)
                {
                    OnCompanyVatNumberChanging(value);
                    SendPropertyChanging();
                    _CompanyVatNumber = value;
                    SendPropertyChanged("CompanyVatNumber");
                    OnCompanyVatNumberChanged();
                }
            }
        }


        [DataType(DataType.Text), StringLength(10), Column("CompanyZipCode"), Required]
        public string CompanyZipCode
        {
            get => _CompanyZipCode;
            set
            {
                if (_CompanyZipCode != value)
                {
                    OnCompanyZipCodeChanging(value);
                    SendPropertyChanging();
                    _CompanyZipCode = value;
                    SendPropertyChanged("CompanyZipCode");
                    OnCompanyZipCodeChanged();
                }
            }
        }


        [DataType(DataType.Text), StringLength(1024), Column("ContactLastName"), Required]
        public string ContactLastName
        {
            get => _ContactLastName;
            set
            {
                if (_ContactLastName != value)
                {
                    OnContactLastNameChanging(value);
                    SendPropertyChanging();
                    _ContactLastName = value;
                    SendPropertyChanged("ContactLastName");
                    OnContactLastNameChanged();
                }
            }
        }

        [DataType(DataType.Text), StringLength(1024), Column("ContactFirstName"), Required]
        public string ContactFirstName
        {
            get => _ContactFirstName;
            set
            {
                if (_ContactFirstName != value)
                {
                    OnContactFirstNameChanging(value);
                    SendPropertyChanging();
                    _ContactFirstName = value;
                    SendPropertyChanged("ContactFirstName");
                    OnContactFirstNameChanged();
                }
            }
        }

        [Column("Active"), Required]
        public bool? Active
        {
            get => _Active;
            set
            {
                if (_Active != value)
                {
                    OnActiveChanging(value);
                    SendPropertyChanging();
                    _Active = value;
                    SendPropertyChanged("Active");
                    OnActiveChanged();
                }
            }
        }

        [Column("AccountId")]
        public int? AccountId
        {
            get => _AccountId;
            set
            {
                if (_AccountId != value)
                {
                    OnAccountIdChanging(value);
                    SendPropertyChanging();
                    _AccountId = value;
                    SendPropertyChanged("AccountId");
                    OnAccountIdChanged();
                }
            }
        }

        [DataType(DataType.Text), StringLength(1024), Column("CallbackSalt")]
        public string CallbackSalt
        {
            get => _CallbackSalt;
            set
            {
                if (_CallbackSalt != value)
                {
                    OnCallbackSaltChanging(value);
                    SendPropertyChanging();
                    _CallbackSalt = value;
                    SendPropertyChanged("CallbackSalt");
                    OnCallbackSaltChanged();
                }
            }
        }

        [Column("UserSpaceId")]
        public int? UserSpaceId
        {
            get => _UserSpaceId;
            set
            {
                if (_UserSpaceId != value)
                {
                    OnUserSpaceIdChanging(value);
                    SendPropertyChanging();
                    _UserSpaceId = value;
                    SendPropertyChanged("UserSpaceId");
                    OnUserSpaceIdChanged();
                }
            }
        }

        [DataType(DataType.Text), StringLength(1024), Column("Login")]
        public string Login
        {
            get => _Login;
            set
            {
                if (_Login != value)
                {
                    OnLoginChanging(value);
                    SendPropertyChanging();
                    _Login = value;
                    SendPropertyChanged("Login");
                    OnLoginChanged();
                }
            }
        }

        [DataType(DataType.Text), StringLength(1024), Column("Pwd")]
        public string Pwd
        {
            get => _Pwd;
            set
            {
                if (_Pwd != value)
                {
                    OnPwdChanging(value);
                    SendPropertyChanging();
                    _Pwd = value;
                    SendPropertyChanged("Pwd");
                    OnPwdChanged();
                }
            }
        }

        [Column("IsTechnicalAccount"), Required]
        public bool IsTechnicalAccount
        {
            get => _IsTechnicalAccount;
            set
            {
                if (_IsTechnicalAccount != value)
                {
                    OnIsTechnicalAccountChanging(value);
                    SendPropertyChanging();
                    _IsTechnicalAccount = value;
                    SendPropertyChanged("IsTechnicalAccount");
                    OnIsTechnicalAccountChanged();
                }
            }
        }

        [DataType(DataType.DateTime), Column("StatusDate")]
        public DateTime? StatusDate
        {
            get => _StatusDate;
            set
            {
                if (_StatusDate != value)
                {
                    OnStatusDateChanging(value);
                    SendPropertyChanging();
                    _StatusDate = value;
                    SendPropertyChanged("StatusDate");
                    OnStatusDateChanged();
                }
            }
        }

        [Column("BankStatusCode")]
        public int BankStatusCode
        {
            get => _BankStatusCode;
            set
            {
                if (_BankStatusCode != value)
                {
                    OnBankStatusCodeChanging(value);
                    SendPropertyChanging();
                    _BankStatusCode = value;
                    SendPropertyChanged("BankStatusCode");
                    OnBankStatusCodeChanged();
                }
            }
        }

        [DataType(DataType.Text), StringLength(255), Column("PivotalAccount")]
        public string PivotalAccount
        {
            get => _PivotalAccount;
            set
            {
                if (_PivotalAccount != value)
                {
                    OnPivotalAccountChanging(value);
                    SendPropertyChanging();
                    _PivotalAccount = value;
                    SendPropertyChanged("PivotalAccount");
                    OnPivotalAccountChanged();
                }
            }
        }

        public List<Resultat> Resultats { get; set; }

        public CompanyType CompanyType
        {
            get => _CompanyType;
            set
            {
                var previousValue = _CompanyType;
                if (previousValue != value)
                {
                    SendPropertyChanging();
                    _CompanyType = value;
                    if (value != null)
                    {
                        CompanyTypeId = value.CompanyTypeId;
                    }
                    else
                    {
                        _CompanyTypeId = default;
                    }
                    SendPropertyChanged("CompanyType");
                }
            }
        }

        public Country Country
        {
            get => _Country;
            set
            {
                var previousValue = _Country;
                if (previousValue != value)
                {
                    SendPropertyChanging();
                    _Country = value;
                    _CountryId = value?.CountryId ?? default;
                    SendPropertyChanged("Country");
                }
            }
        }

        [Column("IsKycIdSent"), Required]
        public bool IsKycIdSent
        {
            get => _IsKycIdSent;
            set
            {
                if (_IsKycIdSent != value)
                {
                    OnIsKycIdSentChanging(value);
                    SendPropertyChanging();
                    _IsKycIdSent = value;
                    SendPropertyChanged("IsKycIdSent");
                    OnIsKycIdSentChanged();
                }
            }
        }

        public event PropertyChangingEventHandler PropertyChanging;

        public event PropertyChangedEventHandler PropertyChanged;

        protected virtual void SendPropertyChanging()
        {
            PropertyChanging?.Invoke(this, emptyChangingEventArgs);
        }

        protected virtual void SendPropertyChanged(string propertyName)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }

        private void Attach_Resultats(Resultat entity)
        {
            SendPropertyChanging();
            entity.Company = this;
        }

        private void Detach_Resultats(Resultat entity)
        {
            SendPropertyChanging();
            entity.Company = null;
        }
    }

以及相關的表創建腳本：

create table T_Companies
(
    CompanyId            int identity (10) identity
        primary key nonclustered,
    CompanyName          varchar(1024) not null,
    CompanyTypeId        int           not null
        constraint FK_Company_CompanyType
            references T_CompanyTypes,
    CountryId            int           not null
        constraint FK_Company_Country
            references T_Countries,
    Active               bit           not null,
    AccountId            int,
    CallbackSalt         varchar(1024),
    UserSpaceId          int,
    Login                varchar(1024),
    Pwd                  varchar(1024),
    StatusDate           datetime(23, 3),
    BankStatusCode       int           not null,
    PivotalAccount       varchar(255),
    IsTechnicalAccount   bit           not null,
    CompanyStreetAddress varchar(256),
    CompanyCity          varchar(256),
    CompanyZipCode       varchar(10),
    CompanyVatNumber     varchar(30),
    ContactFirstName     varchar(20),
    ContactLastName      varchar(20),
    IsKycIdSent          bit           not null
)
go

[編輯 2]

對於相同的模型，這（在項目文件中的 nuget 引用）有效

<PackageReference Include="Microsoft.EntityFrameworkCore" Version="2.1.8" />
<PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="2.1.8" />

而那些，不：

<PackageReference Include="Microsoft.EntityFrameworkCore" Version="2.2.0" />
<PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="2.2.0" />

<PackageReference Include="Microsoft.EntityFrameworkCore" Version="2.2.0" />
<PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="2.1.8" />

Answer 1

錯誤消息表明 EF Core 正在嘗試讀取所需屬性的string值，即數據庫中不應null值的屬性，但底層數據讀取器在某些記錄中報告該屬性的null值。

查看您的實體模型和相應的數據庫表，您可以看到許多string屬性 -> varchar列的明顯差異。 CompanyStreetAddress , CompanyCity , CompanyZipCode , CompanyVatNumber , ContactFirstName , ContactLastName - 所有這些在模型中都標記為[Required] ，但在表中沒有對應的not null約束。

所以問題是由這些列中的一個或多個引起的。

您需要修復該差異 - 可能通過刪除[Required]屬性，因為現有數據中的約束已被破壞。

它在某些較舊的 EF Core 版本中“工作”的事實並不重要 - 這是不正確的映射，因此應該修復。 從技術上講，它不應該從一開始就起作用。 但請記住，EF Core 仍在積極開發中，並且有許多錯誤將在下一個版本中修復。 很可能在“工作”和“不工作”的 EF Core 版本之間進行了一些代碼更改，從而修復了以前的不正確行為。

Answer 2

如果您嘗試從數據庫中讀取一些可為空的數據，但您的類型不可為空，您可能會收到此錯誤。

如果MyInt在數據庫中可以為空並且你有這個實體：

public class MyEntity
{
    public int Id { get; set; }
    public int MyInt { get; set; }
}

您將得到異常： System.Data.SqlTypes.SqlNullValueException: 'Data is Null. This method or property cannot be called on Null values.' System.Data.SqlTypes.SqlNullValueException: 'Data is Null. This method or property cannot be called on Null values.'

要解決此問題，只需將MyInt屬性的類型更改為Nullable<int>或int? ：

public class MyEntity
{
    public int Id { get; set; }
    public int? MyInt { get; set; }
}

注意：這不是對原始問題的回答，而是對標題中問題的回答。

Answer 3

如果您從 C# 8 啟用最新的 Nullable 功能，也會出現這種異常。

EF Core，至少目前，它與 C# 8 可空類型不完全兼容。 例如，假設您為項目啟用了 Nullable 功能，如果您有這樣的類型：

public class MyEntity
{
   public string MyProperty { get; set; }
}

即使該屬性沒有用 [Required] 屬性標記，EF 核心也會引發這種異常，因為它要求數據庫中的值不為空（即它不使用 IsDbNull 測試列值）。

有關如何在 EF 核心中處理可為空的引用類型的更多信息，請查看： https ://docs.microsoft.com/en-us/ef/core/miscellaneous/nullable-reference-types

Answer 4

要解決Data is Null異常的類似問題，我必須明確地將IsRequired(false)放在我的列映射上。 就我而言，我正在映射數據庫視圖。

builder.Property(x => x.MyProperty).IsRequired(false);

Answer 5

解決方案：是的，錯誤“SqlNullValueException：數據為空”。 當模型將導致問題的字段標記為 [Required] 時，當（表的）列包含 NULL 時會導致此問題......使用數字字段很容易解決問題，但當字段為字符串類型時非常糟糕...... .

考慮以下 2 個使用分發路線示例的類，每條路線都有一個司機，當然，每個司機都有 1 條或更多條路線。

 public class Route { public int id { get; set; } public string RouteName { get; set; } [Required] \\==> FIELD CAUSING THE PROBLEM public string UsuarioId { get; set; } public virtual Usuario Driver { get; set; } } public class Usuario { public string Id {get;set; public string Name { get; set; } public virtual List<Route> Routes { get; set; } = new List<Route>(); }

正如您可能猜到的那樣，一個 Route 可以有一個驅動程序（或者我稱之為 Usuario），但是一個驅動程序可以有多個路由，這使得一對多的關系如下：

 protected override void OnModelCreating(ModelBuilder modelBuilder){ base.OnModelCreating(modelBuilder); modelBuilder.Entity<Usuario>() .HasMany<Route>(usuario => usuario.Routes) .WithOne(route => route.Driver) .HasForeignKey(route => route.UsuarioId) .OnDelete(DeleteBehavior.SetNull); }

根據 FluentAPI，當驅動程序被刪除時，行為是將 UsuarioId 字段（在 Routes 模型中）設置為 NULL，但這違反了 [Required] 屬性。 因此，我們將無法刪除用戶（或驅動程序）表中的記錄。 此外，如果數據庫中已經有數據，在這種情況下，UsuarioId 為 NULL 的 Routes，它會立即顯示錯誤。

請記住，重點是：我們希望 [Required] 僅用於驗證目的，因為我們可能有尚未分配給驅動程序 (UserId) 的路由，因此在數據庫中，應該允許它為 NULL ，而不是我們的 mvc 形式。

要解決此問題，請將字段標記為 [required]，然后轉到您使用 fluent API 定義關系的 DbContext 類，並指定該列不是必需的，如下所示：

 modelBuilder.Entity<Route>() .Property(p => p.UsuarioId).IsRequired(required: false);

因此該字段現在在注釋模式下是必需的，但最終將用於構建數據庫的 fluent API 不需要該字段。 這將解決問題！

Answer 6

從模型中刪除 [Required] .. 並在 cshtml 中使用 :

Answer 7

   public bool Isgstvailable { get; set; }

檢查 sql 視圖或表中的位列。 如果它返回 null ，c# 閱讀器將無法讀取並拋出 null ref 異常。

當 gst.Isgstvailable 為 null 時的情況，然后強制轉換（0 作為位），否則 gst.Isgstvailable 結束為 Isgstvailable

Answer 8

[使用 isRequired()][1] 我通過在 db 上下文（由 scafford 生成）中定義表的所有屬性來解決我的問題，這是否需要。

Answer 9

不是 OP 的情況，但這也可能與關系中的反向 Principal Key <> Foreign Key 配置有關。

例如：

entity
  .HasOne(e => e.Principal)
  .WithOne(e => e.Dependent)
  .HasForeignKey<Principal>(e => e.Key) <- This should be the dependent entity
  .HasPrincipalKey<Dependent>(e => e.Key); <- This should be the principal entity

代替

entity
  .HasOne(e => e.Principal)
  .WithOne(e => e.Dependent)
  .HasForeignKey<Dependent>(e => e.Key)
  .HasPrincipalKey<Principal>(e => e.Key);

Answer 10

只是想在這里發布這個；

這里的解決方案很棒，但是在我的情況下它不起作用。 我使用的是 SQL 視圖而不是表，並且我的所有字段都沒有在模型中標記為 [Required]。

經過一些故障排除后，我發現問題來自我的整數列為空。 我只是將模型中的 int 列更改為字符串（我需要此信息僅用於顯示目的），它就成功了。

從

public int BatchId { get; set; }

至

public string BatchId { get; set; }

我希望這可以幫助別人。 感謝以上所有答案！

Answer 11

我遇到了這個，這是因為我在模型中的一個字段上有 [Required] 而不是 [JsonIgnore]

Answer 12

如果您想忽略這些值，添加 DefaultIfEmpty() 有效。

_context.<YourDbSet>.DefaultIfEmpty().ToListAsync();

在這種情況下：

var companyEditVMs = await DB.Companies
    .OrderBy(company => company.CompanyId == 1 
        ? "_" + company.CompanyName 
        : company.CompanyName
    )
    Select(a => new CompanyEditVM(..--..)).DefaultIfEmpty()
    .ToListAsync();

Answer 13

就我而言，這是由於我將數據庫中的列從不可為空更改為可空，然后忘記了我需要再次重新運行 Scaffold-DbContext 以便更新實體類。 我正在使用數據庫優先的實體框架核心。