Web API не возвращает никаких данных, если количество элементов больше 1 по методу get

Question

Веб-интерфейсу API не удается выполнить какие-либо запросы или получить методы, которые возвращают более одной строки в таблице в базе данных.У меня был класс модели квартир, в который я добавил BuyerID, который является идентификатором класса модели покупателей.Также Класс Покупателей содержит коллекцию Квартир.Он возвращает эту ошибку:

SqlNullValueException: Data is Null. This method or property cannot be
called on Null values

Класс моей квартиры:

public class Apartment
    {
        [Key]
        public int ID { get; set; }
        public string Title { get; set; }
        public int NbofRooms { get; set; }
        public int Price { get; set; }
        public string Address { get; set; }
        public int BuyerId { get; set; } 

    }

Класс моих покупателей:

public class Buyer
    {
        [Key]
        public int ID { get; set; }
        public string FullName { get; set; }
        public int Credit { get; set; }
        public ICollection<Apartment> apartments { get; set; }
    }

Контроллер моей квартиры:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Assignment2CME.Data;
using Assignment2CME.Models;
using Microsoft.AspNetCore.Cors;
using System.Diagnostics;
using System.Web.Http.Cors;

namespace Assignment2CME.Controllers
{
    [Produces("application/json")]
    [Route("api/Apartments")]
    [System.Web.Http.Cors.EnableCors(origins: "http://localhost:4200", headers: "*", methods: "*")]
    [Microsoft.AspNetCore.Cors.EnableCors("BuyersPolicy")]
    public class ApartmentsController : Controller
    {
        private readonly ApartmentContext _context;

        public ApartmentsController(ApartmentContext context)
        {

            _context = context;
        }

        // GET: api/Apartments
        [HttpGet]
        public IEnumerable<Apartment> GetApartments()
        {
            return _context.Apartments;
        }

        // GET: api/Apartments/5
        [HttpGet("{id}")]
        public async Task<IActionResult> GetApartment([FromRoute] int id)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            var apartment = await _context.Apartments.SingleOrDefaultAsync(m => m.ID == id);

            if (apartment == null)
            {
                return NotFound();
            }

            return Ok(apartment);
        }

        // GET: api/Apartments/5
        [HttpGet("Aparts/{id}")]
        public async Task<IActionResult> GetApar([FromRoute] int id)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            var apartment = await _context.Apartments.Select(x => x).ToListAsync();

            if (apartment == null)
            {
                return NotFound();
            }

            return Ok(apartment);
        }

        // GET: api/Apartments/5
        [HttpGet("Title/{id}")]
        public async Task<IActionResult> GetTitle([FromRoute] int id)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            var apartment = await _context.Apartments.SingleOrDefaultAsync(m => m.ID == id);

            var title = apartment.Title;

            if (apartment == null)
            {
                return NotFound();
            }

            return Ok(title);
        }

        // GET: api/Apartments/address1/5
        [HttpGet("address1/{id}")]
        public async Task<IActionResult> ReturnAddress([FromRoute] int id)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            var apartment = await _context.Apartments.SingleOrDefaultAsync(m => m.ID == id);

            var address = apartment.Address;

            if (apartment == null)
            {
                return NotFound();
            }

            return Ok(address);
        }

        // GET: api/Apartments/Price/5
        [HttpGet("Price/{id}")]
        public async Task<IActionResult> GetPrice([FromRoute] int id)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            var apartment = await _context.Apartments.SingleOrDefaultAsync(m => m.ID == id);

            var price = apartment.Price;

            if (apartment == null)
            {
                return NotFound();
            }

            return Ok(price);
        }

        [HttpGet("NumberofRooms/{id}")]
        public async Task<IActionResult> GetNbofRooms([FromRoute] int id)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            var apartment = await _context.Apartments.SingleOrDefaultAsync(m => m.ID == id);

            var NumberofRooms = apartment.NbofRooms;

            if (apartment == null)
            {
                return NotFound();
            }

            return Ok(NumberofRooms);
        }

        // GET: api/Apartments/40000/70000
        [HttpGet("{fromPrice}/{toPrice}")]
        public async Task<IActionResult> GetFilteredApartment([FromRoute] int fromPrice,[FromRoute] int toPrice)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }
            if (fromPrice != 0 && toPrice != 0)
            {
                var apartment = await _context.Apartments.Where(s => s.Price >= fromPrice && s.Price <= toPrice).OrderByDescending(s => s.Price).ToListAsync();
                if (apartment == null)
                {
                    return NotFound();
                }

                return Ok(apartment);
            }
            else if(fromPrice != 0)
            {
                var apartment = await _context.Apartments.Where(s => s.Price >= fromPrice).ToListAsync();
                if (apartment == null)
                {
                    return NotFound();
                }

                return Ok(apartment);
            }
            else if (toPrice != 0)
            {
                var apartment = await _context.Apartments.Where(s => s.Price <= toPrice).ToListAsync();
                if (apartment == null)
                {
                    return NotFound();
                }

                return Ok(apartment);
            }
            else
            {
                var apartment = _context.Apartments;
                if (apartment == null)
                {
                    return NotFound();
                }

                return Ok(apartment);
            }
        }

        // GET: api/Apartments/Address/Beirut
        [HttpGet("Address/{address}")]
        public async Task<IActionResult> GetFilteredApartmentByAddress([FromRoute] string address)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }
            if (address != null)
            {
                var apartment = await _context.Apartments.Where(s => s.Address == address).OrderByDescending(s => s.Price).ToListAsync();
                if (apartment == null)
                {
                    return NotFound();
                }
                return Ok(apartment);
            }
            else
            {
                var apartment = _context.Apartments;
                if (apartment == null)
                {
                    return NotFound();
                }

                return Ok(apartment);
            }
        }

        // GET: api/Apartments/NbofRooms/5
        [HttpGet("NbofRooms/{NbofRooms}")]
        public async Task<IActionResult> GetFilteredApartmentByNbofRooms([FromRoute] int NbofRooms)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }
            if (NbofRooms != 0)
            {
                var apartment = await _context.Apartments.Where(s => s.NbofRooms == NbofRooms).OrderByDescending(s => s.Price).ToListAsync();
                if (apartment == null)
                {
                    return NotFound();
                }

                return Ok(apartment);
            }
            else
            {
                var apartment = _context.Apartments;
                if (apartment == null)
                {
                    return NotFound();
                }

                return Ok(apartment);
            }
        }

        // PUT: api/Apartments/5
        [HttpPut("{id}")]
        public async Task<IActionResult> PutApartment([FromRoute] int id, [FromBody] Apartment apartment)
        {
            if (!ModelState.IsValid)
            {
                var errors = ModelState.Values.SelectMany(v => v.Errors);
                return BadRequest(ModelState);
            }

            if (id != apartment.ID)
            {
                return BadRequest();
            }

            _context.Entry(apartment).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!ApartmentExists(id))
                {
                    return NotFound();
                }
                else
                {
                    throw;
                }
            }

            return NoContent();
        }

        // POST: api/Apartments
        [HttpPost]
        public async Task<IActionResult> PostApartment([FromBody] Apartment apartment)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            _context.Apartments.Add(apartment);
            await _context.SaveChangesAsync();

            return CreatedAtAction("GetApartment", new { id = apartment.ID }, apartment);
        }

        // DELETE: api/Apartments/5
        [HttpDelete("{id}")]
        public async Task<IActionResult> DeleteApartment([FromRoute] int id)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            var apartment = await _context.Apartments.SingleOrDefaultAsync(m => m.ID == id);
            if (apartment == null)
            {
                return NotFound();
            }

            _context.Apartments.Remove(apartment);
            await _context.SaveChangesAsync();

            return Ok(apartment);
        }

        private bool ApartmentExists(int id)
        {
            return _context.Apartments.Any(e => e.ID == id);
        }
    }
}

Это мой контекстный класс:

public class ApartmentContext: DbContext
    {
        public ApartmentContext(DbContextOptions options) : base(options)
        {

        }

        protected override void OnModelCreating(ModelBuilder builder)
        {
            base.OnModelCreating(builder);
        }

        public DbSet<Apartment> Apartments { get; set; }
        public DbSet<Buyer> Buyers { get; set; }
    }

Все, что возвращает более одной квартиры, не работает.