Как внедрить модель во 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 string Visibility
{
    get { return bird.Departure != "" ? "Hidden" : "Visible"; }
}

public async Task DeleteBird()
{
    BirdDeparture = Departure; //
    bird.IsAlive = false;
    await birdRepository.UpdateAsync(bird);
    navigationService.NavigateTo(App.ServiceProvider!.GetRequiredService<BirdsViewModel>());
}

using System;
using System.Threading.Tasks;
 
namespace Services.Interfaces
{
    public interface IBackgroundTaskQueue
    {
        void QueueBackgroundWorkItem(Func<Task> workItem);
        void Start();
        void Stop();
    }
}

using System;
using System.Collections.Concurrent;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;
 
using Services.Interfaces;
 
namespace Services
{
    public class BackgroundTaskQueue : IBackgroundTaskQueue
    {
        private readonly ConcurrentQueue<Func<Task>> _workItems = new ConcurrentQueue<Func<Task>>();
        private readonly SemaphoreSlim _signal = new SemaphoreSlim(0);
        private readonly CancellationTokenSource _stopTokenSource = new CancellationTokenSource();
        private Task _processTask;
 
        private async Task Process()
        {
            CancellationToken stopToken = _stopTokenSource.Token;
 
            while (!stopToken.IsCancellationRequested)
            {
                try
                {
                    await _signal.WaitAsync(stopToken);
                    _workItems.TryDequeue(out var task);
                    await await Task.Factory.StartNew(task);
                }
                catch (OperationCanceledException)
                {
                    return;
                }
                catch (Exception ex)
                {
                    Trace.WriteLine(ex.Message);
                }
            }
        }
 
        public void QueueBackgroundWorkItem(Func<Task> workItem)
        {
            if (workItem == null)
            {
                throw new ArgumentNullException(nameof(workItem));
            }
 
            _workItems.Enqueue(workItem);
            _signal.Release();
        }
 
        public void Start()
        {
            _processTask = Task.Run(Process);
        }
 
        public void Stop()
        {
            _stopTokenSource.Cancel();
            _processTask?.GetAwaiter().GetResult();
        }
    }
}

.AddSingleton<IBackgroundTaskQueue, BackgroundTaskQueue>()

public class SomeItem
{
    public string SomeProperty ....
 
    public SomeItem()
    {
        SomeLongMethod();
    }
 
    private void SomeLongMethod()
    {
        Thread.Sleep(5000); // Имитация долго выполнения.
 
        SomeProperty = result;
    }
}

  .... void OnStartup(.....)
  {
      // чё-то там
 
      wind.DataContext = new SomeItem();
      Wind.Show();
  }

public class SomeItem
{
    public string SomeProperty ....
 
    public SomeItem()
    {
        // SomeLongMethod();
    }
 
    public async Task SomeLongMethodAsync() => await Task.Run(SomeLongMethod);
    private void SomeLongMethod()
    {
        Thread.Sleep(5000); // Имитация долго выполнения.
 
        SomeProperty = result;
    }
}

  ....async void OnStartup(.....)
  {
      // чё-то там
 
      SomeItem item = new();    // Получили ссылку на экземпляр
      wind.DataContext = new SomeItem(); // Предоставили ссылку на экземпляр
      Wind.Show();                 // Показали Окно
 
      await item.SomeLongMethodAsync(); // Запустили инициализацию
  }

public RelayCommand ToABViewCommand => new RelayCommand
    (
        execute => Navigation.NavigateTo(App.ServiceProvider!.GetRequiredService<ABViewModel>()
    ));
public RelayCommand ToBirdsViewCommand => new RelayCommand
    (
        execute => Navigation.NavigateTo(App.ServiceProvider!.GetRequiredService<BirdsViewModel>()
    ));

// Проверка состояния свойства
public SynchronizationContext ViewContext
{
    get => _viewContext;
    set
    {
        if (Set(ref _viewContext, value))
        {
            // Если всё нормально, то запускаем инициализацию данных VM
            if (ViewContext != null)
                _taskQueue.QueueBackgroundWorkItem(LoadVMDataAsync);
        }
    }
}
 
// Метод загрузки данных из БД для работы VM
private async Task LoadVMDataAsync()
{
    try
    {
        List<PPWorkHBGroup> groups = await _mainDA.PPWorkHBDA.GetPPWorkGroupsAsync(Branch, EObject);
        List<LaborHBType> types = await _mainDA.LaborHBTypeDA.GetAllAsync(Branch, EObject);
 
        ViewContext.Send(_ =>
        {
            if (PPGroups.Count > 0)
                PPGroups.Clear();
 
            if (LaborHBTypes.Count > 0)
                LaborHBTypes.Clear();
 
            if (groups.Count > 0)
                groups.ForEach(g => PPGroups.Add(g));
 
            if (types.Count > 0)
                types.ForEach(t => LaborHBTypes.Add(t));
 
            PPGroupsLoaded?.Invoke(this, EventArgs.Empty);
        }, null);
    }
    catch (Exception ex)
    {
        _windowService.ShowErrorMessage(ex.Message, "Ошибка");
    }
}

public class Locator : ViewModelBase
{
    private SomeViewModel _mainVM;
    public SomeViewModel MainVM {get => _mainVM; set => Set(ref _mainVM, value);}
}