.NET (Core and Framework)

public class ValidatableModel : INotifyDataErrorInfo, INotifyPropertyChanged
    {
        private ConcurrentDictionary<string, List<string>> _errors = new ConcurrentDictionary<string, List<string>>();
        public event PropertyChangedEventHandler PropertyChanged;

        public void RaisePropertyChanged(string propertyName)
        {
            var handler = PropertyChanged;
            if (handler != null)
                handler(this, new PropertyChangedEventArgs(propertyName));
            ValidateAsync();
        }

        public event EventHandler<DataErrorsChangedEventArgs> ErrorsChanged;

        public void OnErrorsChanged(string propertyName)
        {
            var handler = ErrorsChanged;
            if (handler != null)
                handler(this, new DataErrorsChangedEventArgs(propertyName));
        }

        public IEnumerable GetErrors(string propertyName)
        {
            List<string> errorsForName;
            _errors.TryGetValue(propertyName, out errorsForName);
            return errorsForName;
        }

        public bool HasErrors
        {
            get { return _errors.Any(kv => kv.Value != null && kv.Value.Count > 0); }
        }

        public Task ValidateAsync()
        {
            return Task.Run(() => Validate());
        }

        private object _lock = new object();

        public void Validate()
        {
            lock (_lock)
            {
                var validationContext = new ValidationContext(this, null, null);
                var validationResults = new List<ValidationResult>();
                Validator.TryValidateObject(this, validationContext, validationResults, true);

                foreach (var kv in _errors.ToList())
                {
                    if (validationResults.All(r => r.MemberNames.All(m => m != kv.Key)))
                    {
                        List<string> outLi;
                        _errors.TryRemove(kv.Key, out outLi);
                        OnErrorsChanged(kv.Key);
                    }
                }

                var q = from r in validationResults
                        from m in r.MemberNames
                        group r by m into g
                        select g;

                foreach (var prop in q)
                {
                    var messages = prop.Select(r => r.ErrorMessage).ToList();

                    if (_errors.ContainsKey(prop.Key))
                    {
                        List<string> outLi;
                        _errors.TryRemove(prop.Key, out outLi);
                    }
                    _errors.TryAdd(prop.Key, messages);
                    OnErrorsChanged(prop.Key);
                }
            }
        }
    }

public class Busta : ValidatableModel
   {

       int _BustaID;
       string _DescrizioneBusta;
       int _NegozioID;

       public string _nomeCliente;

       [Key]
       public int ID { get; set; }

       [Required]
       [CustomValidation(typeof(Busta), "unicoBustaID")]

       public int BustaID
       {
           get { return _BustaID; }
           set { _BustaID =  value; RaisePropertyChanged ("BustaID"); }
       }
       [Required]
       [CustomValidation(typeof(Busta), "nullNegozio")]

       public int NegozioID
       {
           get { return _NegozioID; }
           set { _NegozioID = value; RaisePropertyChanged("NegozioID"); }
       }
       [StringLength(20)]
       public string NomeCliente { get; set; }
       [MaxLength(20)]


       [Required]
       public string DescrizioneBusta
       {
           get { return _DescrizioneBusta; }
           set { _DescrizioneBusta = value; RaisePropertyChanged("DescrizioneBusta"); }
       }



       public static ValidationResult unicoBustaID(object obj, ValidationContext context)
       {
           var user = (Busta)context.ObjectInstance;
           if (user.BustaID <= 0 )
           {
               return new ValidationResult("Codice errato", new List<string> { "BustaID","" });
           }
           return ValidationResult.Success;
       }
       public static ValidationResult nullNegozio(object obj, ValidationContext context)
       {
           var user = (Busta)context.ObjectInstance;
           if (user.NegozioID <= 0)
           {
               return new ValidationResult("Selezionare Un Negozio", new List<string> { "NegozioID", "" });
           }
           return ValidationResult.Success;
       }


   }

 SaveCommand = new RelayCommand<Busta>(SalvaBusta,CanSave);

public bool CanSave(object parameter)
        {
            if (Busta.HasErrors == false )
                return true;
            else
                return false;
        }

Hello I have a combobox binding to a ObservableCollection of a table, where I fetch the ID field that deposit in another table, so everything is right, the problem arises when I want my ValidatesOnNotifyDataErrors doing its job, but it does the property in question is set to [Required] will post the code I hope you can help out:

Combobox:

<pre lang="xml"><ComboBox HorizontalAlignment="Left" Margin="327,116,0,0" VerticalAlignment="Top" Width="120" ItemsSource="{Binding NegozioObser}" SelectedItem="{Binding NegozioSelezionato, ValidatesOnNotifyDataErrors=True}">
                <ComboBox.ItemTemplate>
				<DataTemplate>
					<Grid>
						<TextBlock Text="{Binding RagioneSociale}"/>
					</Grid>
				</DataTemplate>
			</ComboBox.ItemTemplate>
		</ComboBox>

[Required]
        
        public int NegozioID 
        {
            get { return _NegozioID; }
            set { _NegozioID = value; RaisePropertyChanged("NegozioID"); }
        }

ObservableCollection<Negozio> _Negozios;

        public ObservableCollection<Negozio> NegozioObser
        {
            get { return _Negozios; }
            set
            {
                _Negozios = value;
                RaisePropertyChanged("NegozioObser");
            }
        }