WPF

Items.CollectionChanged += ItemsChanged;

private void ItemsCHanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
        {
            if(e.NewItems != null)
            {
                foreach(Item item in e.NewItems)
                {
                    //Subscribe to property changed
                    item.PropertyChanged += ItemChanged;
                }
            }
            if (e.OldItems != null)
            {
                foreach (Item item in e.OldItems)
                {
                    //Ensure you unsubscribe
                    item.PropertyChanged -= ItemChanged;
                }
            }
        }

        private void ItemChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
        {
           if(e.PropertyName == "IsChecked")
           {
               //Do work here
           }
        }

public interface IDialogService<TDialogType, TViewModelType>
    where TDialogType : Window
    where TViewModelType : DialogBaseViewModel
{
    void RegisterView(Type dialogType, Type viewModelType);
    bool? ShowDialog(TViewModelType viewModel);
}

public class DialogService<TDialogType, TViewModelType> : IDialogService<TDialogType, TViewModelType>
    where TDialogType : Window
    where TViewModelType : DialogBaseViewModel
{

    private Dictionary<Type, Type> registry = new Dictionary<Type, Type>();

    public void RegisterView(Type dialogType, Type viewModelType)
    {
        if (!dialogType.IsSubclassOf(typeof(TDialogType)))
        {
            throw new ArgumentException(string.Format("The dialogType must be a subclass of type {0}.", typeof(TDialogType).Name), "dialogType");
        }
        if (!viewModelType.IsSubclassOf(typeof(TViewModelType)))
        {
            throw new ArgumentException(string.Format("The viewModelType must be a subclass of type {0}.", typeof(TViewModelType).Name), "viewModelType");
        }

        bool exists = registry.Where(x => x.Key == dialogType).Any();

        if (!exists)
        {
            registry.Add(dialogType, viewModelType);
        }
    }

    public bool? ShowDialog(TViewModelType viewModel)
    {
        Type dialogType = registry.Where(x => x.Value == viewModel.GetType()).Select(x => x.Key).FirstOrDefault();
        var dialog = (TDialogType)TypeDescriptor.CreateInstance(null, dialogType, null, null);


        dialog.DataContext = viewModel;
        dialog.ShowDialog();
        bool? result = dialog.DialogResult;
        return result;
    }
}

DialogService<Window, DialogBaseViewModel> dialogService = new DialogService<Window, DialogBaseViewModel>();

dialogService.RegisterView(typeof(PersonView), typeof(PersonViewModel));
dialogService.RegisterView(typeof(InvoiceView), typeof(InvoiceViewModel));
dialogService.RegisterView(typeof(AnotherView), typeof(AnotherViewModel));

dialogService.ShowDialog(new PersonViewModel());

DialogService<Window, _DialogBaseViewModel>.RegisterView(typeof(SQLConnectionView), typeof(SQLConnectionViewModel));

bool? dialogResult = DialogService<Window, _DialogBaseViewModel>.ShowDialog(new SQLConnectionViewModel());

public static class DialogService
{
    private static Dictionary<Type, Type> registry = new Dictionary<Type, Type>();

    public static void RegisterView(Type dialogType, Type viewModelType)
    {
        //Rest of the implementation here
    }

    public static bool? ShowDialog<TViewModelType>(TViewModelType viewModel) where TViewModelType : DialogBaseViewModel
    {
        //Rest of the implementation here
    }
}

public static class DialogService
{
    private static Dictionary<Type, Type> registry = new Dictionary<Type, Type>();

    public static void RegisterDialog(Type dialogType, Type viewModelType)
    {
        if (!dialogType.IsSubclassOf(typeof(Window)))
        {
            throw new ArgumentException("The dialogType must be a subclass of type Window.");
        }

        bool exists = registry.Where(x => x.Key == dialogType).Any();

        if (!exists)
        {
            registry.Add(dialogType, viewModelType);
        }
    }

    public static bool? ShowDialog<TViewModelType>(TViewModelType viewModel) where TViewModelType : _DialogBaseViewModel
    {
        Type dialogType = registry.Where(x => x.Value == viewModel.GetType()).Select(x => x.Key).FirstOrDefault();
        var dialog = (Window)Activator.CreateInstance(dialogType);

        dialog.DataContext = viewModel;
        dialog.ShowDialog();
            
        bool? result = dialog.DialogResult;

        return result;
    }
}

DialogService.RegisterDialog(typeof(PersonView), typeof(PersonViewModel));
bool? dialogResult = DialogService.ShowDialog(new PersonViewModel());

<Window x:Class="Osprey.UI.WPF.Views.MyDialog"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:i="http://schemas.microsoft.com/expression/2010/interactivity"
        xmlns:ei="http://schemas.microsoft.com/expression/2010/interactions"
        xmlns:behaviors="clr-namespace:Osprey.UI.WPF.Classes.Behaviors"
        Title="My Dialog" 
        xmlns:xc="clr-namespace:Osprey.UI.WPF.Classes"
        xc:DialogCloser.DialogResult="{Binding DialogResult}">

public class DialogResultEx
{
    public bool? DialogResult { get; set; }
    public object DialogData { get; set; }
}

public static DialogResultEx ShowDialog<TViewModelType>(TViewModelType viewModel) where TViewModelType : _DialogBaseViewModel
    {
        Type dialogType = registry.Where(x => x.Value == viewModel.GetType()).Select(x => x.Key).FirstOrDefault();
        var dialog = (Window)Activator.CreateInstance(dialogType);
 
        dialog.DataContext = viewModel;
        dialog.ShowDialog();
            
        DialogResultEx dlgResult = new DialogResult();
        dlgResult.DialogResult = dialog.DialogResult;
        dlgResult.DialogData = viewModel.WhateverData;    //Modify as needed
 
        return dlgResult;
    }

public class DialogResultEx
{
    public bool? DialogResult { get; set; }
    public object DialogData { get; set; }

    public static implicit operator bool?(DialogResultEx dlgResult)
    {
        return dlgResult.DialogResult;
    }
}

DialogResultEx dlgResult = new DialogResultEx();
dlgResult.DialogResult = dialog.DialogResult;
dlgResult.DialogData = viewModel.WhateverData;    //Modify as needed

public abstract class _DialogBaseViewModel
{
    public virtual object DialogData { get { return null; } }
}

public class InputDialogViewModel : _DialogBaseViewModel
{
    private string _textData = string.Empty;

    public override object DialogData
    {
        get
        {
            return _textData;
        }
    }
}

public static class DialogService
{
    private static Dictionary<Type, Type> registry = new Dictionary<Type, Type>();

    public static void RegisterDialog(Type dialogType, Type viewModelType)
    {
        if (!dialogType.IsSubclassOf(typeof(Window)))
        {
            throw new ArgumentException("The dialogType must be a subclass of type Window.");
        }

        bool exists = registry.Where(x => x.Key == dialogType).Any();

        if (!exists)
        {
            registry.Add(dialogType, viewModelType);
        }
    }

    public static bool? ShowDialog<TViewModelType>(TViewModelType viewModel) where TViewModelType : _DialogBaseViewModel
    {
        Type dialogType = registry.Where(x => x.Value == viewModel.GetType()).Select(x => x.Key).FirstOrDefault();
        var dialog = (Window)Activator.CreateInstance(dialogType);

        dialog.DataContext = viewModel;
        dialog.ShowDialog();

        return dialog.DialogResult.Value;
    }
}

public static class DialogManager
{
    static DialogManager()
    {
        // Register all dialogs here
        DialogService.RegisterDialog(typeof(SQLConnectionView), typeof(SQLConnectionViewModel));
    }

    public static string OpenSQLConnectionDialog()
    {
        string result = string.Empty;

        SQLConnectionViewModel vm = new SQLConnectionViewModel();

        bool? dialogResult = DialogService.ShowDialog(vm);

        if (dialogResult.Value)
        {
            result = vm.ConnectionString;
        }

        return result;
    }
}

var connString = DialogManager.OpenSQLConnectionDialog();