/// <summary>
        /// Retrieves the value itself or the value of one of its item, depending on the given <see cref="Index"/>.
        /// </summary>
        /// <param name="value">The value on which this method applies.</param>
        /// <param name="index">The index of the item to retrieve. If <see cref="Index.Empty"/> is passed, this method will return the value itself.</param>
        /// <param name="descriptor">The descriptor of the type of <paramref name="value"/>.</param>
        /// <returns>The value itself or the value of one of its item.</returns>
        public static object Retrieve(object value, Index index, ITypeDescriptor descriptor)
        {
            if (index.IsEmpty)
                return value;

            if (value == null) throw new ArgumentNullException(nameof(value));

            var collectionDescriptor = descriptor as CollectionDescriptor;
            if (collectionDescriptor != null)
            {
                return collectionDescriptor.GetValue(value, index.Int);
            }
            var dictionaryDescriptor = descriptor as DictionaryDescriptor;
            if (dictionaryDescriptor != null)
            {
                return dictionaryDescriptor.GetValue(value, index.Value);
            }

            // Try with the concrete type descriptor
            var objectDescriptor = TypeDescriptorFactory.Default.Find(value.GetType());
            if (objectDescriptor != descriptor)
            {
                return Retrieve(value, index, objectDescriptor);
            }

            throw new NotSupportedException("Unable to retrieve the value at the given index, this collection is unsupported");
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="ObjectContext"/> struct.
 /// </summary>
 /// <param name="serializerContext">The serializer context.</param>
 /// <param name="instance">The instance.</param>
 /// <param name="descriptor">The descriptor.</param>
 public ObjectContext(SerializerContext serializerContext, object instance, ITypeDescriptor descriptor)
     : this()
 {
     SerializerContext = serializerContext;
     Instance = instance;
     Descriptor = descriptor;
 }

        /// <inheritdoc/>
        protected override object TransformForSerialization(ITypeDescriptor descriptor, object collection)
        {
            var dictionaryDescriptor = (DictionaryDescriptor)descriptor;
            var instance = CreatEmptyContainer(descriptor);

            CollectionItemIdentifiers identifier;
            if (!CollectionItemIdHelper.TryGetCollectionItemIds(collection, out identifier))
            {
                identifier = new CollectionItemIdentifiers();
            }
            var keyWithIdType = typeof(KeyWithId<>).MakeGenericType(dictionaryDescriptor.KeyType);
            foreach (var item in dictionaryDescriptor.GetEnumerator(collection))
            {
                ItemId id;
                if (!identifier.TryGet(item.Key, out id))
                {
                    id = ItemId.New();
                    identifier.Add(item.Key, id);
                }
                var keyWithId = Activator.CreateInstance(keyWithIdType, id, item.Key);
                instance.Add(keyWithId, item.Value);
            }

            return instance;
        }

 /// <inheritdoc/>
 public override void VisitCollectionItem(IEnumerable collection, CollectionDescriptor descriptor, int index, object item, ITypeDescriptor itemDescriptor)
 {
     if (CurrentPath.Match(MemberPath))
         VisitAssetMember(item, itemDescriptor);
     else
         base.VisitCollectionItem(collection, descriptor, index, item, itemDescriptor);
 }

 public FlexiPlainTextSerializationContext(
     IFlexiPlainTextSerializer serializer,
     ITypeDescriptor typeDescriptor,
     TypeResolver typeResolver,
     Func<Type, CreateInstanceContext, object> createInstanceWith = null)
     : base(serializer, typeDescriptor, typeResolver, createInstanceWith)
 { }

 protected ContentBase(ITypeDescriptor descriptor, bool isPrimitive, IReference reference)
 {
     if (descriptor == null) throw new ArgumentNullException(nameof(descriptor));
     Reference = reference;
     Descriptor = descriptor;
     IsPrimitive = isPrimitive;
 }

 /// <inheritdoc/>
 public override void VisitArrayItem(Array array, ArrayDescriptor descriptor, int index, object item, ITypeDescriptor itemDescriptor)
 {
     if (CurrentPath.Match(MemberPath))
         VisitAssetMember(item, itemDescriptor);
     else
         base.VisitArrayItem(array, descriptor, index, item, itemDescriptor);
 }

        public override IYamlSerializable TryCreate(SerializerContext context, ITypeDescriptor typeDescriptor)
        {
            if (CanVisit(typeDescriptor.Type))
                return this;

            return null;
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="ObjectContext"/> struct.
 /// </summary>
 /// <param name="serializerContext">The serializer context.</param>
 /// <param name="instance">The instance.</param>
 /// <param name="descriptor">The descriptor.</param>
 public ObjectContext(SerializerContext serializerContext, object instance, ITypeDescriptor descriptor) : this()
 {
     SerializerContext = serializerContext;
     Instance = instance;
     Descriptor = descriptor;
     Properties = new PropertyContainer();
 }

 public ObjectContent(object value, ITypeDescriptor descriptor, bool isPrimitive, IReference reference)
     : base(descriptor, isPrimitive, reference)
 {
     if (reference is ObjectReference)
         throw new ArgumentException($"An {nameof(ObjectContent)} cannot contain an {nameof(ObjectReference)}");
     this.value = value;
 }

        public Unbinder(ITypeDescriptor typeDescriptor,
		                ITypeSimplicityEvaluator typeSimplicityEvaluator,
		                IValueUnbinder valueUnbinder)
        {
            _typeDescriptor = typeDescriptor;
            _typeSimplicityEvaluator = typeSimplicityEvaluator;
            _valueUnbinder = valueUnbinder;
        }

 void InitFromItemDescriptor(ITypeDescriptor descriptor)
 {
     if (descriptor == _itemDescriptor && _name != null) return;
     _itemDescriptor = descriptor;
     if ((descriptor.Name?.Length ?? 0) == 0) return;
     _itemType = _itemDescriptor.GetPreferedType();
     Sealed = _itemDescriptor.Sealed;
     Name = $"List<{_itemDescriptor.Name}>";
 }

 protected ContentBase(ITypeDescriptor descriptor, bool isPrimitive, IReference reference)
 {
     if (descriptor == null) throw new ArgumentNullException("descriptor");
     this.reference = reference;
     Descriptor = descriptor;
     IsPrimitive = isPrimitive;
     SerializeFlags = ViewModelContentSerializeFlags.SerializeValue;
     ShouldProcessReference = true;
 }

        public override void VisitDictionaryKeyValue(object dictionary, DictionaryDescriptor descriptor, object key, ITypeDescriptor keyDescriptor, object value, ITypeDescriptor valueDescriptor)
        {
            // TODO: CurrentPath is valid only for value, not key
            //if (ProcessObject(key, keyDescriptor.Type)) key = null;
            if (ProcessObject(value, valueDescriptor.Type)) return;

            Visit(value, valueDescriptor);
            //base.VisitDictionaryKeyValue(dictionary, descriptor, key, keyDescriptor, value, valueDescriptor);
        }

 protected override IDataContextStack CreateDataContextTypeStack(ITypeDescriptor viewModelType, ITypeDescriptor wrapperType = null, IDataContextStack parentDataContextStack = null)
 {
     var dataContextTypeStack = new DataContextStack(ResolvedTypeDescriptor.ToSystemType(viewModelType), parentDataContextStack as DataContextStack);
     if (wrapperType != null)
     {
         dataContextTypeStack.RootControlType = ResolvedTypeDescriptor.ToSystemType(wrapperType);
     }
     return dataContextTypeStack;
 }

 public FlexiXmlSerializationContext(
     IFlexiSerializer serializer, 
     ITypeDescriptor typeDescriptor, 
     TypeResolver typeResolver,
     FlexiXmlSerializationOptions options,
     Func<Type, CreateInstanceContext, object> createInstanceWith = null)
     : base(serializer, typeDescriptor, typeResolver, createInstanceWith)
 {
     this.Options = options;
 }

 /// <inheritdoc/>
 public override IYamlSerializable TryCreate(SerializerContext context, ITypeDescriptor typeDescriptor)
 {
     if (typeDescriptor is CollectionDescriptor)
     {
         var dataStyle = typeDescriptor.Type.GetCustomAttribute<DataStyleAttribute>();
         if (dataStyle == null || dataStyle.Style != DataStyle.Compact)
             return this;
     }
     return null;
 }

 public SerializationContext(
     IFlexiSerializer serializer,
     ITypeDescriptor typeDescriptor,
     TypeResolver typeResolver,
     Func<Type, CreateInstanceContext, object> createInstanceWith = null)
 {
     this.Serializer = serializer;
     this.TypeDescriptor = typeDescriptor;
     this.TypeResolver = typeResolver;
     this.CustomCreateInstanceWith = createInstanceWith;
 }

 void InitFromKeyValueDescriptors(ITypeDescriptor keyDescriptor, ITypeDescriptor valueDescriptor)
 {
     if (_keyDescriptor == keyDescriptor && _valueDescriptor == valueDescriptor && _name != null) return;
     _keyDescriptor = keyDescriptor;
     _valueDescriptor = valueDescriptor;
     if ((_keyDescriptor.Name?.Length ?? 0) == 0 || (_valueDescriptor.Name?.Length ?? 0) == 0) return;
     _keyType = _keyDescriptor.GetPreferedType();
     _valueType = _valueDescriptor.GetPreferedType();
     Sealed = _keyDescriptor.Sealed && _valueDescriptor.Sealed;
     Name = $"Dictionary<{_keyDescriptor.Name}, {_valueDescriptor.Name}>";
 }

        /// <inheritdoc/>
        public override bool CanAttach(ITypeDescriptor typeDescriptor, MemberDescriptorBase memberDescriptor)
        {
            var type = typeDescriptor.GetInnerCollectionType();
            var isNullableStruct = type.IsNullable() && Nullable.GetUnderlyingType(type).IsStruct();
            var isAbstractOrClass = type.IsAbstract || type.IsClass;
            //var isCollection = (typeDescriptor is CollectionDescriptor) || (typeDescriptor is DictionaryDescriptor);

            //var result = isNullableStruct || (isAbstractOrClass && !isCollection);
            var result = isNullableStruct || isAbstractOrClass;
            return result;
        }