Hi ich hab genau das gleiche Problem.

Ich konnte im Internet bis jetzt auch nichts weiter zu finden können außer diesen Thread.

Hast du in der Zwischenzeit eine Lösung finden können?

ok hab das problem gelöst es lag an einer ganz anderen stelle

ValidatesOnDataErrors=True

hat einfach in der Defaultansicht der Zelle gefehlt damit wurde die validierung garnicht ausgelöst

es sieht so aus als ob es ein "feature" im IDataErrorInfo gibt

validation class

/// <summary>
    /// The class all validating ViewModel objects must inherit from. 
    /// </summary>
    public class VMValidation : VMWorkspace, IDataErrorInfo
    {
        private Dictionary<string, string> ErrorList = new Dictionary<string, string>();
    
        /// <summary>
        /// Gets a value indicating whether or not this domain object is valid. 
        /// </summary>
        public bool IsVailid
        {
            get { return (ErrorList.Count == 0) ? true : false; }
        }
    
        #region IDataErrorInfo
    
        /// <summary>
        /// Gets an error message indicating what is wrong with this domain object. 
        /// The default is an empty string ("").
        /// </summary>
        public string Error
        {
            get { return getErrors(); } // noch keine richtige methode für gefunden müsste so aber auch funktionieren
        }
    
        /// <summary>
        /// dies ist eine methode die durch einen Event (noch unbekannt welcher)
        /// ausgelöst wird und den Propertynamen schon mit übergeben bekommt
        /// </summary>
        /// <param name="propertyName">Name der Property z.B FirstName</param>
        /// <returns>The error message for the property. 
        /// The default is an empty string ("").</returns>
        public string this[string propertyName]
        {
            get { return OnValidate(propertyName); }
        }
    
        private string getErrors()
        {
            string Error = "";
            foreach (KeyValuePair<string, string> error in ErrorList)
            {
                Error += error.Value;
                Error += Environment.NewLine;
            }
    
            return Error;
        }
    
        /// <summary>
        /// Validates current instance properties using Data Annotations.
        /// </summary>
        /// <param name="propertyName">Name der Property</param>
        /// <returns>ErrorMsg</returns>
        protected virtual string OnValidate(string propertyName)
        {
            if (string.IsNullOrEmpty(propertyName))
                throw new ArgumentException("Invalid property name", propertyName);
    
            string error = string.Empty;
            var value = this.GetType().GetProperty(propertyName).GetValue(this, null);
            var results = new List<ValidationResult>(1);
    
            var context = new ValidationContext(this, null, null) { MemberName = propertyName };
    
            var result = Validator.TryValidateProperty(value, context, results);
    
            if (!result)
            {
                var validationResult = results.First();
                error = validationResult.ErrorMessage;
            }
            if (error.Length > 0)
            {
                if (!ErrorList.ContainsKey(propertyName))
                    ErrorList.Add(propertyName, error);
            }
            else
                if (ErrorList.ContainsKey(propertyName))
                    ErrorList.Remove(propertyName);
    
            return error;
        }
        #endregion //IDataErrorInfo
    }

ViewModel part mit MetaData für die Validirung

[Required]
    [RegularExpression(@"^[0-9''-'\s]$")]
    [Range(1,9999)] //<- wird anscheinend nicht benutzt da IsValid = true anstatt von false ist wenn man eine 0 eingibt
    public int MengeL
    {
        get { return myValue.Menge; }
        set
            {
               myValue.Menge = value;
               RaisePropertyChanged(() => Reg(() => MengeL));
               RaisePropertyChanged(() => Reg(() => dirtyMenge));
             }
     }

kann mir bitter einer sagen wo da der Fehler is den folgende Varianten funktionieren schonmal

[Required]
[RegularExpression(@"^[0-9''-'\s]$")]

[Required]
[Range(1,9999)]

das schau ich mir mal an dank dir

EDIT:
scheint genau das zu sein was ich bauen wollte nur mit mehr schnickschnack dran 😄

sehr schön Projekt nur die vielen Iterationen find ich nicht so gut aber da lässt sich anscheinend aber auch nichts dran ändern da die sein müssen naja man kann nicht alles haben 😛

Hi ich bin dabei meine eigene ObservableCollection zu bauen die die Funktionalität wie DataTable.GetChanges() anbieten soll nur scheint mir noch das wissen zu fehlen wie ich die Änderungen erstmal richtig speichere um sie dann später auslesen zu können

erste idee war ein Dictionary welches einfach alle Änderungen der Reihenfolge nach speichert um sogar ein Rollback ausführen zu können (lief auch soweit bis auf Modifizierungen rückgängig zu machen (is aber auch erstmal egal)) naja das prob hier is halt das man mit einfachen abfragen z.B

DicOfChanges.Where(x => (x.Value).Modification == CollStat.Added);

auch elemete bekommt die später wieder gelöscht wurden.

zweite Idee war für jede art von Änderung eine eigene Collection zu machen und dann während des Events zu die Änderung der einen Collection hinzu zu fügen und aus den anderen zu löschen hier find ich kann das dauerhafte iterieren zum Problem werden

dritte Idee ich kombiniere 1. und 2. und erstelle ein

Dictionary<???,List/Dictionary<???>>

um bei einen Event die Änderungen Objekt genauer bearbeiten zu können

ich hab mir hier schon versucht die Logik dahinter zu verstehen bin aber leider kläglich gescheitert. Könnte mir bitte einer erklären wie das da ganz grob abläuft.

spontane Ideen sind auch gerne gesehen

momentan hab ich

        #region nested class
        private class _ElementKeeper<T>
        {
            public T Element;
            public CollStat Modification;

            public _ElementKeeper(T element, CollStat Modifi)
            {
                Element = element;
                Modification = Modifi;
            }
        }
        #endregion

beinhaltet das Element und die art der Modifikation

private Dictionary<int, _ElementKeeper<T>> DicOfChanges = new Dictionary<int, _ElementKeeper<T>>();

ist das Dictionary welches ich mit Linq durchsuche