Dlaczego nie można wykonać rzutowania?

Hej, zastanawiam się, czemu nie mogę wykonać rzutowania w konstruktorze modelu widoku:

public BookingsViewModel()
        {
            IEnumerable<Booking> bookingsDB = repository.GetBookings();
            model = bookingsDB; //wyjątek
        }

Rzuca mi to wyjątkiem:

Cannot implicitly convert type 'System.Collections.Generic.IEnumerable<Library2.Models.Booking>' to 'Library2.Models.Bookings'. An explicit conversion exists (are you missing a cast?)

W czasie gdy GetBookings() wygląda tak:

public IEnumerable<Booking> GetBookings()
        {
            var bookings = context.Bookings.
                    Include(i => i.Book).
                    Include(i => i.Reader).
                    AsEnumerable().
                    ToList();
            return bookings;
        }

A model **Bookings **tak:

public class Bookings : IEnumerable<Booking>
    {
        private List<Booking> bookingList = new List<Booking>();
        public void AddBooking(Booking booking)
        {
            bookingList.Add(booking);
        }
        public bool DeleteBooking(Booking booking)
        {
            return bookingList.Remove(booking);
        }
        public int BookingList
        {
            get
            {
                return bookingList.Count;
            }
        }
        public Booking this[int index]
        {
            get
            {
                return bookingList[index];
            }
        }
        public IEnumerator<Booking> GetEnumerator()
        {
            return bookingList.GetEnumerator();
        }
        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }
    }

Gdzie leży problem, skoro Bookings implementuje IEnumerable<Booking>?

var bookings = context.Bookings.
                    Include(i => i.Book).
                    Include(i => i.Reader).
                    AsEnumerable().
                    ToList();
            return bookings;

Jesteś pewien, że to zwraca ci IEnumerable<Booking> a nie przypadkiem IEnumerable<Bookings>?

Dlatego, że nie jest to pewne że się uda. Kompilator nie przeanalizuje aż tak dokładnie Twojego kodu żeby ze 100% pewnością to stwierdzić. A tylko wtedy gdy ma taką pewność implicit casting działa.
Więcej info o tym tutaj:
https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/types/casting-and-type-conversions

Ciągle możesz użyć konwersji explicit lub dodać sobie
https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/implicit

jeśli tak bardzo Ci zależy na tym braku casta.

Dlaczego twoim zdaniem ten kod powinien działać ?

@AreQrm: był najbliższy prawidłowej odpowiedzi.

Bądź co bądź przebudowałem całkowicie aplikację, bo korzystałem z rozwiązań, które zaczerpnąłem z innego projektu, a tutaj się nie sprawdzały, więc przebudowałem model i VM.

W każdym razie dzięki wszystkim za uwagę :)