public override OptionSet WithChangedOption(OptionKey optionAndLanguage, object value)
        {
            // make sure we first load this in current optionset
            this.GetOption(optionAndLanguage);

            return new WorkspaceOptionSet(_service, _values.SetItem(optionAndLanguage, value));
        }

        bool IOptionSerializer.TryFetch(OptionKey optionKey, out object value)
        {
            var collectionPath = GetCollectionPathForOption(optionKey);
            if (collectionPath == null)
            {
                value = null;
                return false;
            }

            lock (_gate)
            {
                using (var subKey = this._registryKey.OpenSubKey(collectionPath))
                {
                    if (subKey == null)
                    {
                        value = null;
                        return false;
                    }

                    // Options that are of type bool have to be serialized as integers
                    if (optionKey.Option.Type == typeof(bool))
                    {
                        value = subKey.GetValue(optionKey.Option.Name, defaultValue: (bool)optionKey.Option.DefaultValue ? 1 : 0).Equals(1);
                        return true;
                    }
                    else
                    {
                        // Otherwise we can just store normally
                        value = subKey.GetValue(optionKey.Option.Name, defaultValue: optionKey.Option.DefaultValue);
                        return true;
                    }
                }
            }
        }

        public virtual bool TryPersist(OptionKey optionKey, object value)
        {
            // We ignore languageName, since the current use of this class is only for
            // language-specific options that apply to a single language. The underlying option
            // service has already ensured the languageName is right, so we'll drop it on the floor.
            if (this.RegistryKey == null)
            {
                throw new InvalidOperationException();
            }

            var collectionPathAndPropertyName = GetCollectionPathAndPropertyNameForOption(optionKey.Option, optionKey.Language);
            if (collectionPathAndPropertyName == null)
            {
                return false;
            }

            lock (Gate)
            {
                using (var subKey = this.RegistryKey.CreateSubKey(collectionPathAndPropertyName.Item1))
                {
                    subKey.SetValue(collectionPathAndPropertyName.Item2, (bool)value ? 1 : 0, RegistryValueKind.DWord);
                }

                return true;
            }
        }

        public virtual bool TryFetch(OptionKey optionKey, out object value)
        {
            if (this.RegistryKey == null)
            {
                throw new InvalidOperationException();
            }

            var collectionPathAndPropertyName = GetCollectionPathAndPropertyNameForOption(optionKey.Option, optionKey.Language);
            if (collectionPathAndPropertyName == null)
            {
                value = null;
                return false;
            }

            lock (Gate)
            {
                using (var openSubKey = this.RegistryKey.OpenSubKey(collectionPathAndPropertyName.Item1))
                {
                    if (openSubKey == null)
                    {
                        value = null;
                        return false;
                    }

                    value = openSubKey.GetValue(collectionPathAndPropertyName.Item2, defaultValue: (bool)optionKey.Option.DefaultValue ? 1 : 0).Equals(1);
                    return true;
                }
            }
        }

        protected override string GetCollectionPathForOption(OptionKey key)
        {
            if (key.Option.Feature == EditorComponentOnOffOptions.OptionName)
            {
                return @"Roslyn\Internal\OnOff\Components";
            }
            else if (key.Option.Feature == InternalFeatureOnOffOptions.OptionName)
            {
                return @"Roslyn\Internal\OnOff\Features";
            }
            else if (key.Option.Feature == PerformanceFunctionIdOptionsProvider.Name)
            {
                return @"Roslyn\Internal\Performance\FunctionId";
            }
            else if (key.Option.Feature == LoggerOptions.FeatureName)
            {
                return @"Roslyn\Internal\Performance\Logger";
            }
            else if (key.Option.Feature == InternalDiagnosticsOptions.OptionName)
            {
                return @"Roslyn\Internal\Diagnostics";
            }
            else if (key.Option.Feature == InternalSolutionCrawlerOptions.OptionName)
            {
                return @"Roslyn\Internal\SolutionCrawler";
            }
            else if (key.Option.Feature == CacheOptions.FeatureName)
            {
                return @"Roslyn\Internal\Performance\Cache";
            }

            throw ExceptionUtilities.Unreachable;
        }

        bool IOptionSerializer.TryPersist(OptionKey optionKey, object value)
        {
            if (this._registryKey == null)
            {
                throw new InvalidOperationException();
            }

            var collectionPath = GetCollectionPathForOption(optionKey);
            if (collectionPath == null)
            {
                return false;
            }

            lock (_gate)
            {
                using (var subKey = this._registryKey.CreateSubKey(collectionPath))
                {
                    // Options that are of type bool have to be serialized as integers
                    if (optionKey.Option.Type == typeof(bool))
                    {
                        subKey.SetValue(optionKey.Option.Name, (bool)value ? 1 : 0, RegistryValueKind.DWord);
                        return true;
                    }
                    else
                    {
                        subKey.SetValue(optionKey.Option.Name, value);
                        return true;
                    }
                }
            }
        }

        protected bool TryPersist(OptionKey optionKey, object value, Action<RegistryKey, string, IOption, object> valueSetter)
        {
            // We ignore languageName, since the current use of this class is only for
            // language-specific options that apply to a single language. The underlying option
            // service has already ensured the languageName is right, so we'll drop it on the floor.
            if (this.RegistryKey == null)
            {
                throw new InvalidOperationException();
            }

            var collectionPathAndPropertyName = GetCollectionPathAndPropertyNameForOption(optionKey.Option, optionKey.Language);
            if (collectionPathAndPropertyName == null)
            {
                return false;
            }

            lock (Gate)
            {
                using (var subKey = this.RegistryKey.CreateSubKey(collectionPathAndPropertyName.Item1))
                {
                    valueSetter(subKey, collectionPathAndPropertyName.Item2, optionKey.Option, value);
                    return true;
                }
            }
        }

            public bool TryGetDocumentOption(Document document, OptionKey option, out object value)
            {
                var editorConfigPersistence = option.Option.StorageLocations.OfType<EditorConfigStorageLocation>().SingleOrDefault();

                if (editorConfigPersistence == null)
                {
                    value = null;
                    return false;
                }

                if (_codingConventionSnapshot.TryGetConventionValue(editorConfigPersistence.KeyName, out value))
                {
                    try
                    {
                        value = editorConfigPersistence.ParseValue(value.ToString(), option.Option.Type);
                        return true;
                    }
                    catch (Exception)
                    {
                        // TODO: report this somewhere?
                        return false;
                    }
                }
                else
                {
                    return false;
                }
            }

        protected bool TryFetch(OptionKey optionKey, Func<RegistryKey, string, IOption, object> valueGetter, out object value)
        {
            if (this.RegistryKey == null)
            {
                throw new InvalidOperationException();
            }

            var collectionPathAndPropertyName = GetCollectionPathAndPropertyNameForOption(optionKey.Option, optionKey.Language);
            if (collectionPathAndPropertyName == null)
            {
                value = null;
                return false;
            }

            lock (Gate)
            {
                using (var subKey = this.RegistryKey.OpenSubKey(collectionPathAndPropertyName.Item1))
                {
                    if (subKey == null)
                    {
                        value = null;
                        return false;
                    }

                    value = valueGetter(subKey, collectionPathAndPropertyName.Item2, optionKey.Option);
                    return true;
                }
            }
        }

        public bool TryFetch(OptionKey optionKey, out object value)
        {
            if (this._settingManager == null)
            {
                Debug.Fail("Manager field is unexpectedly null.");
                value = null;
                return false;
            }

            // Do we roam this at all?
            var roamingSerialization = optionKey.Option.StorageLocations.OfType<RoamingProfileStorageLocation>().SingleOrDefault();

            if (roamingSerialization == null)
            {
                value = null;
                return false;
            }

            var storageKey = roamingSerialization.GetKeyNameForLanguage(optionKey.Language);

            RecordObservedValueToWatchForChanges(optionKey, storageKey);

            value = this._settingManager.GetValueOrDefault(storageKey, optionKey.Option.DefaultValue);

            // VS's ISettingsManager has some quirks around storing enums.  Specifically,
            // it *can* persist and retrieve enums, but only if you properly call 
            // GetValueOrDefault<EnumType>.  This is because it actually stores enums just
            // as ints and depends on the type parameter passed in to convert the integral
            // value back to an enum value.  Unfortunately, we call GetValueOrDefault<object>
            // and so we get the value back as boxed integer.
            //
            // Because of that, manually convert the integer to an enum here so we don't
            // crash later trying to cast a boxed integer to an enum value.
            if (optionKey.Option.Type.IsEnum)
            {
                if (value != null)
                {
                    value = Enum.ToObject(optionKey.Option.Type, value);
                }
            }
            else if (optionKey.Option.Type == typeof(CodeStyleOption<bool>))
            {
                // We store these as strings, so deserialize
                var serializedValue = value as string;

                if (serializedValue != null)
                {
                    value = CodeStyleOption<bool>.FromXElement(XElement.Parse(serializedValue));
                }
                else
                {
                    value = optionKey.Option.DefaultValue;
                }
            }

            return true;
        }

 private static KeyValueLogMessage Create(OptionKey optionKey, object oldValue, object currentValue)
 {
     return KeyValueLogMessage.Create(m =>
     {
         m[Name] = optionKey.Option.Name;
         m[Language] = optionKey.Language ?? All;
         m[Change] = CreateOptionValue(oldValue, currentValue);
     });
 }

 public void GettingOptionWithChangedOption()
 {
     var optionService = TestOptionService.GetService();
     var optionSet = optionService.GetOptions();
     var option = new Option<bool>("Test Feature", "Test Name", false);
     var key = new OptionKey(option);
     Assert.False(optionSet.GetOption(option));
     optionSet = optionSet.WithChangedOption(key, true);
     Assert.True((bool)optionSet.GetOption(key));
 }

        public override bool TryFetch(OptionKey optionKey, out object value)
        {
            switch (optionKey.Option.Feature)
            {
                case CacheOptions.FeatureName:
                case InternalSolutionCrawlerOptions.OptionName:
                    return TryFetch(optionKey, (r, k, o) => r.GetValue(k, defaultValue: o.DefaultValue), out value);
            }

            return base.TryFetch(optionKey, out value);
        }

        public override bool TryPersist(OptionKey optionKey, object value)
        {
            switch (optionKey.Option.Feature)
            {
                case CacheOptions.FeatureName:
                case InternalSolutionCrawlerOptions.OptionName:
                    return TryPersist(optionKey, value, (r, k, o, v) => r.SetValue(k, v, o.Type == typeof(int) ? RegistryValueKind.DWord : RegistryValueKind.QWord));
            }

            return base.TryPersist(optionKey, value);
        }

        public bool TryFetch(OptionKey optionKey, out object value)
        {
            value = string.Empty;
            if (optionKey != TodoCommentOptions.TokenList)
            {
                return false;
            }

            value = _taskTokenList;
            return true;
        }

        public override object GetOption(OptionKey optionKey)
        {
            lock (_gate)
            {
                if (!_values.TryGetValue(optionKey, out var value))
                {
                    value = _service != null ? _service.GetOption(optionKey) : optionKey.Option.DefaultValue;
                    _values = _values.Add(optionKey, value);
                }

                return value;
            }
        }

        private void SetChangedOption(IOptionService optionService, IOption option, string languageName)
        {
            OptionKey key = new OptionKey(option, languageName);

            object currentValue;
            if (this.TryFetch(key, out currentValue))
            {
                OptionSet optionSet = optionService.GetOptions();
                optionSet = optionSet.WithChangedOption(key, currentValue);

                optionService.SetOptions(optionSet);
            }
        }

        public override bool TryPersist(OptionKey optionKey, object value)
        {
            if (optionKey.Option.Feature == CacheOptions.FeatureName)
            {
                lock (Gate)
                {
                    using (var subKey = this.RegistryKey.CreateSubKey(CachePath))
                    {
                        subKey.SetValue(optionKey.Option.Name, value, optionKey.Option.Type == typeof(int) ? RegistryValueKind.DWord : RegistryValueKind.QWord);
                        return true;
                    }
                }
            }

            return base.TryPersist(optionKey, value);
        }

        public override bool TryFetch(OptionKey optionKey, out object value)
        {
            if (optionKey.Option.Feature == CacheOptions.FeatureName)
            {
                lock (Gate)
                {
                    using (var openSubKey = this.RegistryKey.OpenSubKey(CachePath))
                    {
                        if (openSubKey == null)
                        {
                            value = null;
                            return false;
                        }

                        value = openSubKey.GetValue(optionKey.Option.Name, defaultValue: optionKey.Option.DefaultValue);
                        return true;
                    }
                }
            }

            return base.TryFetch(optionKey, out value);
        }

        bool IOptionPersister.TryFetch(OptionKey optionKey, out object value)
        {
            string path;
            string key;

            if (!TryGetKeyPathAndName(optionKey.Option, out path, out key))
            {
                value = null;
                return false;
            }

            lock (_gate)
            {
                using (var subKey = this._registryKey.OpenSubKey(path))
                {
                    if (subKey == null)
                    {
                        value = null;
                        return false;
                    }

                    // Options that are of type bool have to be serialized as integers
                    if (optionKey.Option.Type == typeof(bool))
                    {
                        value = subKey.GetValue(key, defaultValue: (bool)optionKey.Option.DefaultValue ? 1 : 0).Equals(1);
                        return true;
                    }
                    else
                    {
                        // Otherwise we can just store normally
                        value = subKey.GetValue(key, defaultValue: optionKey.Option.DefaultValue);
                        return true;
                    }
                }
            }
        }