userTextEdit.DataBindings.Add(new Binding("Text",Settings.Instance,"UserName",true,DataSourceUpdateMode.OnPropertyChanged));

private string userName = string.Empty;

public string UserName { get { return userName; }set { userName = value; } }

  userTextEdit.DataBindings.Add(new Binding("EditValue",bindingSource,"UserName",true,DataSourceUpdateMode.OnValidation));

this.userTextEdit.CausesValidation = false;

private void simpleButton2_Click(object sender, EventArgs e)
        {     
            userTextEdit.DoValidate();
            //hier weitere Textfelder updaten
        }

  _curSelectedRow.RejectChanges();

BindingSource bindingSource = new BindingSource();

public class MyObject
    {        
        private string userName = string.Empty;
        private string departmentCode = string.Empty;
        //...
        public string UserName { get { return userName; } set { userName = value; } }
        public string DepartmentCode { get { return departmentCode; } set { departmentCode = value; } }

        //...
}

public MyForm()
        {
            InitializeComponent();
            bindingSource.DataSource = MyObject;
       ...
}

userTextEdit.DataBindings.Add(new Binding("Text", bindingSource, "UserName"));
departmentTextEdit.DataBindings.Add(new Binding("Text", bindingSource, "DepartmentCode"));

 public static class DataBindingUtils
    {
        public static void SuspendTwoWayBinding(BindingManagerBase bindingManager)
        {
            if (bindingManager == null)
            {
                throw new ArgumentNullException("bindingManager");
            }

            foreach (Binding b in bindingManager.Bindings)
            {
                b.DataSourceUpdateMode = DataSourceUpdateMode.Never;
            }
        }

        public static void UpdateDataBoundObject(BindingManagerBase bindingManager)
        {
            if (bindingManager == null)
            {
                throw new ArgumentNullException("bindingManager");
            }

            foreach (Binding b in bindingManager.Bindings)
            {
                b.WriteValue();
            }
        }
    }

public partial class MyForm: Form
    {               
        private BindingSource bindingSource = new BindingSource();
        public MyForm()
        {
            InitializeComponent();
            bindingSource.DataSource = MyObject;

            userTextEdit.DataBindings.Add(new Binding("Text", bindingSource, "UserName"));
            departmentTextEdit.DataBindings.Add(new Binding("Text", bindingSource, "DepartmentCode"));

            DataBindingUtils.SuspendTwoWayBinding(this.BindingContext[bindingSource]);
        }     

private void okButton_Click(object sender, EventArgs e)
        {
            DataBindingUtils.UpdateDataBoundObject(this.BindingContext[bindingSource]);
        }

[Serializable()]
    public abstract class BusinessObject : INotifyPropertyChanged, IDataErrorInfo, IEditableObject
    {
        [NonSerialized()]
        private List<Rule> rules;
        [NonSerialized()]
        private MemoryStream memoryStream;
        [NonSerialized()]
        private BinaryFormatter formatter = new BinaryFormatter(null, new StreamingContext(StreamingContextStates.Clone));

        private bool hasBrokenRulesThatMustBeFollowed = false;
        private bool editing = false;

        /// <summary>
        /// Constructor.
        /// </summary>
        public BusinessObject()
        {
        }

        public bool HasBrokenRulesThatMustBeFollowed
        {
            get { return hasBrokenRulesThatMustBeFollowed; }
            protected set { hasBrokenRulesThatMustBeFollowed = value; }
        }

        /// <summary>
        /// Gets a value indicating whether or not this domain object is valid. 
        /// </summary>
        public virtual bool IsValid
        {
            get { return this.Error == null; }
        }        

        /// <summary>
        /// Gets an error message indicating what is wrong with this domain object. The default is an empty string ("").
        /// </summary>
        public virtual string Error
        {
            get
            {
                string result = this[string.Empty];
                if (result != null && result.Trim().Length == 0)
                    result = null;

                return result;
            }
        }

        /// <summary>
        /// Gets the error message for the property with the given Name.
        /// </summary>
        /// <param Name="propertyName">The Name of the property whose error message to get.</param>
        /// <returns>The error message for the property. The default is an empty string ("").</returns>
        public virtual string this[string propertyName]
        {
            get
            {
                var builder = new StringBuilder();

                 propertyName = CleanString(propertyName);

                foreach (Rule r in GetBrokenRules(propertyName))
                    if (propertyName == string.Empty || r.PropertyName == propertyName)
                    {
                        builder.AppendLine(r.Description);
                    }

                return builder.Length != 0 ? builder.ToString() : null;
            }
        }

        /// <summary>
        /// Validates all rules on this domain object, returning a list of the broken rules.
        /// </summary>
        /// <returns>A read-only collection of rules that have been broken.</returns>
        public virtual ReadOnlyCollection<Rule> GetBrokenRules()
        {
            return GetBrokenRules(string.Empty);
        }

        /// <summary>
        /// Validates all rules on this domain object for a given property, returning a list of the broken rules.
        /// </summary>
        /// <param Name="property">The Name of the property to check for. If null or empty, all rules will be checked.</param>
        /// <returns>A read-only collection of rules that have been broken.</returns>
        public virtual ReadOnlyCollection<Rule> GetBrokenRules(string property)
        {
            hasBrokenRulesThatMustBeFollowed = false;

            property = CleanString(property);

            // If we haven't yet created the rules, create them now.
            if (rules == null)
            {
                rules = new List<Rule>();
                rules.AddRange(this.CreateRules());
            }
            List<Rule> broken = new List<Rule>();

            foreach (Rule r in this.rules)
                // Ensure we only validate a rule 
                if (r.PropertyName == property || property == string.Empty)
                {
                    bool isRuleBroken = !r.ValidateRule(this);
                    //Debug.WriteLine(DateTime.Now.ToLongTimeString() + ": Validating the rule: '" + r.ToString() + "' on object '" + this.ToString() + "'. Result = " + ((isRuleBroken == false) ? "Valid" : "Broken"));
                    if (isRuleBroken)
                    {
                        broken.Add(r);
                        if (r.RuleMustBeFollowed)
                            hasBrokenRulesThatMustBeFollowed = true;
                    }
                }

            return broken.AsReadOnly();
        }

        /// <summary>
        /// Occurs when any properties are changed on this object.
        /// </summary>
        [field:NonSerialized]
        public event PropertyChangedEventHandler PropertyChanged;

        /// <summary>
        /// Override this method to create your own rules to validate this business object. These rules must all be met before 
        /// the business object is considered valid enough to save to the data store.
        /// </summary>
        /// <returns>A collection of rules to add for this business object.</returns>
        protected virtual List<Rule> CreateRules()
        {
            return new List<Rule>();
        }

        /// <summary>
        /// A helper method that raises the PropertyChanged event for a property.
        /// </summary>
        /// <param Name="propertyNames">The names of the properties that changed.</param>
        protected virtual void NotifyChanged(params string[] propertyNames)
        {
            foreach (string name in propertyNames)
                OnPropertyChanged(new PropertyChangedEventArgs(name));

            OnPropertyChanged(new PropertyChangedEventArgs("IsValid"));
        }

        /// <summary>
        /// Cleans a string by ensuring it isn't null and trimming it.
        /// </summary>
        /// <param name="s">The string to clean.</param>
        protected string CleanString(string s)
        {
            return (s ?? string.Empty).Trim();
        }

        /// <summary>
        /// Raises the PropertyChanged event.
        /// </summary>
        protected virtual void OnPropertyChanged(PropertyChangedEventArgs e)
        {
            if (this.PropertyChanged != null)
                this.PropertyChanged(this, e);
        }

        protected void createSnapShot(object item)
        {
            if (!editing)
            {
                memoryStream = new MemoryStream();
                if (formatter == null)
                    formatter = new BinaryFormatter(null, new StreamingContext(StreamingContextStates.Clone));
                formatter.Serialize(memoryStream, item);

                editing = true;
            }
        }

        protected void restoreSnapshot<T>(ref T item)
        {
            if (editing)
            {
                memoryStream.Position = 0;
                item = (T)formatter.Deserialize(memoryStream);

                editing = true;
            }
        }

        protected void throwAwaySnapshot()
        {
            if (memoryStream != null)
            {
                memoryStream.Dispose();
                memoryStream = null;
            }

            editing = false;
        }

        #region IEditableObject Member

        public virtual void BeginEdit()
        {
            // Childklassen sind für die Implementierung zuständig
        }

        public virtual void CancelEdit()
        {
            // Childklassen sind für die Implementierung zuständig
        }

        public virtual void EndEdit()
        {
            throwAwaySnapshot();         
        }

        #endregion
    }

/// <summary>
    /// An abstract class that contains information about a rule as well as a method to validate it.
    /// </summary>
    /// <remarks>
    /// This class is primarily designed to be used on a domain object to validate a business rule. In most cases, you will want to use the 
    /// concrete class SimpleRule, which just needs you to supply a delegate used for validation. For custom, complex business rules, you can 
    /// extend this class and provide your own method to validate the rule.
    /// </remarks>
    [Serializable]
    public abstract class Rule
    {
        private string _description;
        private string _propertyName;
        private bool _ruleMustBeFollowed = false;

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="propertyName">The Name of the property the rule is based on. This may be blank if the rule is not for any specific property.</param>
        /// <param name="brokenDescription">A description of the rule that will be shown if the rule is broken.</param>
        public Rule(string propertyName, string brokenDescription)
        {
            this.Description = brokenDescription;
            this.PropertyName = propertyName;
        }

        public Rule(string propertyName, string brokenDescription, bool ruleMustBeFollowed)
        {
            this.Description = brokenDescription;
            this.PropertyName = propertyName;
            this._ruleMustBeFollowed = ruleMustBeFollowed;
        }

        public bool RuleMustBeFollowed
        {
            get { return _ruleMustBeFollowed; }
        }

        /// <summary>
        /// Gets descriptive text about this broken rule.
        /// </summary>
        public virtual string Description
        {
            get { return _description; }
            protected set { _description = value; }
        }

        /// <summary>
        /// Gets the Name of the property the rule belongs to.
        /// </summary>
        public virtual string PropertyName
        {
            get { return (_propertyName ?? string.Empty).Trim(); }
            protected set { _propertyName = value; }
        }

        /// <summary>
        /// Validates that the rule has been followed.
        /// </summary>
        public abstract bool ValidateRule(BusinessObject domainObject);

        /// <summary>
        /// Gets a string representation of this rule.
        /// </summary>
        /// <returns>A string containing the description of the rule.</returns>
        public override string ToString()
        {
            return this.Description;
        }

        /// <summary>
        /// Serves as a hash function for a particular type. System.Object.GetHashCode()
        /// is suitable for use in hashing algorithms and data structures like a hash
        /// table.
        /// </summary>
        /// <returns>A hash code for the current rule.</returns>
        public override int GetHashCode()
        {
            return this.ToString().GetHashCode();
        }
    }

public class MyObject: BusinessObject
    {
//...
    }