Entity Framework Core：`SqlNullValueException：数据为空。`如何排除故障？-entity-framework-IT问答社区-解决你的IT疑问

Entity Framework Core：`SqlNullValueException：数据为空。`如何排除故障？

user303749 1月前

我在 ASP.NET Core 应用程序和 Controller 操作中使用 Entity Framework Core，我没有对工作代码和数据库进行任何更改，但我无法判断查询性能如何......

我在 ASP.NET Core 应用程序和 Controller 操作中使用 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" />

帖子版权声明 1、本帖标题：Entity Framework Core：`SqlNullValueException：数据为空。`如何排除故障？
本站网址：http://xjnalaquan.com/
2、本网站的资源部分来源于网络，如有侵权，请联系站长进行删除处理。
3、会员发帖仅代表会员个人观点，并不代表本站赞同其观点和对其真实性负责。
4、本站一律禁止以任何方式发布或转载任何违法的相关信息，访客发现请向站长举报
5、站长邮箱：yeweds@126.com 除非注明，本帖由user303749在本站《entity-framework》版块原创发布，转载请注明出处！

最新回复 (0)

最新倒序只看楼主

bonk 1月前 0 只看Ta

引用 2楼

问题在于如何解决问题。而不是如何修复它。它始终是模型/数据库不匹配，通过故障排除，可以决定两者中的哪一个必须更改。
Nikos Paraskevopoulos 1月前 0 只看Ta

引用 3楼

在我的上下文中，我的数据库与我的模型不同步，我添加了一个新的迁移来同步两者并更新了我的数据库，问题已解决。
Maggy 1月前 0 只看Ta

引用 4楼

@GertArnold 感谢您的反馈。不幸的是，如果它对您的情况没有帮助，并不一定意味着它无法解决类似情况下的问题。我个人也遇到过同样的异常，我答案中的代码帮助我解决了它。
Misha 1月前 0 只看Ta

引用 5楼
在现代 EF Core 版本中，这是由 csproj 中的属性触发的 Nullable 。这也意味着您有某种字段在数据库中为空，但在 C# 中不可为空。

如果你不想禁用 Nullable 该功能，也可以将其从切换 enable 到 warnings
```
<PropertyGroup>
    <Nullable>warnings</Nullable>
</PropertyGroup>
```
Filippo 1月前 0 只看Ta

引用 6楼

我将所有视图都改为 int -> int?，并将 HasNoKey 和所有字符串都设置为 .IsRequired(false); 但我仍然收到 SqlNullValueException。我可以设置一些全局标志吗？顺便说一句，所有行/列都有有效数据。所以我没有空值/
King Saozer 1月前 0 只看Ta

引用 7楼

你好 Asif，我遇到了同样的问题。在我的情况中，最好将“int”更改为“int?”以允许为空。数据库中的相应列也允许为空。它对你有用的原因是字符串始终可以为空。
Magnum 1月前 0 只看Ta

引用 8楼
只是想在这里发布这个；

这里的解决方案很棒，但是对我而言却不起作用。我使用的是 SQL 视图而不是表，并且模型中没有一个字段带有 [Required] 标记。

经过一些故障排除后，我发现问题出在我的整数列为空。我只需将模型中的 int 列更改为字符串（我仅需要此信息用于显示目的）即可解决问题。

从
```
public int BatchId { get; set; }
```
到
```
public string BatchId { get; set; }
```
希望这对某些人有帮助。感谢以上所有答案！
Bike Smith 1月前 0 只看Ta

引用 9楼
在.net 6中，在.csproj文件中，按如下所示设置此条目。
```
<Nullable>disable</Nullable>
```
就我而言，它发生在我从 .net 框架迁移到 .net6 之后。之前 EF 接受来自数据库的属性空数据，但在 .net 核心中，您必须将 ? 添加到可空的属性中。关于此问题，上述选项使 ef core 能够像以前一样工作。
Suraj Sanwal 1月前 0 只看Ta

引用 10楼
我在视图方面也遇到了同样的问题。SQL/SSMS 的一个大问题是视图没有刷新，因此 EF 脚手架无法获取更改。

此代码将刷新您的视图元数据，这使得 EF 能够在搭建脚手架时看到诸如 NULL/NOT NULL 属性变化之类的细小变化。
```
-- Loop and refresh all views.
DECLARE @ViewName VARCHAR(100), @SchemaName VARCHAR(20);

DECLARE [views_cursor] CURSOR FOR 
SELECT v.[name] AS ViewName, s.[name] AS SchemaName 
FROM [sys].[views] v INNER JOIN [sys].[schemas] s ON s.[schema_id] = v.[schema_id]
WHERE v.[type] = 'V'
ORDER BY SchemaName, ViewName;

OPEN [views_cursor];

FETCH NEXT FROM [views_cursor] 
INTO @ViewName, @SchemaName;

-- Check @@FETCH_STATUS to see if there are any more rows to fetch.
WHILE @@FETCH_STATUS = 0
BEGIN
    BEGIN TRY
        DECLARE @FullName VARCHAR(120) = @SchemaName + '.' + @ViewName;
        PRINT 'Refreshing: ' + @FullName
        EXEC sp_refreshview @FullName
    END TRY
    BEGIN CATCH
        PRINT 'Error: ' + @FullName
    END CATCH
    FETCH NEXT FROM [views_cursor] 
    INTO @ViewName, @SchemaName;
END

CLOSE [views_cursor];
DEALLOCATE [views_cursor];
GO
```
AliKales 1月前 0 只看Ta

引用 11楼

就目前的情况来看，您的答案不够清晰。请编辑以添加更多详细信息，帮助其他人了解此内容如何解决所提问题。您可以在帮助中心找到有关如何撰写良好答案的更多信息。
MaroonSphinx 1月前 0 只看Ta

引用 12楼

我只需要在模型上将 (int?) 作为 c# 属性放置即可，而且工作正常，因为数据库列允许为空。
physicsGuy 1月前 0 只看Ta

引用 13楼
我通过添加解决了这个问题
```
modelBuilder.Entity<EntityName>().HasNoKey();
```
方法 DbContext
```
protected override void OnModelCreating(ModelBuilder modelBuilder)
```
因为我的存储过程返回了 null 属性 Id 。
Guest 1月前 0 只看Ta

引用 14楼

[使用 isRequired()][1]我已经通过在数据库上下文中定义表的所有属性（由 scafford 生成）来解决了我的问题，这些属性是必需的还是不是。
Mike Cheel 1月前 0 只看Ta

引用 15楼
不是 OP 情况，但这也可以与关系中的反转主键<>外键配置相关。

例如：
```
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);
```
Juls 1月前 0 只看Ta

引用 16楼

从模型中删除 [Required] ..并在 cshtml 中使用：< input data-val=\'true\' data-val-required=\'write a message for validation\' >
Chukwujiobi Canon 1月前 0 只看Ta

引用 17楼

是的，Ivan 对此进行了充分解释。您的回答没有添加任何新内容。此外，它不是抛出的空引用异常。
eliran 1月前 0 只看Ta

引用 18楼

谢谢@GertArnold，在实体框架中加载数据时，它会与模型进行映射。如果有效负载数据与数据类型不匹配，则会引发异常。我有一个案例，我在数据库中有一个位字段，不幸的是它插入了空数据。加载位字段时，实体框架会引发空引用异常，原因是数据类型和加载的数据类型不匹配。
Суровый Критик 1月前 0 只看Ta

引用 19楼
```
   public bool Isgstvailable { get; set; }
```
检查 SQL 视图或表中的位列。如果它返回 null ，则 c# 读取器将无法读取并抛出 null ref 异常。

当 gst.Isgstvailable 为空时，则强制转换（0 作为位），否则 gst.Isgstvailable 以 Isgstvailable 结尾
al-al-99 1月前 0 只看Ta

引用 20楼
我知道这是一个老问题，但万一有人还在寻找。要么从
```
public string RRN { get; set; }
```
到
```
public string? RRN { get; set; }
```
或者在 cproj 文件中禁用可空
```
 <Nullable>disable</Nullable>
```