WPF MVVM ComboBox Data Binding

    public class RandomColorModel : OnPropertyChangedClass
    {
        private static readonly Random random = new Random();
        private static readonly string[] namesAllColors = typeof(Brushes)
            .GetProperties()
            .Select(prop => prop.Name)
            .ToArray();
        public ObservableCollection<string> RandomColors { get; } = new ObservableCollection<string>();
 
        public void GenerateRandomColors(uint count)
        {
            RandomColors.Clear();
            foreach (string name in namesAllColors.OrderBy(x => random.Next()).Take((int)count))
                RandomColors.Add(name);
        }
    }

    public class RandomColorVM : OnPropertyChangedClass
    {
        private uint _countColors;
        private string _selectColor;
        private RelayCommand _selectColorCommand;
        RandomColorModel model = new RandomColorModel();
 
        public IEnumerable<string> RandomColors => model.RandomColors;
        public uint CountColors { get => _countColors; set { _countColors = value; OnPropertyChanged(); } }
 
        public string SelectColor { get => _selectColor; set { _selectColor = value; OnPropertyChanged(); } }
        public RelayCommand GenerateRandomColorsCommand => _selectColorCommand ?? (_selectColorCommand = new RelayCommand(GenerateRandomColorsMetod, GenerateRandomColorsCanMetod));
 
        private bool GenerateRandomColorsCanMetod(object parameter)
            => uint.TryParse(parameter?.ToString(), out uint _tmp);
 
        private void GenerateRandomColorsMetod(object parameter)
        {
            if (GenerateRandomColorsCanMetod(parameter))
                model.GenerateRandomColors(uint.Parse(parameter.ToString()));
            SelectColor = null;
        }
 
        public RandomColorVM() => GenerateRandomColorsMetod(CountColors = 5);
    }

ObservableCollection<GroupMail> groupmaillist;
        public ObservableCollection<GroupMail> GetGroupMailList()
        {
            return groupmaillist;
        }
 
public async Task LoadGroupMailList()
        {
            await Task.Delay(1000);
            ///Далее начинаем загружать данные из БД и заносить в список
            groupmaillist = new ObservableCollection<GroupMail>()
            {
                new GroupMail { group_mail_id = 1, group_mail_header = "Отдел кадров", group_mail_description="Рассылка для отделов кадров"},
                new GroupMail { group_mail_id = 2, group_mail_header = "Отдел аналитики", group_mail_description = "Рассылка отдела аналитики" },
                new GroupMail { group_mail_id = 3, group_mail_header = "Отдел продаж", group_mail_description = "Рассылка отдела продаж" },
            };
            OnPropertyChanged("Список групп загружен успешно");
            Logger.Logbox += "Список групп загружен успешно";
        }

 public ObservableCollection<string> GetGroupIE()
        {
            foreach (var item in groupmaillist)
            {
                GroupIE.Add(item.group_mail_header);
            }
            return GroupIE;
        }

        
public IEnumerable<string> GroupIE => GetGroupIE();
public ObservableCollection<string> GetGroupIE()
        {
            var templist = new ObservableCollection<string>();
            foreach (var item in Model.groupmaillist)
            {
                templist.Add(item.group_mail_header);
            }
            return templist;
        }

    public class PropertyChangedDataEventArgs : PropertyChangedEventArgs
    {
        public object RemoveData { get; set; }
        public object AddData { get; set; }
 
        public PropertyChangedDataEventArgs(string propertyName)
            : base(propertyName) { }
        public PropertyChangedDataEventArgs(string propertyName, object removeData, object addData)
            : this(propertyName)
        {
            RemoveData = removeData;
            AddData = addData;
        }
    }

    /// <summary>Базовый класс с реализацией INPC </summary>
    public abstract class OnPropertyChangedClass : INotifyPropertyChanged
    {
        /// <summary>Событие для извещения об изменения свойства</summary>
        public event PropertyChangedEventHandler PropertyChanged;
 
        /// <summary>Метод для вызова события извещения об изменении свойства</summary>
        /// <param name="propertyName">Изменившееся свойство</param>
        public void OnPropertyChanged([CallerMemberName]string propertyName = "") =>
                    PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
 
        /// <summary>Метод для вызова события извещения об изменении свойства
        /// с передачей дополнительных данных</summary>
        /// <param name="propertyName">Изменившееся свойство</param>
        /// <param name="removeData">Удаляемые данные</param>
        /// <param name="addData">Добавляемые данные</param>
        public void OnPropertyChanged(string propertyName, object removeData, object addData) =>
                    PropertyChanged?.Invoke(this, new PropertyChangedDataEventArgs(propertyName, removeData, addData));
 
    }

    public class RandomColorModel : OnPropertyChangedClass
    {
        private static readonly Random random = new Random();
        public static readonly IEnumerable<string> NamesAllColors = typeof(Brushes)
            .GetProperties()
            .Select(prop => prop.Name)
            .ToArray();
        public IEnumerable<string> RandomColors => randomColors;
        private List<string> randomColors = new List<string>();
 
        private void GenerateRandomColors(uint count)
        {
            lock (randomColors)
            {
                Thread.Sleep(2000);
                IEnumerable<string> colors = randomColors.ToArray();
                randomColors.Clear();
                OnPropertyChanged("RemoveColors", colors, null);
 
                Thread.Sleep(2000);
                colors = NamesAllColors.OrderBy(x => random.Next()).Take((int)count).ToArray();
                randomColors.AddRange(colors);
                OnPropertyChanged("AddColors", null, colors);
            }
        }
        public async void GenerateRandomColorsAsync(uint count)
            => await Task.Run(() => GenerateRandomColors(count));
 
        public async void AddColorsAsync(string color)
            => await Task.Run(() => AddColors(color));
        private void AddColors(string color)
        {
            lock (randomColors)
            {
                Thread.Sleep(2000);
                if (!randomColors.Contains(color) && NamesAllColors.Contains(color))
                {
                    randomColors.Add(color);
                    OnPropertyChanged("AddColors", null, new string[] { color });
                }
            }
        }
 
        public async void RemoveColorsAsync(string color)
            => await Task.Run(() => RemoveColors(color));
        private void RemoveColors(string color)
        {
            Thread.Sleep(2000);
            lock (randomColors)
            {
                if (randomColors.Contains(color))
                {
                    randomColors.Add(color);
                    OnPropertyChanged("RemoveColors", new string[] { color }, null);
                }
            }
        }
    }

    public class RandomColorVM : OnPropertyChangedClass
    {
        private uint _countColors;
        private string _selectColor;
        private RelayCommand _selectColorCommand;
        RandomColorModel model/* = new RandomColorModel()*/;
        private RelayCommand _addColorCommand;
        private RelayCommand _removeColorCommand;
 
        public ObservableCollection<string> RandomColors { get; } = new ObservableCollection<string>();
        public uint CountColors { get => _countColors; set { _countColors = value; OnPropertyChanged(); } }
 
        public string SelectColor { get => _selectColor; set { _selectColor = value; OnPropertyChanged(); } }
        public RelayCommand GenerateRandomColorsCommand => _selectColorCommand ?? (_selectColorCommand = new RelayCommand(GenerateRandomColorsMetod, GenerateRandomColorsCanMetod));
        public RelayCommand AddColorCommand => _addColorCommand ?? (_addColorCommand = new RelayCommand(AddRandomColorsMetod, AddRandomColorsCanMetod));
 
        private bool AddRandomColorsCanMetod(object parameter)
            => RandomColorModel.NamesAllColors.Contains(parameter?.ToString());
 
        private void AddRandomColorsMetod(object parameter)
        {
            if (AddRandomColorsCanMetod(parameter))
                model.AddColorsAsync(parameter?.ToString());
        }
        public RelayCommand RemoveColorCommand => _removeColorCommand ?? (_removeColorCommand = new RelayCommand(RemoveRandomColorsMetod, RemoveRandomColorsCanMetod));
 
        private bool RemoveRandomColorsCanMetod(object parameter)
            => RandomColors.Contains(parameter?.ToString());
 
        private void RemoveRandomColorsMetod(object parameter)
        {
            if (RemoveRandomColorsCanMetod(parameter))
                model.RemoveColorsAsync(parameter?.ToString());
        }
 
        private bool GenerateRandomColorsCanMetod(object parameter)
            => uint.TryParse(parameter?.ToString(), out uint _tmp);
 
        private void GenerateRandomColorsMetod(object parameter)
        {
            if (GenerateRandomColorsCanMetod(parameter))
                model.GenerateRandomColorsAsync(uint.Parse(parameter.ToString()));
            SelectColor = null;
        }
 
        public RandomColorVM()
        {
            Task task = new Task(()=> model= new RandomColorModel());
            task.Start();
            task.Wait();
            model.PropertyChanged += Model_PropertyChanged;
            GenerateRandomColorsMetod(CountColors = 5);
        }
 
        private void Model_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
        {
 
            if ((string.IsNullOrEmpty(e.PropertyName) || e.PropertyName == "RemoveColors")
                        && e is PropertyChangedDataEventArgs eR
                        && eR.RemoveData is IEnumerable<string> removeColors)
 
                Application.Current.Dispatcher.BeginInvoke(new Action(
                    () =>
                    {
                        foreach (string color in removeColors)
                        {
                            if (RandomColors.Contains(color))
                                RandomColors.Remove(color);
                        }
 
                    }),
                    null
                );
 
            if ((string.IsNullOrEmpty(e.PropertyName) || e.PropertyName == "AddColors")
                        && e is PropertyChangedDataEventArgs eA
                        && eA.AddData is IEnumerable<string> addColors)
 
                Application.Current.Dispatcher.BeginInvoke(new Action(
                    () =>
                    {
                        foreach (string color in addColors)
                        {
                            if (!RandomColors.Contains(color))
                                RandomColors.Add(color);
                        }
 
                    }),
                    null
                );
        }
 
 
    }