private void AddItems(IEnumerable groupedItems, MvxExpandableDataConverter groupedDataConverter)
        {
            foreach (var mvxGroupable in groupedItems.Cast <object>().Select(groupedDataConverter.ConvertToMvxGroupedData))
            {
                if (!_observableItemsSource.Contains(mvxGroupable))
                {
                    _observableItemsSource.Add(mvxGroupable);
                }

                var childNotifyCollectionChanged = mvxGroupable.GroupItems as INotifyCollectionChanged;

                if (childNotifyCollectionChanged == null)
                {
                    continue;
                }

                if (!_groupedDataDisposables.ContainsKey(mvxGroupable))
                {
                    EventHandler <NotifyCollectionChangedEventArgs> collectionChangedHandler = (sender, args) =>
                    {
                        switch (args.Action)
                        {
                        case NotifyCollectionChangedAction.Add:
                            AddChildItems(mvxGroupable, args.NewItems);
                            break;

                        case NotifyCollectionChangedAction.Remove:
                            RemoveChildItems(mvxGroupable, args.OldItems);
                            break;

                        case NotifyCollectionChangedAction.Reset:
                            ResetChildCollection(mvxGroupable);
                            break;

                        default:
                            ItemsMovedOrReplaced?.Invoke();
                            break;
                        }
                    };

                    _groupedDataDisposables.Add(mvxGroupable,
                                                new EventHandlerWeakSubscriptionHolder(
                                                    collectionChangedHandler,
                                                    childNotifyCollectionChanged.WeakSubscribe(collectionChangedHandler)
                                                    )
                                                );
                }
            }
        }
        void ObservableGroups_CollectionChanged(object sender, NotifyCollectionChangedEventArgs args)
        {
            switch (args.Action)
            {
            case NotifyCollectionChangedAction.Reset:
                var enumerableGroupedItems = sender as IEnumerable ?? Enumerable.Empty <object>();
                _observableItemsSource.Clear();
                foreach (var disposables in _groupedDataDisposables.Values)
                {
                    disposables.Dispose();
                }

                _groupedDataDisposables.Clear();
                AddItems(enumerableGroupedItems, groupedDataConverter);
                break;

            case NotifyCollectionChangedAction.Add:
                var enumerableGroupedItems2 = sender as IEnumerable ?? Enumerable.Empty <object>();
                _observableItemsSource.Clear();
                foreach (var disposables in _groupedDataDisposables.Values)
                {
                    disposables.Dispose();
                }

                _groupedDataDisposables.Clear();
                AddItems(enumerableGroupedItems2, groupedDataConverter);
                break;

            case NotifyCollectionChangedAction.Remove:
                foreach (var item in Enumerable.Cast <object>(args.OldItems))
                {
                    var mvxGroupedData = groupedDataConverter.ConvertToMvxGroupedData(item);

                    _observableItemsSource.Remove(mvxGroupedData);

                    if (_groupedDataDisposables.ContainsKey(mvxGroupedData))
                    {
                        _groupedDataDisposables[mvxGroupedData].Dispose();
                        _groupedDataDisposables.Remove(mvxGroupedData);
                    }
                }
                break;

            default:
                ItemsMovedOrReplaced?.Invoke();
                break;
            }
        }