public DictionaryAdapterInstance(IDictionary dictionary, PropertyDescriptor descriptor, 
										 IDictionaryAdapterFactory factory)
		{
			Dictionary = dictionary;
			Descriptor = descriptor;
			Factory = factory;
		}

		private void MergeBehaviorOverrides(DictionaryAdapterMeta meta)
		{
			if (Descriptor == null) return;

			var typeDescriptor = Descriptor as DictionaryDescriptor;

			if (typeDescriptor != null)
			{
				Initializers = Initializers.Prioritize(typeDescriptor.Initializers).ToArray();
			}

			Properties = new Dictionary<string, PropertyDescriptor>();

			foreach (var property in meta.Properties)
			{
				var propertyDescriptor = property.Value;

				var propertyOverride = new PropertyDescriptor(propertyDescriptor, false)
					.AddKeyBuilders(propertyDescriptor.KeyBuilders.Prioritize(Descriptor.KeyBuilders))
					.AddGetters(propertyDescriptor.Getters.Prioritize(Descriptor.Getters))
					.AddSetters(propertyDescriptor.Setters.Prioritize(Descriptor.Setters));

				Properties.Add(property.Key, propertyOverride);
			}
		}

		bool IDictionaryPropertySetter.SetPropertyValue(IDictionaryAdapter dictionaryAdapter,
			string key, ref object value, PropertyDescriptor property)
		{
			if (value != null)
			{
				value = GetPropertyAsString(property, value);
			}
			return true;
		}

 public object GetPropertyValue(IDictionaryAdapter dictionaryAdapter, string key, object storedValue, PropertyDescriptor property, bool ifExists)
 {
     if (storedValue != null)
     {
         return storedValue;
     }
     
     throw new InvalidOperationException(string.Format("App setting '{0}' not found!", key));
 }

		public object GetPropertyValue(IDictionaryAdapter dictionaryAdapter,
			string key, object storedValue, PropertyDescriptor property, bool ifExists)
		{
			if (storedValue == null || storedValue.Equals(UnassignedGuid))
			{
				storedValue = Guid.NewGuid();
				property.SetPropertyValue(dictionaryAdapter, key, ref storedValue, dictionaryAdapter.This.Descriptor);
			}

			return storedValue;
		}

		public DictionaryAdapterInstance(IDictionary dictionary, DictionaryAdapterMeta meta,
										 PropertyDescriptor descriptor, IDictionaryAdapterFactory factory)
		{
			Dictionary = dictionary;
			Descriptor = descriptor;
			Factory = factory;

			Properties = meta.Properties;
			Initializers = meta.Initializers;
			MergeBehaviorOverrides(meta);
		}

        public object GetPropertyValue(IDictionaryAdapter dictionaryAdapter, string key, object storedValue, PropertyDescriptor property, bool ifExists)
        {
            if (property.PropertyType.IsAssignableFrom(storedValue.GetType()))
            {
                return storedValue;
            }

            if (property.PropertyType.IsInterface && IsDictionary(storedValue.GetType()))
            {
                return dictionaryAdapter.This.Factory.GetAdapter(property.PropertyType, storedValue as IDictionary);
            }

            return storedValue;
        }

        public object GetPropertyValue(IDictionaryAdapter dictionaryAdapter, string key, object storedValue,
            PropertyDescriptor property, bool ifExists)
        {
            var defaultValue = property.Annotations
                .OfType<DefaultValueAttribute>()
                .SingleOrDefault();

            if (storedValue == null && IsRequired(ifExists) && defaultValue == null)
                throw new KeyNotFoundException("key '" + key + "' not found");

            if (storedValue == null && defaultValue != null)
                return defaultValue.Value;

            return storedValue;
        }

		object IDictionaryPropertyGetter.GetPropertyValue(
			IDictionaryAdapterFactory factory, IDictionary dictionary,
			string key, object storedValue, PropertyDescriptor property)
		{
			if (storedValue == null)
			{
				PropertyDescriptor descriptor = 
					new PropertyDescriptor(property.Property);
				descriptor.AddKeyBuilder(new DictionaryKeyPrefixAttribute(key));

				return factory.GetAdapter(
					property.Property.PropertyType, dictionary, descriptor);
			}

			return storedValue;
		}

		public DictionaryAdapterInstance(IDictionary dictionary, DictionaryAdapterMeta meta,
										 PropertyDescriptor descriptor, IDictionaryAdapterFactory factory)
		{
			Dictionary = dictionary;
			Descriptor = descriptor;
			Factory    = factory;

			List<IDictionaryBehavior> behaviors;

			if (null == descriptor || null == (behaviors = descriptor.BehaviorsInternal))
			{
				Initializers = meta.Initializers;
				Properties   = MergeProperties(meta.Properties);
			}
			else
			{
				Initializers = MergeInitializers(meta.Initializers, behaviors);
				Properties   = MergeProperties(meta.Properties, behaviors);
			}
		}

		object IDictionaryPropertyGetter.GetPropertyValue(IDictionaryAdapter dictionaryAdapter,
			string key, object storedValue, PropertyDescriptor property, bool ifExists)
		{
			if (storedValue == null)
			{
				var component = dictionaryAdapter.This.ExtendedProperties[property.PropertyName];

				if (component == null)
				{
					var descriptor = new PropertyDescriptor(property.Property, null);
					descriptor.AddKeyBuilder(new KeyPrefixAttribute(key));
					component = dictionaryAdapter.This.Factory.GetAdapter(
						property.Property.PropertyType, dictionaryAdapter.This.Dictionary, descriptor);
					dictionaryAdapter.This.ExtendedProperties[property.PropertyName] = component;
				}

				return component;
			}

			return storedValue;
		}

		private static bool IsCollection(PropertyDescriptor property, out Type collectionItemType)
		{
			collectionItemType = null;
			var propertyType = property.PropertyType;
			if (propertyType != typeof(string) && typeof(IEnumerable).IsAssignableFrom(propertyType))
			{
				if (propertyType.IsArray)
				{
					collectionItemType = propertyType.GetElementType();
				}
				else if (propertyType.IsGenericType)
				{
					var arguments = propertyType.GetGenericArguments();
					collectionItemType = arguments[0];
				}
				else
				{
					collectionItemType = typeof(object);
				}
				return true;
			}
			return false;
		}

		public bool SetPropertyValue(IDictionaryAdapter dictionaryAdapter, string key, ref object value, PropertyDescriptor property)
		{
			value = (value != null) ? value.ToString() : null;
			return true;
		}

		String IDictionaryKeyBuilder.GetKey(IDictionaryAdapter dictionaryAdapter, String key, PropertyDescriptor property)
		{
			return String.Format("{0}#{1}", property.Property.DeclaringType.FullName, key);
		}

		private static bool IsVolatileProperty(IDictionaryAdapter dictionaryAdapter, PropertyDescriptor property)
		{
			return dictionaryAdapter.Meta.Behaviors.Union(property.Behaviors).Any(behavior => behavior is VolatileAttribute);
		}

		private static bool ShouldIgnoreProperty(PropertyDescriptor property)
		{
			return property.Behaviors.Any(behavior => behavior is XmlIgnoreAttribute);
		}

		public override PropertyDescriptor CopyBehaviors(PropertyDescriptor other, Func<IDictionaryBehavior, bool> selector)
		{
			if (other is DictionaryDescriptor)
			{
				var otherDict = (DictionaryDescriptor)other;
				CopyMetaInitializers(otherDict, selector).CopyInitializers(otherDict, selector);
			}
			return base.CopyBehaviors(other, selector);
		}

		public override PropertyDescriptor CopyBehaviors(PropertyDescriptor other)
		{
			if (other is DictionaryDescriptor)
			{
				var otherDict = (DictionaryDescriptor)other;
				CopyMetaInitializers(otherDict).CopyInitializers(otherDict);
			}
			return base.CopyBehaviors(other);
		}

		public bool SetPropertyValue(IDictionaryAdapter dictionaryAdapter,
			string key, ref object value, PropertyDescriptor property)
		{
			dictionaryAdapter.This.ExtendedProperties.Remove(property.PropertyName);
			return true;
		}

		string IDictionaryKeyBuilder.GetKey(IDictionaryAdapter dictionaryAdapter, string key,
		                                    PropertyDescriptor property)
		{
			return prefix ?? key + "_";
		}