Jetbrains 的 Rider 错了吗？

Question

我正在使用 .NET 8、ASP.NET Core 8 WebAPI、Entity Framework Core 8、SQL Server 2022

文件

BusinessTypeHiddenOption.cs

using System;
using System.Collections.Generic;

namespace acc.Models;

public partial class BusinessTypeHiddenOption
{
    public Guid OptionVisibleBusinessId { get; set; }

    public string? OptionVisibleBusiness { get; set; }

    public string? ColumnHidden { get; set; }

    public int? TypeHidden { get; set; }

    public string? LayoutHidden { get; set; }

    public int? RefType { get; set; }

    public int? VoucherType { get; set; }

    public string? SubSystemCode { get; set; }

    public string? TableName { get; set; }

    public string? DictionaryType { get; set; }

    public string? ReportId { get; set; }

    public string? ParentId { get; set; }
    public Guid TenantId { get; set; }
}

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using System.Data;
using acc.DTO;
using acc.Models;
using Swashbuckle.AspNetCore.Annotations;
using acc.DTO;
using acc.Models;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Stimulsoft.Report;
using System.Data;
using Stimulsoft.Report.Dictionary;
using Stimulsoft.Report.Web;
using System;
using System.IO;
using System.Web;
using Stimulsoft.Report.Mvc;
using Microsoft.Extensions.Hosting.Internal;
using JwtRoleAuthentication.Enums;
using Swashbuckle.AspNetCore.Annotations;
using AutoMapper;

namespace JwtRoleAuthentication.Controllers
{
    /// <summary>
    /// FOO.
    /// </summary>
    [SwaggerTag("Tài khoản kế toán.")]
    [Route("api/business-type-hidden-option")]
    [ApiController]
    public class BusinessTypeHiddenOptionController : ControllerBase
    {
        private readonly ILogger<BusinessTypeHiddenOptionController> _logger;
        private readonly Acc200Context _db;

        public BusinessTypeHiddenOptionController(ILogger<BusinessTypeHiddenOptionController> logger,
            Acc200Context acc200Context)
        {
            _logger = logger;
            _db = acc200Context;
        }

        /// <summary>
        /// Delete an account by its tenantId and optionVisibleBusinessId .
        /// </summary>
        /// <param name="tenantId"></param>
        /// <param name="optionVisibleBusinessId"></param>
        /// <returns></returns>
        [SwaggerOperation("Xóa bỏ option Visible Business theo Mã dữ liệu kế toán và ID record (Xóa vật lý).")]
        [HttpDelete("{tenantId}/{optionVisibleBusinessId}")]
        [Authorize(Roles = "User")]
        public async Task<IActionResult> DeleteAnRecord([FromRoute] Guid tenantId, [FromRoute] Guid optionVisibleBusinessId)
        {
            var item = await _db.BusinessTypeHiddenOptions.Where(x => x.TenantId == tenantId).Where(y => y.OptionVisibleBusinessId == optionVisibleBusinessId)
                .FirstOrDefaultAsync();
            if (item == null)
            {
                return NotFound();
            }
            _db.BusinessTypeHiddenOptions.Remove(item);
            await _db.SaveChangesAsync();
            return NoContent();
        }
        
        /// <summary>
        /// Sửa 1 account.
        /// </summary>
        /// <param name="accountId"></param>
        /// <param name="tenantId"></param>
        /// <param name="input"></param>
        /// <returns></returns>
        [SwaggerOperation("Sửa/cập nhật Tài khoản kế toán theo Mã dữ liệu kế toán và id của Tài khoản kế toán.")]
        [HttpPut("{tenantId}/{optionVisibleBusinessId}")]
        [Authorize(Roles = "User")]
        public async Task<IActionResult> PutItem([FromRoute] Guid accountId, [FromRoute] Guid optionVisibleBusinessId,
            [FromBody] BusinessTypeHiddenOptionDTO input)
        {
            // if (account_id != input.Id || tenant_id != input.TenantId)
            if (accountId != input.OptionVisibleBusinessId)
            {
                return BadRequest();
            }

            _db.Entry(input).State = EntityState.Modified;
            try
            {
                await _db.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!AccountExists(tenantId, accountId))
                {
                    return NotFound();
                }
                else
                {
                    throw;
                }
            }

            return NoContent();
        }
        
        /// <summary>
        /// Kiểm tra xem 1 số tài khoản đã tồn tại hay chưa?
        /// </summary>
        /// <param name="tenantId"></param>
        /// <param name="accountId"></param>
        /// <returns></returns>
        private bool IsItemExist(Guid tenantId, Guid optionVisibleBusinessId)
        {
            BusinessTypeHiddenOption businessTypeHiddenOption =
                _db.BusinessTypeHiddenOptions.First(x =>
                    x.TenantId == tenantId && x.OptionVisibleBusinessId == optionVisibleBusinessId);
            if (businessTypeHiddenOption != null)
            {
                return true;
            }
            return false;
        }
        
        /// <summary>
        /// Get an item by accountId and tenantId .
        /// </summary>
        /// <param name="tenantId"></param>
        /// <param name="accountId"></param>
        /// <returns></returns>
        [SwaggerOperation("Lấy thông tin chi tiết 1 Tài khoản kế toán.")]
        [HttpGet("{tenantId}/{accountId}")]
        [Authorize(Roles = "User")]
        public async Task<ActionResult<AccountDTO>> GetItem([FromRoute] Guid tenantId, [FromRoute] Guid accountId)
        {
            var accountItem = await _db.Accounts.Where(s => s.TenantId == tenantId).Where(y => y.AccountId == accountId)
                .FirstOrDefaultAsync();
            if (accountItem == null)
            {
                return NotFound();
            }
            var config = new MapperConfiguration(cfg => cfg.CreateMap<Account, AccountDTO>());
            var config2 = new MapperConfiguration(cfg => cfg.CreateMap<Account, AccountDTO>().ReverseMap());
            var mapper = config.CreateMapper();
            AccountDTO dto = mapper.Map<AccountDTO>(accountItem);
            return dto;
        }
        
        /// <summary>
        /// FOO.
        /// </summary>
        /// <param name="tenantId"></param>
        /// <returns></returns>
        [SwaggerOperation("Hệ thống Tài khoản kế toán.")]
        [HttpGet("{tenantId}/all")]
        [Authorize(Roles = "User")]
        public IEnumerable<BusinessTypeHiddenOptionDTO> Get([FromRoute] Guid tenantId)
        {
            return _db.BusinessTypeHiddenOptions.Where(x => x.TenantId == tenantId).Select(a =>
                new BusinessTypeHiddenOptionDTO
                {
                    TenantId = a.TenantId,
                    ColumnHidden = a.ColumnHidden,
                    DictionaryType = a.DictionaryType,
                }).ToArray();
        }
    }
}

骑手说

Expression is always true according to nullable reference types' annotations.

如果Rider为true，在这种情况下如何检查记录是否存在？

Answer 1

你得到这个是因为你正在返回

First

，它总是返回一些东西。您可能打算

FirstOrDefault