Как внедрить модель во viewModel?

public class BirdsViewModel : ObservableObject
{
    // [B]Конструктор[/B]
    public BirdsViewModel(IBirdRepository birdRepository, Func<BirdEntity, BirdViewModel> birdView) // [B]Прошу обратить 
//внимание на делегат. Его, думаю, и нужно заменять.[/B]
 
    {
        Birds = [];
        _birdView = birdView;
        _birdRepository = birdRepository;
        LoadBirds();
    }
 
// [B]Проблемный метод[/B]
private async void LoadBirds()
{
    var birds = await _birdRepository.GetAllAsync(); // [B]Получение данных из БД[/B]
    switch (Name)
    {
        default:
            foreach (var bird in birds)
                Birds.Add(_birdView(bird)); // [B]С помощью делегата я во ViewModel передаю Entity, 
//с которой та и работает. Есть ли другие методы подобной реализации, чтобы у каждой ViewModel был свой Entity?[/B]
            break;
    }
}

public bool IsUnique(string name)
{
    return readOnlyObservableCollection!.Any(t => t.Name.Equals(name, StringComparison.OrdinalIgnoreCase));
}

public string Word {  get => Get<string>()!; 
    set 
    {
        ClearErrors();
        if (string.IsNullOrEmpty(value) || _wordRepository.IsUnique(value))
        {
            AddError("");
        }
        
        Set(value); 
    }
}

    public class CreateSetViewModel : ViewModelBase
    {
        private readonly RelayCommand<CreateSetViewModel> saveCommand;
 
        public RelayCommand SaveCommand => GetCommand(
            () =>
            {
                saveCommand.Execute(this);
            },
            () =>
            {
                return saveCommand.CanExecute(this);
            });
 
        protected override void OnPropertyChanged(string propertyName, object? oldValue, object? newValue)
        {
            base.OnPropertyChanged(propertyName, oldValue, newValue);
            SaveCommand.RaiseCanExecuteChanged();
        }
 
        public CreateSetViewModel(RelayCommand<CreateSetViewModel> saveCommand)
        {
            Id = 0;
            Set = string.Empty;
            Word = string.Empty;
            Definition = string.Empty;
 
            this.saveCommand = saveCommand;
            saveCommand.CanExecuteChanged += delegate { SaveCommand.RaiseCanExecuteChanged(); };
        }

        public MainViewModel(IDbModel model)
        {
            this.model = model;
 
            createSetVM = new((RelayCommand<CreateSetViewModel>)SaveWordCommand);

namespace Flashcards.Liblary.Repository
{
    /// <summary>Базовый класс с идентификатором</summary>
    public abstract class IdDto(int id)
    {
        /// <summary>Целочисленный идентификатор</summary>
        public int Id { get; set; } = id;
 
    }
 
    /// <summary>Базовый класс с идентификатором</summary>
    public abstract class IdNameDto(int id, string name) : IdDto (id)
    {
        /// <summary>Название</summary>
        public string Name { get; set; } = name;
    }
}

using System.Collections.ObjectModel;
 
namespace Flashcards.Liblary.Repository
{
    /// <summary>Репозиторий <see cref="IdDto"/>.</summary>
    public interface IRepository<TId> where TId : IdDto
    {
        /// <summary>Добавление записи в Репозиторий.</summary>
        /// <param name="idDto">Экземпляр с данными для добавления. Идентификатор <paramref name="id"/> игнорируется.</param>
        /// <remarks>Если не удалось создать или добавить экземпляр, то выкдывается исключение.
        /// Игнорирование <see cref="TId.Id"/> зависит от диалекта БД.
        /// Возможно для этого добавление логики в Репозиторий.</remarks>
        /// <returns>Созданный согласно параметров экземляр <see cref="IdDto"/> и добавленный в репозиторий.
        /// Идентификатор, возвращаемего экземпляра, присваивается репозиторием.</returns>
        Task<TId> AddAsync(TId idDto);
 
        /// <summary>Удаление записи с указанным идентификатором.</summary>
        /// <param name="id">Идентификатор.</param>
        /// <remarks>Если не удалось удалить, то выкидывается исключение.</remarks>
        Task DeleteAsync(int id);
 
        /// <summary>Обновление записи Репозитория.</summary>
        /// <param name="idDto">Экземпляр с данными для обновления.
        /// Идентификатор остаётся неизменным, его поменять невозможно.</param>
        /// <remarks>Если не удалось обновить или создать экземпляр, то выкдывается исключение.</remarks>
        Task UpdateAsync(TId idDto);
 
        /// <summary>Возвращает отражение локального кеша БД.</summary>
        /// <returns>Метод возвращает всегда одby и тот же экземпляр <see cref="ReadOnlyObservableCollection{T}"/>.</returns>
        ReadOnlyObservableCollection<TId> GetObservableCollection();
 
        /// <summary>Асинхронная загрузка локального кеша (Eager loading).</summary>
        /// <returns>Задача в которой выполняется Асинхронная загрузка локального кеша.</returns>
        Task LoadAsync();
 
        /// <summary>Получение всех записей.</summary>
        /// <returns>Последовательность со всеми записями.</returns>
        /// <remarks>В методе производится новый запрос к БД, в отличии от метода <see cref="GetObservableCollection"/>,
        /// в котором возвращается отражение локального кеша без нового запроса в БД.</remarks>
        Task<IEnumerable<TId>> GetAllAsync();
    }
 
    /// <summary>Репозиторий <see cref="IdNameDto"/>.</summary>
    public interface INameRepository<TIdName> : IRepository<TIdName> where TIdName : IdNameDto
    {
        bool IsUnique(string name);
    }
}

namespace Flashcards.Liblary.Repository
{
    /// <summary>Дженерик Репозиторий для БД</summary>
    public class DbNameRepository<TId> : INameRepository<TId> where TId : IdNameDto
    {
        private readonly DbContext context;
        private readonly Func<DbContext> contextCreator;
        private readonly DbSet<TId> dbSet;
 
        /// <summary>Конструктор Репозитория.</summary>
        /// <param name="context">Постоянный Контекст БД, используемый для синхронизации через локальный кеш.</param>
        /// <param name="contextCreator">Функция, создающая новый одноразовый DbContext,
        /// из которого можно получить <see cref="DbSet{TEntity}">DbSet&lt;<typeparamref name="TId"/>&gt;</see>.</param>
        public DbNameRepository(DbContext context, Func<DbContext> contextCreator)
        {

public async Task<bool> IsUnique(string name)
{
    if (await GetAllAsync() is IEnumerable<Word> words)
    {
        return words.Any(w => w.Name == name);
    }
    return false;
}
 
public async Task<IEnumerable<TId>> GetAllAsync() => await Task.Run(() =>
{
    return context.Set<TId>().ToList().Select(b => b);
});

public string Word {  get => Get<string>()!; 
    set 
    {
        ClearErrors();
        if (_wordRepository.IsUnique(value).Result)
        {
            AddError("");
        }
        
        Set(value); 
    }
}

public async Task<bool> IsUnique(string name) => await Task.Run(() =>
{
    return context.Set<TIdName>().Any(w => w.Name == name);
};

private async void ValidateWordAsync()
{
    string word = Word; // кешируется валидируемое значение
    AddError("Процесс валидации"); // Здесь обычно не стринг сообщение, а другой тип.
 
    try
    {
        var erorr = await Task(() =>model.ValidateWord(word));
        if(word != Word)
            return;
 
        // Обработка возращённой ошибки.
    }
    catch
    {
        // Обработка исключений
    }
}

    public abstract class DbRepository<TId> : INameRepository<TId> where TId : IdDto
    {
 
          public abstract Task<bool> IsUnique(string name);

    public abstract class WordDbRepository : INameRepository<Word> 
    {
 
          public override Task<bool> IsUnique(string name) => ....

public string Word {  get => Get<string>()!; 
    set 
    {
        Set(value); 
        ValidateWordAsync();
    }
}

var error = await Task(() =>model.ValidateWord(word));

var error = await model.ValidateWord(word);

public class DbModel : IDbModel
{
    private readonly DbContext context;
    private readonly object locker = new();
 
    public IRepository<Word> Words { get; }
    public IRepository<Set> Sets { get; }
 
    public Task LoadAsync() => Task.Run(() =>
    {
        lock(locker){
        context.Set<Word>().Load(); // В этом месте исключение
        context.Set<Set>().Load();}
    });
 
    /// <summary>Конструктор Репозитория.</summary>
    /// <param name="context">Постоянный Контекст БД используемый для синхронизации через локальный кеш.</param>
    /// <param name="contextCreator">Функция создающая новый одноразовый DbContext из которого можно получить
    /// <see cref="DbSet{TEntity}">DbSet&lt;<typeparamref name="TId"/>&gt;</see>.</param>
    public DbModel(DbContext context, Func<DbContext> contextCreator)
    {
        //context.Database.EnsureCreated();
        this.context = context;
 
        Words = new DbRepository<Word>(context, contextCreator);
        Sets = new DbRepository<Set>(context, contextCreator);
    }
}

public async Task<bool> IsUnique(string name) => await Task.Run(() =>
{
    lock(locker){
        return context.Set<TId>().Any(w => w.Name == name);
    }
});

<CETCompat>false</CETCompat>

using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.ChangeTracking;
using System.Collections.Immutable;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Reflection;
 
namespace Flashcards.Liblary.Repository
{
    /// <summary>Дженерик Репозиторий для БД</summary>
    public class DbRepository<TId> : IRepository<TId> where TId : IdDto
    {
        private readonly DbContext context;
        private readonly Func<DbContext> contextCreator;
        private readonly DbSet<TId> dbSet;
 
        /// <summary>Конструктор Репозитория.</summary>
        /// <param name="context">Постоянный Контекст БД, используемый для синхронизации через локальный кеш.</param>
        /// <param name="contextCreator">Функция, создающая новый одноразовый DbContext,
        /// из которого можно получить <see cref="DbSet{TEntity}">DbSet&lt;<typeparamref name="TId"/>&gt;</see>.</param>
        public DbRepository(DbContext context, Func<DbContext> contextCreator)
        {
            context.Database.EnsureCreated();
            this.context = context;
            dbSet = context.Set<TId>();
            this.contextCreator = contextCreator;
        }
 
        public async Task<TId> AddAsync(TId idDto) => await Task.Run(async () =>
        {
            // Добавление сущности через другой, одноразовый Контекст БД.
            using (DbContext context = contextCreator())
            {
                DbSet<TId> set = context.Set<TId>();
                set.Add(idDto);
                context.SaveChanges();
            }
            // Получение сущности в локальный кеш и её возврат.
            return await dbSet.FindAsync(idDto.Id) ?? throw new Exception("Не добавилась.");
        });
 
        public async Task DeleteAsync(int id) => await Task.Run(async () =>
        {
            // Удаление сущности через другой, одноразовый Контекст БД.
            using (DbContext context = contextCreator())
            {
                DbSet<TId> set = context.Set<TId>();
                TId ent = set.Find(id) ?? throw new Exception("Записи с таким Id нет.");
                set.Remove(ent);
                context.SaveChanges();
            }
            {
                // Обновление локального кеша, если там есть сущность с таким Id.
                TId? ent = await dbSet.FindAsync(id);
                if (ent is not null)
                {
                   await dbSet.Entry(ent).ReloadAsync();
                }
            }
        });
 
        public async Task<IEnumerable<TId>> GetAllAsync() => await Task.Run(() =>
        {
            return context.Set<TId>().ToList().Select(b => b);
        });
 
        private ReadOnlyObservableCollection<TId>? readOnlyObservableCollection;
 
        public ReadOnlyObservableCollection<TId> GetObservableCollection()
        {
            readOnlyObservableCollection ??= new(dbSet.Local.ToObservableCollection());
            return readOnlyObservableCollection;
        }
 
        public async Task UpdateAsync(TId idDto) => await Task.Run(async () =>
        {
            // Обновление записи в БД через другой, одноразовый Контекст БД.
            using (DbContext context = contextCreator()) // Создание одноразового Контекста БД.
            {
                DbSet<TId> set = context.Set<TId>();
 
                _ = set.Update(idDto);
                _ = context.SaveChanges();
            }
 
            // Обновление сущности с уведомлением привязок через PropertyDescriptor об изменении Bird.IsActive.
            // Вариант показан, как альтернативная реализация.
            // В данной задаче, на практике, более лучшим вариантом будет замена сущности.
            EntityEntry<TId>? ent = dbSet.Local.FindEntry(idDto.Id);
            await ent!.ReloadAsync();
            TId tid = await dbSet.FindAsync(idDto.Id) ?? throw new NullReferenceException();
 
            OnAllPropertiesChanged(tid);
        });
 
        public async Task<bool> IsUnique(string name) => await Task.Run(() =>
        {
            using var context = contextCreator();
            return context.Set<TId>().Any(w => w.Name == name);
        });
 
        private static readonly PropertyChangedEventArgs args = new(string.Empty);
 
        // Создание метода для уведомления об обновлении всех свойств Bird
        private static readonly ImmutableArray<Action<object, EventArgs>> allPropertiesChangedHandler;
 
        static DbRepository()
        {
            var onValueChanged = typeof(PropertyDescriptor)
                .GetMethod($"OnValueChanged", BindingFlags.Instance | BindingFlags.NonPublic)!;
            allPropertiesChangedHandler = TypeDescriptor.GetProperties(typeof(TId))
                .Cast<PropertyDescriptor>()
                .Select(onValueChanged.CreateDelegate<Action<object, EventArgs>>)
                .ToImmutableArray();
        }
 
        // Метод обновляющий все привязки к Bird.
        private static void OnAllPropertiesChanged(TId ent)
        {
            foreach (var p in allPropertiesChangedHandler)
            {
                p(ent, args);
            }
        }
 
        public async Task LoadAsync() => await Task.Run(async () => await dbSet.LoadAsync());
    }
}

            birdsRepository.RepChanged += OnbirdsRepositoryChanged;