[TestClass]
    public class TestMRUStore
    {
        const int REPEAT_TEST = 1000;

        [TestMethod]
        public void TestFillMRUStore()
        {
            var store = new MRUStore("TestMru", 40);
            var stopwatch = new Stopwatch();
            var random = new Random();
            var basePath = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments) + "\\хранилища\\";

            store.Reload();
            stopwatch.Start();
            for (int i = REPEAT_TEST; --i >= 0;)
            {
                string pickItem;
                if (random.NextDouble() <= 0.4 && store.Count > 0)
                {
                    pickItem = store[random.Next(store.Count)];
                }
                else
                {
                    pickItem = string.Concat(basePath, random.Next(), ".txt");
                }
                store.Add(pickItem);
                store.Save();
            }
            stopwatch.Stop();
            Debug.Write("Test completed in " + stopwatch.Elapsed.ToString());
        }

        [TestMethod]
        public void TestLoadMRUStore()
        {
            var store = new MRUStore("TestMru");
            var stopwatch = new Stopwatch();
            stopwatch.Start();
            for (int i = REPEAT_TEST; --i >= 0;)
            {
                store.Reload();
            }
            stopwatch.Stop();
            Debug.Write("Test completed in " + stopwatch.Elapsed.ToString());
        }
    }

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using System.Xml;
using System.Xml.Schema;
using System.Xml.Serialization;

namespace SspMain
{
    public class SettingsModel
    {
        public SettingsSection RootSection { get; set; }

        public SettingsModel()
        {
            RootSection = new SettingsSection();
        }
    }

    public class SettingsSection
    {
        public SettingsValueDictionary Values { get; set; }
        public SettingsSectionDictionary Sections { get; set; }

        public SettingsSection()
        {
            Values = new SettingsValueDictionary();
            Sections = new SettingsSectionDictionary();
        }
    }

    public partial class SettingsSectionDictionary : Dictionary<string, SettingsSection>
    {
        public SettingsSectionDictionary()
            : base(StringComparer.InvariantCultureIgnoreCase)
        { }

        // CHANGED:
        internal SettingsSection GetValueOrDefault(string sectionName)
        {
            SettingsSection result;
            return TryGetValue(sectionName ,out result) ? result : null;
        }
    }

    public partial class SettingsValueDictionary : Dictionary<string, object>
    {
        public SettingsValueDictionary()
            : base(StringComparer.InvariantCultureIgnoreCase)
        { }
    }

    public class SettingsStorage
    {
        #region Default Storage

        //CHANGED:
        public static Lazy<SettingsStorage> I = new Lazy<SettingsStorage>(() => new SettingsStorage
        {
            FilePath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "settings.xml")
        });

        #endregion

        #region Model Management

        public string FilePath { get; set; }

        object LockObj = new object();

        SettingsXmlSerializer Serializer = new SettingsXmlSerializer();

        bool IsModelChanged;

        SettingsModel Model
        {
            get
            {
                if (_model == null)
                    Load();

                return _model;
            }
        }

        SettingsModel _model;

        public void Load()
        {
            lock (LockObj)
            {
                if (File.Exists(FilePath))
                    //CHANGED: Log.ExecuteWithLog(() => _model = Serializer.Deserialize(FilePath));
                    _model = Serializer.Deserialize(FilePath);

                if (_model == null)
                    _model = new SettingsModel();

                IsModelChanged = false;
            }
        }

        public void Save()
        {
            lock (LockObj)
                if (IsModelChanged)
                {
                    Serializer.Serialize(FilePath, Model);
                    IsModelChanged = false;
                }
        }

        #endregion

        #region Section Management

        SettingsSection GetOrCreateSectionByPath(string[] sectionPath)
        {
            var result = Model.RootSection;
            foreach (var sectionName in sectionPath)
                result = GetOrCreateChildSection(result, sectionName);
            return result;
        }

        SettingsSection GetOrCreateChildSection(SettingsSection parentSection, string sectionName)
        {
            SettingsSection result;
            if (parentSection.Sections.TryGetValue(sectionName, out result) == false)
            {
                result = new SettingsSection();
                parentSection.Sections.Add(sectionName, result);
            }
            return result;
        }

        SettingsSection GetSectionByPath(string[] sectionPath)
        {
            var result = Model.RootSection;
            foreach (var sectionName in sectionPath)
            {
                result = result.Sections.GetValueOrDefault(sectionName);
                if (result == null)
                    return null;
            }
            return result;
        }

        #endregion

        #region Value Management

        public bool RemoveValue(SettingsStorageKey key)
        {
            lock (LockObj)
            {
                var section = GetSectionByPath(key.SectionPath);
                if (section == null)
                    return false;

                bool result = section.Values.Remove(key.ValueName);
                if (result)
                    IsModelChanged = true;

                return result;
            }
        }

        public void SetValue(SettingsStorageKey key, object value)
        {
            lock (LockObj)
            {
                var storageValue = CloneHelper.XmlCloneIfRefType(value);
                GetOrCreateSectionByPath(key.SectionPath).Values[key.ValueName] = storageValue;
                IsModelChanged = true;
            }
        }

        public bool TryGetValue(SettingsStorageKey key, Type valueType, out object result)
        {
            lock (LockObj)
            {
                result = null;

                var section = GetSectionByPath(key.SectionPath);

                if (section == null)
                    return false;

                object value;
                if (section.Values.TryGetValue(key.ValueName, out value) == false)
                    return false;

                if (CheckValueType(valueType, value))
                {
                    result = CloneHelper.XmlCloneIfRefType(value);
                    return true;
                }

                return false;
            }
        }

        bool CheckValueType(Type valueType, object value)
        {
            if (value != null)
                return valueType.IsAssignableFrom(value.GetType());

            return valueType.CanBeNull();
        }

        #endregion

        #region Value Management Extension

        public bool TryGetValue<T>(SettingsStorageKey key, out T result)
        {
            object value;

            if (TryGetValue(key, typeof(T), out value))
            {
                result = (T) value;
                return true;
            }

            result = default(T);
            return false;
        }

        public T GetValueOrDefault<T>(SettingsStorageKey key, T defaultValue = default(T))
        {
            object result;

            if (TryGetValue(key, typeof(T), out result))
                return (T) result;

            return defaultValue;
        }

        #endregion
    }
    public class SettingsStorageKey
    {
        public string[] SectionPath { get; private set; }

        public string ValueName { get; private set; }

        public SettingsStorageKey(string[] sectionPath, string valueName)
        {
            if (sectionPath == null)
                throw new ArgumentNullException("sectionPath");

            if (sectionPath.Length == 0)
                throw new ArgumentException("sectionPath.Length == 0");

            if (sectionPath.Any(v => string.IsNullOrWhiteSpace(v)))
                throw new ArgumentException("sectionPath.Any(v => string.IsNullOrWhiteSpace(v))");

            if (string.IsNullOrWhiteSpace(valueName))
                throw new ArgumentException("string.IsNullOrWhiteSpace(valueName)");

            SectionPath = sectionPath;
            ValueName = valueName;
        }
    }
    class SettingsXmlSerializer
    {
        XmlSerializer Serializer = new XmlSerializer(typeof(SettingsModel));

        public void Serialize(string filePath, SettingsModel model)
        {
            var dir = Path.GetDirectoryName(filePath);

            if (string.IsNullOrEmpty(dir) == false && Directory.Exists(dir) == false)
                Directory.CreateDirectory(dir);

            var tempFilePath = filePath + ".temp.xml";

            if (File.Exists(tempFilePath))
                File.Delete(tempFilePath);

            using (var xw = new XmlTextWriter(tempFilePath, Encoding.GetEncoding(1251)))
            {
                xw.Formatting = Formatting.Indented;
                Serializer.Serialize(xw, model);
            }

            if (File.Exists(filePath))
                File.Delete(filePath);

            File.Move(tempFilePath, filePath);
        }

        public SettingsModel Deserialize(string filePath)
        {
            try
            {
                using (var xr = new XmlTextReader(filePath))
                    return (SettingsModel) Serializer.Deserialize(xr);
            }
            catch (Exception e)
            {
                throw new Exception("Ошибка при чтении файла хранилища настроек.", e);
            }
        }
    }

    public partial class SettingsSectionDictionary : IXmlSerializable
    {
        #region IXmlSerializable Members

        const string E_Item = "Item";
        const string A_Key = "Key";

        void IXmlSerializable.ReadXml(XmlReader reader)
        {
            if (reader.IsEmptyElement)
            {
                reader.Read();
                return;
            }

            var vs = GetValueSerializer();

            while (reader.Read())
            {
                if (reader.NodeType == XmlNodeType.EndElement)
                {
                    reader.ReadEndElement();
                    break;
                }

                if (reader.NodeType == XmlNodeType.Element && reader.Name == E_Item)
                {
                    string key = reader[A_Key];

                    reader.Read();
                    var value = (SettingsSection) vs.Deserialize(reader);
                    reader.ReadEndElement();

                    Add(key, value);
                }
            }
        }

        void IXmlSerializable.WriteXml(XmlWriter writer)
        {
            var vs = GetValueSerializer();

            foreach (var item in this)
            {
                writer.WriteStartElement(E_Item);
                writer.WriteAttributeString(A_Key, item.Key);
                vs.Serialize(writer, item.Value);
                writer.WriteEndElement();
            }
        }

        XmlSerializer GetValueSerializer()
        {
            return new XmlSerializer(typeof(SettingsSection));
        }

        XmlSchema IXmlSerializable.GetSchema()
        {
            return null;
        }

        #endregion
    }

    public partial class SettingsValueDictionary : IXmlSerializable
    {
        #region IXmlSerializable Members

        const string E_Item = "Item";
        const string A_Key = "Key";
        const string A_ValueType = "ValueType";

        void IXmlSerializable.ReadXml(XmlReader reader)
        {
            if (reader.IsEmptyElement)
            {
                reader.Read();
                return;
            }

            while (reader.Read())
            {
                if (reader.NodeType == XmlNodeType.EndElement)
                {
                    reader.ReadEndElement();
                    break;
                }

                if (reader.NodeType == XmlNodeType.Element && reader.Name == E_Item)
                {
                    string key = reader[A_Key];
                    string valueType = reader[A_ValueType];

                    object value = null;
                    bool hasValue = true;

                    if (valueType != null)
                        hasValue = TryDeserializeValue(valueType, reader.ReadInnerXml(), out value);

                    if (hasValue)
                        Add(key, value);
                }
            }
        }

        bool TryDeserializeValue(string type, string data, out object value)
        {
            try
            {
                var vs = new XmlSerializer(Type.GetType(type));

                var doc = new XmlDocument();
                doc.LoadXml(data);
                doc.DocumentElement.SetAttribute("xmlns:xsd", "http://www.w3.org/2001/XMLSchema");

                using (var xr = new XmlNodeReader(doc))
                    value = vs.Deserialize(xr);

                return true;
            }
            catch
            {
                value = null;
                return false;
            }
        }

        void IXmlSerializable.WriteXml(XmlWriter writer)
        {
            foreach (var item in this)
            {
                writer.WriteStartElement(E_Item);
                writer.WriteAttributeString(A_Key, item.Key);

                if (item.Value != null)
                {
                    var valueType = item.Value.GetType();
                    writer.WriteAttributeString(A_ValueType, GetTypeName(valueType));
                    var vs = new XmlSerializer(valueType);
                    vs.Serialize(writer, item.Value);
                }

                writer.WriteEndElement();
            }
        }

        XmlSchema IXmlSerializable.GetSchema()
        {
            return null;
        }

        string GetTypeName(Type type)
        {
            var fullName = type.AssemblyQualifiedName;
            var simpleName = type.FullName + ", " + type.Assembly.GetName().Name;

            try
            {
                if (Type.GetType(simpleName) == null)
                    return fullName;
            }
            catch
            {
                return fullName;
            }

            return simpleName;
        }

        #endregion
    }
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Reflection;
using System.Security.AccessControl;
using BSS.Common;
using Microsoft.Win32;

namespace BSS.Editor
{
    public class MRUStore : IReadOnlyList<string>, ICollection<string>
    {
        private const string MRU_KEY_PREFIX = "MRU";

        private static string _regkeyBasePath;

        private string _name;

        private int _usedEntries;
        private int _maxEntries;
        private int _updateEntries;
        private int _lastUpdateNo;
        private STuple<int, int, string>[] _mru;              // Update number, key number, value

        public MRUStore(string name)
            : this(name, 0)
        { }

        public MRUStore(string name, int maxEntries)
        {
            if (_regkeyBasePath == null)
            {
                string companyName = null;
                string productName = null;
                var runAssembly = Assembly.GetEntryAssembly();
                if (runAssembly != null)
                {
                    var namespaceParts = runAssembly.EntryPoint.DeclaringType.Namespace.Split('.');
                    var companyAttr = runAssembly.GetCustomAttribute<AssemblyCompanyAttribute>();
                    if (companyAttr != null && !string.IsNullOrWhiteSpace(companyAttr.Company))
                    {
                        companyName = companyAttr.Company;

                    }
                    else if (namespaceParts.Length > 0)
                    {
                        companyName = namespaceParts[0];
                    }
                    var productAttr = runAssembly.GetCustomAttribute < AssemblyProductAttribute>();
                    if (productAttr != null && !string.IsNullOrWhiteSpace(productAttr.Product))
                    {
                        productName = productAttr.Product;
                    }
                    else if (namespaceParts.Length > 1)
                    {
                        productName = namespaceParts[1];
                    }
                }
                _regkeyBasePath = string.Concat("Software\\", 
                    companyName ?? "unknown", "\\", 
                    productName ?? AppDomain.CurrentDomain.FriendlyName, "\\");
                _regkeyBasePath = string.Concat("Software\\",
                    companyName ?? "BSS", "\\",
                    productName ?? "BssEdit", "\\");
            }
            _name = name;
            _maxEntries = maxEntries;
        }

        public void Reload()
        {
            var mruList = new List<STuple<int, int, string>>();
            using (var mruRootKey = Registry.CurrentUser.OpenSubKey(_regkeyBasePath + _name, RegistryKeyPermissionCheck.ReadSubTree, RegistryRights.ReadKey))
            {
                if (mruRootKey != null)
                {
                    int itemNo;
                    int updateNo;
                    foreach (var keyName in mruRootKey.GetValueNames())
                    {
                        if (!keyName.StartsWith(MRU_KEY_PREFIX)
                        || !int.TryParse(keyName.Substring(MRU_KEY_PREFIX.Length), NumberStyles.None, CultureInfo.InvariantCulture, out itemNo)
                        || mruRootKey.GetValueKind(keyName) != RegistryValueKind.String)
                            continue;

                        var keyValue = mruRootKey.GetValue(keyName) as string;
                        if (keyValue == null)
                            continue;
                        var d = keyValue.IndexOf(':');
                        if (d <= 0 || !int.TryParse(keyValue.Substring(0, d), NumberStyles.None, CultureInfo.InvariantCulture, out updateNo))
                            continue;
                        mruList.Add(STuple.New(updateNo, itemNo, keyValue.Substring(d + 1)));
                        _lastUpdateNo = Math.Max(_lastUpdateNo, updateNo);
                    }
                }
            }
            _usedEntries = mruList.Count;
            if(_maxEntries <= 0)
                _maxEntries = _usedEntries;
            _mru = new STuple<int, int, string>[Math.Max(_maxEntries, _usedEntries)];
            mruList.Sort();
            mruList.CopyTo(_mru);
            _updateEntries = 0;
        }

        public void Save()
        {
            using (var mruRootKey = Registry.CurrentUser.CreateSubKey(_regkeyBasePath + _name, RegistryKeyPermissionCheck.ReadWriteSubTree))
            {
                // delete removed keys
                if (_usedEntries < _mru.Length)
                {
                    for (int i = _usedEntries; i < _mru.Length; ++i)
                    {
                        var t = _mru[i];
                        if (t.Item2 == 0)
                            break;
                        mruRootKey.DeleteValue(string.Concat(MRU_KEY_PREFIX, _mru[i].Item2.ToString(CultureInfo.InvariantCulture)));
                        _mru[i] = STuple.New(0, 0, (string) null);
                    }
                }
                // shrink used keys
                if (_maxEntries < _usedEntries)
                {
                    for (int i = _usedEntries - _maxEntries; --i >= 0;)
                    {
                        mruRootKey.DeleteValue(string.Concat(MRU_KEY_PREFIX, _mru[i].Item2.ToString(CultureInfo.InvariantCulture)));
                    }
                    Array.Copy(_mru, _usedEntries - _maxEntries, _mru, 0, _maxEntries);
                    _usedEntries = _maxEntries;
                    _updateEntries = Math.Min(_updateEntries, _maxEntries);
                }
                if (_maxEntries < _mru.Length)
                {
                    Array.Resize(ref _mru, _maxEntries);
                }
                // Update entries
                for (int i = _usedEntries - _updateEntries; i < _usedEntries; ++i)
                {
                    var t = _mru[i];
                    mruRootKey.SetValue(
                        string.Concat(MRU_KEY_PREFIX, t.Item2.ToString(CultureInfo.InvariantCulture)),
                        string.Concat(t.Item1.ToString(CultureInfo.InvariantCulture), ":", t.Item3),
                        RegistryValueKind.String);
                }
                _updateEntries = 0;
            }
        }

        public int Count
        {
            get
            {
                return _usedEntries;
            }
        }

        public string this[int index]
        {
            get
            {
                return _mru[_usedEntries - index - 1].Item3;
            }
        }

        public IEnumerator<string> GetEnumerator()
        {
            for (int i = _usedEntries; --i >= 0;)
                yield return _mru[i].Item3;
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return this.GetEnumerator();
        }

        public bool IsReadOnly
        {
            get
            {
                return false;
            }
        }

        private int IndexOf(string value)
        {
            for (int i = _usedEntries; --i >= 0;)
                if (value == _mru[i].Item3)
                    return i;
            return -1;
        }

        public bool Contains(string item)
        {
            return this.IndexOf(item) >= 0;
        }

        public void Add(string item)
        {
            int itemNo;
            if (_lastUpdateNo > 99999)
            {
                for (int i = _usedEntries; --i >= 0;)
                {
                    _mru[i].Item1 = i;
                }
                _lastUpdateNo = _usedEntries;
                _updateEntries = _usedEntries;
            }
            var pos = this.IndexOf(item);
            if (pos < 0 && _usedEntries < _maxEntries)
            {
                itemNo = _mru[_usedEntries].Item2;
                if(itemNo == 0)
                {
                    do { ++itemNo; } while (Array.FindIndex(_mru, 0, _usedEntries, t => t.Item2 == itemNo) >= 0);
                }
                _mru[_usedEntries++] = STuple.New(++_lastUpdateNo, itemNo, item);
                ++_updateEntries;
                return;
            }
            if(pos < 0)
            {
                pos = 0;
            }
            if (pos + _updateEntries < _usedEntries)
            {
                ++_updateEntries;
            }
            itemNo = _mru[pos].Item2;
            if (pos < _usedEntries - 1)
            {
                Array.Copy(_mru, pos + 1, _mru, pos, _usedEntries - 1 - pos);
            }
            _mru[_usedEntries - 1] = STuple.New(++_lastUpdateNo, itemNo, item);
        }

        public bool Remove(string item)
        {
            var pos = this.IndexOf(item);
            if (pos < 0)
                return false;
            if (pos + _updateEntries > --_usedEntries)
            {
                --_updateEntries;
            }
            if (pos == _usedEntries)
            {
                _mru[_usedEntries].Item3 = null;
            }
            else
            {
                var t = _mru[pos];
                Array.Copy(_mru, pos + 1, _mru, pos, _usedEntries - pos);
                _mru[_usedEntries] = STuple.New(t.Item1, t.Item2, (string) null);
            }
            return true;
        }

        public void Clear()
        {
            for (int i = _usedEntries; --i >= 0;)
                _mru[i].Item3 = null;
            _usedEntries = _updateEntries = 0;
        }

        public void CopyTo(string[] array, int arrayIndex)
        {
            for (int i = _usedEntries; --i >= 0;)
                array[arrayIndex++] = _mru[i].Item3;
        }
    }
}

    [TestClass]
    public class TestXMLStore
    {
        const int REPEAT_TEST = 1000;
        static string[] PATH = new [] { "TestMru" };

        [TestMethod]
        public void TestFillMRUStore()
        {
            var store = SettingsStorage.I.Value;
            var stopwatch = new Stopwatch();
            var random = new Random();
            var basePath = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments) + "\\хранилища\\";

            store.Load();
            stopwatch.Start();
            for (int i = REPEAT_TEST; --i >= 0;)
            {
                string pickItem = null;
                var key = new SettingsStorageKey(PATH, random.Next(40).ToString());
                if (random.NextDouble() <= 0.4)
                {
                    store.TryGetValue<string>(key, out pickItem);
                }
                if(pickItem == null)
                {
                    pickItem = string.Concat(basePath, random.Next(), ".txt");
                }
                store.SetValue(key, pickItem);
                store.Save();
            }
            stopwatch.Stop();
            Debug.Write("Test completed in " + stopwatch.Elapsed.ToString());
        }

        [TestMethod]
        public void TestLoadMRUStore()
        {
            var store = SettingsStorage.I.Value;
            var stopwatch = new Stopwatch();
            stopwatch.Start();
            for (int i = REPEAT_TEST; --i >= 0;)
            {
                store.Load();
            }
            stopwatch.Stop();
            Debug.Write("Test completed in " + stopwatch.Elapsed.ToString());
        }
    }