namespace DoTests
{
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Reflection;
    using System.Text;

    using NUnit.Framework;

    using Xtensive.Storage;
    using Xtensive.Storage.Configuration;

    [TestFixture]
    public class VersionTest
    {
        private Domain domain;

        [TestFixtureSetUp]
        public void Setup()
        {
            var cfg = new DomainConfiguration("sqlserver://localhost/DO40-Tests")
            {
                UpgradeMode = DomainUpgradeMode.Recreate
            };

            cfg.Sessions.Add(new SessionConfiguration("Default")
            {
                BatchSize = 25,
                DefaultIsolationLevel = System.Transactions.IsolationLevel.ReadCommitted,
                CacheSize = 1000,
                Options = SessionOptions.AutoShortenTransactions
            });

            cfg.Types.Register(Assembly.GetExecutingAssembly());

            domain = Domain.Build(cfg);
        }

        /// <summary>
        /// Тест механизма оптимистического параллелизма
        /// </summary>
        [Test]
        public void Test()
        {
            using (var s = Session.Open(domain))
            {
                var id = Guid.NewGuid();
                Person person;
                using (var tr = Transaction.Open())
                {
                    person = new Person(id) { Name = id.ToString() };
                    tr.Complete();
                }

                var item = Query.Single<Person>(id);

                // Version is ok
                var values = new Dictionary<string, object>() { { "Name", "new_" + id }, { "Version", item.Version } };
                var clone = new Dictionary<string, object>(values);
                this.UpdateItem(id, values);

                // Второй апдейт с той же версией умрет
                Assert.Throws(typeof(VersionConflictException), () => this.UpdateItem(id, clone));
            }
        }

        public virtual void UpdateItem(Guid id, Dictionary<string, object> values)
        {
            var versionInfoItems = new List<KeyValuePair<Key, VersionInfo>>();
            if (values.ContainsKey("Version"))
            {
                var key = Key.Create(typeof(Person), id);
                var versionInfo = new VersionInfo(Xtensive.Core.Tuples.Tuple.Create((DateTime)values["Version"]));
                versionInfoItems.Add(new KeyValuePair<Key, VersionInfo>(key, versionInfo));
                values.Remove("Version");
            }

            var versionSet = new VersionSet(versionInfoItems);

            using (VersionValidator.Attach(versionSet))
            {
                using (var transaction = Transaction.Open())
                {
                    var item = Query.Single<Person>(id);
                    using (var ir = Validation.Disable())
                    {
                        foreach (var keyValuePair in values)
                        {
                            item[keyValuePair.Key] = keyValuePair.Value;
                        }

                        ir.Complete();
                    }

                    transaction.Complete();
                }
            }
        }
    }
}

using System;
using Xtensive.Storage;

namespace DoTests
{
    [Serializable]
    [HierarchyRoot]
    public class Person : Entity
    {
        public Person(Guid id)
            : base(id)
        {
        }

        [Field, Key]
        public Guid Id { get; private set; }

        [Field, Version]
        public DateTime Version { get; set; }

        /// <summary>
        /// Gets or sets Name.
        /// </summary>
        [Field]
        public string Name { get; set; }
    }
}

This thread was imported from our support forum. The original discussion may contain more detailed answer.