Взаимодействие UserControl, ContentControl и SelectedItem в Listbox

private AgencyModel _selectedAgency;
public AgencyModel SelectedAgency
{
    get { return _selectedAgency; }
    set { Set(ref _selectedAgency, value); }
}

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Tasks;
 
namespace InstnceVM
{
    public class MainVM : INotifyPropertyChanged
    {
        public static MainVM Instanse { get; set; }
        public static string InstansData { get; set; }
        public MainVM()
        {
            Instanse = this;
            InstansData = Data;
        }
 
        private string _data;
 
        public string Data
        {
            get => _data;
            set
            {
                if (value == _data) return;
                _data = value;
                OnPropertyChanged();
            }
        }
 
        public event PropertyChangedEventHandler? PropertyChanged;
 
        protected virtual void OnPropertyChanged([CallerMemberName] string? propertyName = null)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }
 
        protected bool SetField<T>(ref T field, T value, [CallerMemberName] string? propertyName = null)
        {
            if (EqualityComparer<T>.Default.Equals(field, value)) return false;
            field = value;
            OnPropertyChanged(propertyName);
            return true;
        }
    }
}

      public static MainVM Instanse { get; set; }

    public static string InstansData { get; set; }

using System.Windows;
 
namespace DBClient.Services
{
    public class DialogCloser
    {
        private static void DialogResultChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            if (d is Window window)
                window.DialogResult = e.NewValue as bool?;
        }
 
        public static readonly DependencyProperty DialogResultProperty =
            DependencyProperty.RegisterAttached(
                "DialogResult",
                typeof(bool?),
                typeof(DialogCloser),
                new PropertyMetadata(DialogResultChanged));
 
        public static void SetDialogResult(Window target, bool? value)
        {
            target.SetValue(DialogResultProperty, value);
        }
    }
}

using System.ComponentModel;
 
namespace Services.Interfaces
{
    public interface IBaseViewModel : INotifyPropertyChanged
    {
    }
}

namespace Services.Interfaces
{
    public interface IBaseDialogViewModel : IBaseViewModel
    {
        bool? DialogResult { get; set; }
    }
}

using System.ComponentModel;
using System.Runtime.CompilerServices;
 
using Services.Interfaces;
 
namespace VModels.Base
{
    public class BaseViewModel : INotifyPropertyChanged, IBaseViewModel
    {
        public event PropertyChangedEventHandler PropertyChanged;
 
        protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
            => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
 
        protected virtual bool Set<T>(ref T field, T value, [CallerMemberName] string PropertyName = null)
        {
            if (Equals(field, value))
                return false;
 
            field = value;
 
            OnPropertyChanged(PropertyName);
 
            return true;
        }
    }
}

using Services.Interfaces;
 
using VModels.Input;
 
namespace VModels.Base
{
    public abstract class BaseDialogViewModel : BaseViewModel, IBaseDialogViewModel
    {
        private bool? _dialogResult;
        public bool? DialogResult
        {
            get => _dialogResult;
            set => Set(ref _dialogResult, value);
        }
 
        private RelayCommand _saveCommand;
        public RelayCommand SaveCommand
            => _saveCommand ??= new RelayCommand(Save);
 
        protected abstract void Save(object obj);
    }
}

using System;
using System.Threading.Tasks;
 
namespace Services.Interfaces
{
    // Сервис очереди выполнения асинхронных методов. Позволяет запускать их из конструктора и в свойствах
    public interface IBackgroundTaskQueue
    {
        void QueueBackgroundWorkItem(Func<Task> workItem);
        void Start();
        void Stop();
    }
}

namespace Services.Interfaces
{
    // Сервис для поучения VM из регистрации DI
    public interface IViewModelFactory
    {
        T CreateViewModel<T>() where T : IBaseViewModel;
    }
}

namespace Services.Interfaces
{
    // Сервис управления окнами
    public interface IWindowService
    {
        void ShowErrorMessage(string message, string caption);
        void ShowInfoMessage(string message, string caption);
        bool ShowQuestionMessage(string message, string caption);
        bool ShowWarningMessage(string message, string caption);
        void ShowWindow(IBaseViewModel viewModel);
        bool? ShowDialog(IBaseViewModel viewModel);
    }
}

using System.Windows;
using System.Windows.Controls;
 
using Services.Interfaces;
 
namespace DBClient.Services.Interfaces
{
    public interface IViewModelsService
    {
        Window GetWindow(IBaseViewModel viewModel);
        ContentControl GetControl(IBaseViewModel viewModel);
        IViewModelsService Register<TViewModelType, TViewType>()
            where TViewType : ContentControl, new()
            where TViewModelType : IBaseViewModel;
    }
}

using System;
using System.Collections.Generic;
using System.Windows;
using System.Windows.Controls;
 
using DBClient.Services.Interfaces;
 
using Services.Interfaces;
 
namespace DBClient.Services
{
    public class ViewModelsService : IViewModelsService
    {
        private readonly Dictionary<Type, Func<ContentControl>> _dict = new Dictionary<Type, Func<ContentControl>>();
 
        public IViewModelsService Register<TViewModelType, TViewType>()
            where TViewType : ContentControl, new()
            where TViewModelType : IBaseViewModel
        {
            _dict[typeof(TViewModelType)] = () => new TViewType();
 
            return this;
        }
 
        public Window GetWindow(IBaseViewModel viewModel)
        {
            var result = GetControl(viewModel);
 
            if (result is not Window window)
                throw new Exception($"{result.GetType()} is not window");
 
            return window;
        }
 
        public ContentControl GetControl(IBaseViewModel viewModel)
        {
            var parentTypes = GetParentTypes(viewModel.GetType());
 
            foreach (var parentType in parentTypes)
            {
                if (_dict.TryGetValue(parentType, out var res))
                    return res();
            }
 
            throw new Exception($"ViewModel {viewModel.GetType().Name} is not registered");
        }
 
        private static IEnumerable<Type> GetParentTypes(Type type)
        {
            // is there any base type?
            if (type == null)
                yield break;
 
            yield return type;
 
            // return all implemented or inherited interfaces
            foreach (var i in type.GetInterfaces())
                yield return i;
 
            // return all inherited types
            var currentBaseType = type.BaseType;
 
            while (currentBaseType != null)
            {
                yield return currentBaseType;
                currentBaseType = currentBaseType.BaseType;
            }
        }
    }
}

using System;
 
using Microsoft.Extensions.DependencyInjection;
 
using Services.Interfaces;
 
namespace DBClient.Services
{
    public class ViewModelFactory : IViewModelFactory
    {
        private readonly IServiceProvider _serviceProvider;
 
        public ViewModelFactory(IServiceProvider serviceProvider)
        {
            _serviceProvider = serviceProvider;
        }
 
        public T CreateViewModel<T>() where T : IBaseViewModel
            => _serviceProvider.GetService<T>();
    }
}

using System;
using System.IO;
using System.Linq;
using System.Windows;
 
using DBClient.Services.Interfaces;
 
using Microsoft.Win32;
 
using Services.Interfaces;
 
using VModels.WindowsVM;
 
namespace DBClient.Services
{
    internal class WindowService : IWindowService
    {
        private readonly IViewModelsService _viewModelsService;
 
        public WindowService(IViewModelsService viewModelsService)
        {
            _viewModelsService = viewModelsService;
        }
 
        public Window GetWindow(IBaseViewModel viewModel)
        {
            var window = _viewModelsService.GetWindow(viewModel);
 
            window.DataContext = viewModel;
 
            return window;
        }
 
        public void ShowWindow(IBaseViewModel viewModel)
            => GetWindow(viewModel).Show();
 
        public bool? ShowDialog(IBaseViewModel viewModel)
            => GetWindow(viewModel).ShowDialog();
 
        public void ShowErrorMessage(string message, string caption)
            => MessageBox.Show(message, caption, MessageBoxButton.OK, MessageBoxImage.Error);
 
        public void ShowInfoMessage(string message, string caption)
            => MessageBox.Show(message, caption, MessageBoxButton.OK, MessageBoxImage.Information);
 
        public bool ShowQuestionMessage(string message, string caption)
        {
            if (MessageBox.Show(message, caption, MessageBoxButton.YesNo, MessageBoxImage.Question) == MessageBoxResult.Yes)
                return true;
            else
                return false;
        }
 
        public bool ShowWarningMessage(string message, string caption)
        {
            if (MessageBox.Show(message, caption, MessageBoxButton.YesNo, MessageBoxImage.Warning) == MessageBoxResult.Yes)
                return true;
            else
                return false;
        }
    }
}

using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;

namespace DBClient
{
    /// <summary>
    /// Interaction logic for App.xaml
    /// </summary>
    public partial class App : Application
    {
        // Коллекция наших сервисов DI
        public IServiceProvider Services { get; }
        // Конфигурация нашего приложения
        public IConfiguration Configuration { get; }
 
        // Объект нашего приложения
        public static new App Current => (App)Application.Current;
 
        public App()
        {
            Configuration = GetConfiguration();
            Services = ConfigureServices();
 
            InitializeComponent();
        }
 
        // Загружаем конфигурацию
        private static IConfiguration GetConfiguration()
        {
            IConfigurationBuilder builder = new ConfigurationBuilder()
                .SetBasePath(AppDomain.CurrentDomain.BaseDirectory)
                .AddJsonFile("appsettings.json");
 
            return builder.Build();
        }
 
        // Запускаем сервисы
        private static IServiceProvider ConfigureServices()
        {
            ServiceCollection services = new ServiceCollection();
 
            services
                .AddSingleton(Current.Configuration)
                .AddSingleton<IViewModelsService, ViewModelsService>()
                .AddSingleton<IWindowService, WindowService>()
                .AddSingleton<IBackgroundTaskQueue, BackgroundTaskQueue>()
                .AddSingleton<IViewModelFactory, ViewModelFactory>();
 
            return services.BuildServiceProvider();
        }
    }
}

using System.Threading;
 
using DTOClassLibrary.DTO;
 
namespace Services.Interfaces.DialogsVM
{
    public interface ICPSContractEditDialogVM : IBaseDialogViewModel
    {
        // Свойства для взаимодействия МЬ с остальным кодом приложения
        CPSContract Contract { get; set; }
        bool? EditMode { get; set; }
        bool? IsLoaded { get; set; }
        SynchronizationContext ViewContext { get; set; }
    }
}

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
 
using DALibrary.Interfaces;
 
using DTOClassLibrary.DTO;
 
using Services.Interfaces;
using Services.Interfaces.DialogsVM;
 
using VModels.Base;
 
namespace VModels.DialogsVM
{
    // Наследуемся от базавого класса и подключаем интерфейс для взамодействия
    public class CPSContractEditDialogVM : BaseDialogViewModel, ICPSContractEditDialogVM
    {
        #region Private ViewModel members region
 
        private readonly IWindowService _windowService;
        private readonly IBackgroundTaskQueue _taskQueue;
        private readonly IMainDA _mainDA;
 
        #endregion
 
        #region ViewModel properties for binding UI elements
 
        private CPSContract _contract;
        private bool? _editMode;
        private DateTime? _selectedContractDate;
        private string _contractNumber = string.Empty;
        private string _contractName = string.Empty;
        private string _contractType = string.Empty;
        private string _selectedContractType;
        private bool? _isLoaded;
 
        public SynchronizationContext ViewContext { get; set; }
        public CPSContract Contract
        {
            get => _contract;
            set => Set(ref _contract, value);
        }
        public bool? EditMode
        {
            get => _editMode;
            set => Set(ref _editMode, value);
        }
        public DateTime? SelectedContractDate
        {
            get => _selectedContractDate;
            set => Set(ref _selectedContractDate, value);
        }
        public string ContractNumber
        {
            get => _contractNumber;
            set => Set(ref _contractNumber, value);
        }
        public string ContractName
        {
            get => _contractName;
            set => Set(ref _contractName, value);
        }
        public string ContractType
        {
            get => _contractType;
            set => Set(ref _contractType, value);
        }
        public string SelectedContractType
        {
            get => _selectedContractType;
            set => Set(ref _selectedContractType, value);
        }
        public List<string> ContractTypes { get; } = new List<string>();
        public bool? IsLoaded
        {
            get => _isLoaded;
            set
            {
                if (Set(ref _isLoaded, value))
                {
                    if (IsLoaded == true)
                    {
                        switch (EditMode)
                        {
                            case true:
                                SelectedContractDate = Contract.ContractDate;
                                ContractNumber = Contract.ContractNumber;
                                ContractName = Contract.ContractName;
                                ContractType = Contract.ContractType;
 
                                _taskQueue.QueueBackgroundWorkItem(LoadVMData);
                                break;
 
                            case false:
                                Contract = new CPSContract();
 
                                _taskQueue.QueueBackgroundWorkItem(LoadVMData);
                                break;
                        }
                    }
                }
            }
        }
 
        #endregion
 
        #region RelayCommand region
 
        #endregion
 
        #region Methods region
 
        // Инжектим нужные сервисы в конструктор VM с помощью DI
        public CPSContractEditDialogVM(IWindowService windowService,
                                       IBackgroundTaskQueue taskQueue,
                                       IMainDA mainDA)
        {
            _windowService = windowService;
            _taskQueue = taskQueue;
            _mainDA = mainDA;
        }
 
        // Метод который отрабатывает при нажатии кнопки Ok
        protected override void Save(object obj)
        {
            if (SelectedContractDate != null && !string.IsNullOrEmpty(ContractNumber) && !string.IsNullOrEmpty(ContractName) && !string.IsNullOrEmpty(ContractType))
            {
                Contract.ContractDate = SelectedContractDate.Value.Date;
                Contract.ContractNumber = ContractNumber;
                Contract.ContractName = ContractName;
                Contract.ContractType = ContractType;
 
                DialogResult = true;
            }
            else
            {
                _windowService.ShowErrorMessage("Все поля должны быть заполнены!", "Ошибка");
            }
        }
 
        private async Task LoadVMData()
        {
            try
            {
                List<string> strings = await _mainDA.CPSDataDA.GetContractTypesAsync();
 
                ViewContext.Send(vc =>
                {
                    if (ContractTypes.Count > 0)
                        ContractTypes.Clear();
 
                    strings.ForEach(s => ContractTypes.Add(s));
                }, null);
            }
            catch (Exception ex)
            {
                _windowService.ShowErrorMessage(ex.Message, "Ошибка");
            }
        }
 
        #endregion
    }
}

// Запускаем сервисы
private static IServiceProvider ConfigureServices()
{
    ServiceCollection services = new ServiceCollection();
 
    services
        .AddSingleton(Current.Configuration)
        .AddSingleton<IViewModelsService, ViewModelsService>()
        .AddSingleton<IWindowService, WindowService>()
        .AddSingleton<IBackgroundTaskQueue, BackgroundTaskQueue>()
        .AddSingleton<IViewModelFactory, ViewModelFactory>()
        // Запускаем VM как сервис по требованию
        .AddTransient<IMainWindowVM, MainWindowVM>()
        .AddTransient<ICPSContractEditDialogVM, CPSContractEditDialogVM>();
 
    return services.BuildServiceProvider();
}

// Переопределение базового метода Application
protected override void OnStartup(StartupEventArgs e)
{
    base.OnStartup(e);
 
    // Получаем нужные сервисы мз DI
    IViewModelsService _viewModelsService
        = Current.Services.GetService<IViewModelsService>();
    IBackgroundTaskQueue _taskQueue
        = Current.Services.GetService<IBackgroundTaskQueue>();
    
    // Связываем VM и окна
    _viewModelsService
        .Register<MainWindowVM, MainWindow>()
        .Register<CPSContractEditDialogVM, CPSContractEditDialog>();
 
    // Запускаем сервис очереди асинхронных методов
    _taskQueue.Start();
 
    // Подключаем VM главного окна
    MainWindow = new MainWindow { DataContext = Current.Services.GetService<IMainWindowVM>() };
    // Показываем главное окно
    MainWindow.Show();
}

// Метод в VM
private async Task AddContractAsync()
{
    try
    {
        // Получаем VM из сервиса
        var vm = _viewModelFactory.CreateViewModel<ICPSContractEditDialogVM>();
 
        // Устанавливаем свойства
        vm.EditMode = false;
 
        // Показываем диалог
        _windowService.ShowDialog(vm);
 
        // Если Ok
        if (vm.DialogResult == true)
        {
            // Получаем данные из диалога
            vm.Contract.EObjectID = CurrentEObject.EObjectID;
            vm.Contract.BranchID = (int)Branch;
 
            // И что-то с ними делаем
            await _mainDA.CPSDataDA.AddContractAsync(vm.Contract);
 
            ViewContext.Send(vc =>
            {
                Contracts.Add(vm.Contract);
            }, null);
 
            SelectedContract = Contracts.FirstOrDefault(c => c.ContractID == vm.Contract.ContractID);
        }
    }
    catch (Exception ex)
    {
        _windowService.ShowErrorMessage(ex.Message, "Ошибка");
    }
}

   public class HomeView : INPC
   {
       private string _Selected;
       public string Selected
       {
           get => _Selected;
           set
           {
               _Selected = value;
               RaisePropertyChanged(nameof(SelectedAgency));
           }
       }
       public HomeView()
       {
           Selected = "Какие то данные";
       }
   }