public void RemoveError(string propName, string error)
        {
            lock (this._errorsSyncLock)
            {
                if (_errors == null)
                {
                    return;
                }
                if (_errors.ContainsKey(propName) == true)
                {
                    //if (errors[propName] != error) { throw new InvalidOperationException(); }
                    ErrorLogDO e = _errors[propName];
                    if (e.Message == error)
                    {
                        if (e.Suppress == true)
                        {
                            return;
                        }

                        this._errors.Remove(propName);
                        if (e.IsPersisted)
                        {
                            e.Delete();
                        }
                        //OnErrorsChanged(new DataErrorsChangedEventArgs(propName));
                    }
                }

                if (this._errors.Count == 0)
                {
                    this._errors = null;
                }
            }
        }
        internal void ClearErrors()
        {
            lock (this._errorsSyncLock)
            {
                if (this.HasErrors == false)
                {
                    return;
                }
                var keysToRemove = new List <string>();
                foreach (KeyValuePair <string, ErrorLogDO> kv in this._errors)
                {
                    ErrorLogDO e = kv.Value;
                    if (e != null)
                    {
                        if (e.Suppress == true)
                        {
                            continue;
                        }
                        if (e.IsPersisted)
                        {
                            e.Delete();
                        }
                    }
                    keysToRemove.Add(kv.Key);
                }

                foreach (string k in keysToRemove)
                {
                    this._errors.Remove(k);
                }
            }
        }
        private void AddError(string propName, ErrorLogDO e)
        {
            lock (this._errorsSyncLock)
            {
                if (this._errors == null)
                {
                    this._errors = new Dictionary <string, ErrorLogDO>();
                }

                if (_errors.ContainsKey(propName) == true)
                {
                    ErrorLogDO e1 = _errors[propName];
                    if (e1.Level[0] != e.Level[0] && e1.Suppress == true)
                    {
                        _errors[propName] = e;
                        //OnErrorsChanged(new DataErrorsChangedEventArgs(propName));
                    }
                    else if (e1.Message == e.Message && (e.Suppress == true && e1.Suppress == false))
                    {
                        if (e1.IsPersisted)
                        {
                            e1.Delete();
                        }
                        _errors[propName] = e;
                        //OnErrorsChanged(new DataErrorsChangedEventArgs(propName));
                    }
                    else if (e1.Level.StartsWith("W") && e.Level.StartsWith("E"))
                    {
                        _errors[propName] = e;
                        //OnErrorsChanged(new DataErrorsChangedEventArgs(propName));
                    }
                }
                else
                {
                    _errors[propName] = e;
                    //OnErrorsChanged(new DataErrorsChangedEventArgs(propName));
                }
            }
        }