EditableObject class

public class TestObject : INotifyPropertyChanged
{
    // The FirstName editable property.
    //
    private string _originalFirstName;
    private string _currentFirstName;

    public override string FirstName
    {
        get { return _currentFirstName; }
        set
        {
            _currentFirstName = value;
            OnPropertyChanged("FirstName");
        }
    }

    bool IsFirstNameDirty
    {
        get { return _currentFirstName != _originalFirstName; }
    }

    void AcceptFirstNameChange()
    {
        if (IsFirstNameDirty)
        {
            _originalFirstName = _currentFirstName;
            OnPropertyChanged("FirstName");
        }
    }

    void RejectFirstNameChange()
    {
        if (IsFirstNameDirty)
        {
            _currentFirstName = _originalFirstName;
            OnPropertyChanged("FirstName");
        }
    }

    // The LastName editable property.
    //
    private string _originalLastName;
    private string _currentLastName;

    public override string LastName
    {
        get { return _currentLastName; }
        set
        {
            _currentLastName = value;
            OnPropertyChanged("LastName");
        }
    }

    bool IsLastNameDirty
    {
        get { return _currentLastName != _originalLastName; }
    }

    void AcceptLastNameChange()
    {
        if (IsLastNameDirty)
        {
            _originalLastName = _currentLastName;
            OnPropertyChanged("LastName");
        }
    }

    void RejectLastNameChange()
    {
        if (IsLastNameDirty)
        {
            _currentLastName = _originalLastName;
            OnPropertyChanged("LastName");
        }
    }

    // Common members.
    //
    public bool IsDirty
    {
        get
        {
            return IsFirstNameChange || IsLastNameChange;
        }
    }

    public void AcceptChanges()
    {
        AcceptFirstNameChange();
        AcceptLastNameChange();
    }

    public void RejectChanges()
    {
        RejectFirstNameChange();
        RejectLastNameChange();
    }

    public virtual event PropertyChangedEventHandler PropertyChanged;

    protected virtual void OnPropertyChanged(string propertyName)
    {
        if (PropertyChanged != null)
            PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    }
}

using System;
using NUnit.Framework;
using BLToolkit.EditableObjects;

namespace HowTo.EditableObjects
{
    [TestFixture]
    public class EditableObjectTest
    {
        public abstract class TestObject : EditableObject<TestObject>
        {
            // Any abstract property becomes editable.
            //
            public abstract string FirstName { get; set; }
            public abstract string LastName  { get; set; }

            // This field is not editable.
            //
            public string FullName
            {
                get { return string.Format("{0} {1}", FirstName, LastName); }
            }
        }

        [Test]
        public void Test()
        {
            TestObject obj = TestObject.CreateInstance();

            obj.FirstName = "Tester";
            obj.LastName  = "Testerson";

            Assert.IsTrue(obj.IsDirty);

            obj.AcceptChanges();

            Assert.IsFalse(obj.IsDirty);
        }
    }
}

[BLToolkitGenerated]
public sealed class TestObject : EditableObjectTest.TestObject, IEditable, IMemberwiseEditable, IPrintDebugState
{
    // Note that the internal representation of the properties is EditableValue<string>.
    // The EditableValue class provides a mechanism to keep and control the field value state.
    //
    private EditableValue<string> _firstName;
    private EditableValue<string> _lastName;

    // PropertyInfo is used for internal purposes.
    //
    private static PropertyInfo _firstName_propertyInfo =
        TypeHelper.GetPropertyInfo(typeof(EditableObjectTest.TestObject), "FirstName", typeof(string), Type.EmptyTypes);
    private static PropertyInfo _lastName_propertyInfo  =
        TypeHelper.GetPropertyInfo(typeof(EditableObjectTest.TestObject), "LastName",  typeof(string), Type.EmptyTypes);

    // Constructors.
    //
    public TestObject()
    {
        this._firstName = new EditableValue<string>("");
        this._lastName  = new EditableValue<string>("");
    }

    public TestObject(InitContext ctx)
    {
        this._firstName = new EditableValue<string>("");
        this._lastName  = new EditableValue<string>("");
    }

    // Abstract property implementation.
    //
    public override string FirstName
    {
        get
        {
            return _firstName.Value;
        }

        set
        {
            _firstName.Value = value;

            // The PropertyChanged event support.
            //
            ((IPropertyChanged)this).OnPropertyChanged(_firstName_propertyInfo);
        }
    }

    public override string LastName
    {
        get
        {
            return _lastName.Value;
        }

        set
        {
            _lastName.Value = value;
            ((IPropertyChanged)this).OnPropertyChanged(_lastName_propertyInfo);
        }
    }

    // The IEditable interface implementation.
    //
    bool IEditable.IsDirty
    {
        get { return _firstName.IsDirty || _lastName.IsDirty; }
    }

    void IEditable.AcceptChanges()
    {
        this._firstName.AcceptChanges();
        this._lastName. AcceptChanges();
    }

    void IEditable.RejectChanges()
    {
        this._firstName.RejectChanges();
        this._lastName. RejectChanges();
    }

    // The IMemberwiseEditable interface implementation.
    //
    bool IMemberwiseEditable.AcceptMemberChanges(PropertyInfo propertyInfo, string memberName)
    {
        return
            _firstName.AcceptMemberChanges(_firstName_propertyInfo, memberName) ||
            _lastName. AcceptMemberChanges(_lastName_propertyInfo,  memberName);
    }

    void IMemberwiseEditable.GetDirtyMembers(PropertyInfo propertyInfo, ArrayList list)
    {
        _firstName.GetDirtyMembers(_firstName_propertyInfo, list);
        _lastName. GetDirtyMembers(_lastName_propertyInfo,  list);
    }

    bool IMemberwiseEditable.IsDirtyMember(PropertyInfo propertyInfo, string memberName, ref bool isDirty)
    {
        return
            _firstName.IsDirtyMember(_firstName_propertyInfo, memberName, ref isDirty) ||
            _lastName. IsDirtyMember(_lastName_propertyInfo,  memberName, ref isDirty);
    }

    bool IMemberwiseEditable.RejectMemberChanges(PropertyInfo propertyInfo, string memberName)
    {
        return
            _firstName.RejectMemberChanges(_firstName_propertyInfo, memberName) ||
            _lastName. RejectMemberChanges(_lastName_propertyInfo,  memberName);
    }

    // The IPrintDebugState interface implementation.
    //
    void IPrintDebugState.PrintDebugState(PropertyInfo propertyInfo, ref string str)
    {
        _firstName.PrintDebugState(_firstName_propertyInfo, ref str);
        _lastName. PrintDebugState(_lastName_propertyInfo,  ref str);
    }
}