/// <summary>
        /// Initializes a new instance of the <see cref="CollectionObserver"/> class.
        /// </summary>
        /// <param name="collection">The collection.</param>
        /// <param name="tag">The tag.</param>
        /// <param name="mementoService">The memento service.</param>
        /// <exception cref="ArgumentNullException">The <paramref name="collection"/> is <c>null</c>.</exception>
        public CollectionObserver(INotifyCollectionChanged collection, object tag = null, IMementoService mementoService = null)
            : base(tag, mementoService)
        {
            Argument.IsNotNull("collection", collection);

            _weakEventListener = this.SubscribeToWeakCollectionChangedEvent(collection, OnCollectionChanged);
        }

 public void Include(INotifyCollectionChanged changed)
 {
     changed.CollectionChanged += (s, e) =>
     {
         var test = string.Format("{0}{1}{2}{3}{4}", e.Action, e.NewItems, e.NewStartingIndex, e.OldItems, e.OldStartingIndex);
     };
 }

        /// <summary>
        /// Constructor with collection and property name</summary>
        /// <param name="collection">Collection whose changes are listened to</param>
        /// <param name="propertyName">Property whose value change is listened to</param>
        public CollectionChangeListener(INotifyCollectionChanged collection, string propertyName)
        {
            m_value = collection;
            PropertyName = propertyName;

            Subscribe();
        }

        /// <summary>
        /// Begins observing the given notifying collection.
        /// </summary>
        /// <param name="notifyingCollection"></param>
        public void ObserveCollection(INotifyCollectionChanged notifyingCollection)
        {
            notifyingCollection.ThrowIfNull ("notifyingCollection");

            if (IsDisposed) return;

            if (myObservedCollections.ContainsKey (notifyingCollection)) return;

            myObservedCollections[notifyingCollection] = () => notifyingCollection.CollectionChanged -= myCollectionChangedEventHandler;

            NotificationChainPropertyAttribute.CallProperties (notifyingCollection);

            notifyingCollection.CollectionChanged += myCollectionChangedEventHandler;

            var enumerable = notifyingCollection as IEnumerable;
            if (enumerable != null)
            {
                foreach (var item in enumerable)
                {
                    var inpc = item as INotifyPropertyChanged;
                    if (inpc != null)
                        base.Observe (inpc);
                }
            }
        }

 private void DetachNotificationEvents(INotifyCollectionChanged notifyCollection)
 {
     if (notifyCollection != null)
     {
         notifyCollection.CollectionChanged -= OnCollectionChanged;
     }
 }

 public CollectionChangedEventListener(INotifyCollectionChanged source, NotifyCollectionChangedEventHandler handler)
 {
     if (source == null) { throw new ArgumentNullException("source"); }
     if (handler == null) { throw new ArgumentNullException("handler"); }
     this.source = source;
     this.handler = handler;
 }

        /// <summary>
        /// Remove a handler for the given source's event.
        /// </summary>
        public static void RemoveHandler(INotifyCollectionChanged source, EventHandler<NotifyCollectionChangedEventArgs> handler)
        {
            if (handler == null)
                throw new ArgumentNullException("handler");

            CurrentManager.ProtectedRemoveHandler(source, handler);
        }

 public CollectionObserver(INotifyCollectionChanged collection, Action<NotifyCollectionChangedEventArgs> collectionChanged)
 {
     _collectionChanged = collectionChanged;
     _collectionObserver = Observable.FromEventPattern<NotifyCollectionChangedEventHandler, NotifyCollectionChangedEventArgs>(
         ev => collection.CollectionChanged += ev, ev => collection.CollectionChanged -= ev)
         .Subscribe(e => CollectionChanged(e.EventArgs));
 }

 public Capture(ListBox listBox)
 {
     this.listBox = listBox;
     incc = listBox.ItemsSource as INotifyCollectionChanged;
     incc.CollectionChanged +=
         new NotifyCollectionChangedEventHandler(incc_CollectionChanged);
 }

		public CollectionSynchronizer(INotifyCollectionChanged source, ObservableCollection<object> target, IValueConverter valueConverter)
		{
			_source = source;
			_target = target;
			_valueConverter = valueConverter;
			_source.CollectionChanged += OnSourceCollectionChanged;
		}

        private UICollectionSynchronizer(IList<CardViewModel> collection, INotifyCollectionChanged collectionChanged, StackLayout stackLayout, GamePageModel gamePageModel)
        {
            this.stackLayout = stackLayout;
            this.gamePageModel = gamePageModel;
            ((INotifyCollectionChanged)collection).CollectionChanged += (object sender, NotifyCollectionChangedEventArgs e) => {
                if (e.Action == NotifyCollectionChangedAction.Reset) {
                    this.stackLayout.Children.Clear ();
                    this.mapper.Clear ();
                } else {
                    if(e.OldItems != null)
                    {
                        foreach (CardViewModel card in e.OldItems) {
                            this.RemoveItem(card);
                        }
                    }

                    if(e.NewItems != null)
                    {
                        foreach (CardViewModel card in e.NewItems) {
                            this.AddItem(card);
                        }
                    }
                }
            };
            foreach (CardViewModel card in collection) {
                this.AddItem (card);
            }
        }

        protected override SnapshotState CheckValueChanged(object newValue)
        {
            if (_listenedCollectionAsINotifyCollectionChanged != null &&
                ReferenceEquals(_listenedCollectionAsINotifyCollectionChanged, newValue))
            {
                return this.State;
            }

            ReleaseListeners();

            var newValueAsINotifyCollectionChanged = newValue as INotifyCollectionChanged;
            var newValueAsIEnumerable = newValue as IEnumerable;

            if (newValueAsINotifyCollectionChanged == null || newValueAsIEnumerable == null ||
                newValue.GetType() != this.SnapshotValue.GetType())
            {
                return SnapshotState.CHANGED;
            }

            _listenedCollectionAsINotifyCollectionChanged = newValueAsINotifyCollectionChanged;
            _listenedCollectionAsIEnumerable = newValueAsIEnumerable;
            _listenedCollectionAsINotifyCollectionChanged.CollectionChanged += OnCollectionChanged;

            return CheckCollectionChanged();
        }

        public CollectionNotificationChainManager(INotifyCollectionChanged notifyingCollection)
            : this()
        {
            notifyingCollection.ThrowIfNull ("notifyingCollection");

            ObserveCollection (notifyingCollection);
        }

        public static void UnhookCollectionChangedEvent(INotifyCollectionChanged collection, object target, PropertyInfo property)
        {
            _collectionPropertyMap
                .Where(t => t.CollectionReference.Target == collection && t.TargetReference.Target == target && t.Property == property)
                .ToList().ForEach(t => _collectionPropertyMap.Remove(t));

            collection.CollectionChanged -= HandleCollectionChanged;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="CollectionObserver"/> class.
        /// </summary>
        /// <param name="collection">The collection.</param>
        /// <param name="tag">The tag.</param>
        /// <param name="mementoService">The memento service.</param>
        /// <exception cref="ArgumentNullException">The <paramref name="collection"/> is <c>null</c>.</exception>
        public CollectionObserver(INotifyCollectionChanged collection, object tag = null, IMementoService mementoService = null)
            : base(tag, mementoService)
        {
            Argument.IsNotNull("collection", collection);

            _collection = collection;
            _collection.CollectionChanged += OnCollectionChanged;
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="WeakCollectionChangedListener"/>
 /// </summary>
 /// <param name="source">The source event source</param>
 /// <param name="listener">The listener event listener</param>
 private WeakCollectionChangedListener(
     INotifyCollectionChanged source,
     ICollectionChangedListener listener)
 {
     this._source = source;
     this._source.CollectionChanged += this.SourceCollectionChanged;
     this._weakListener = new WeakReference(listener);
 }

        //
        //  Public Methods 
        //

        /// <summary>
        /// Add a listener to the given source's event. 
        /// </summary>
        public static void AddListener(INotifyCollectionChanged source, IWeakEventListener listener) 
        { 
            if (source == null)
                throw new ArgumentNullException("source"); 
            if (listener == null)
                throw new ArgumentNullException("listener");

            CurrentManager.ProtectedAddListener(source, listener); 
        }

 public Capture(ListView ListView)
 {
     this.ListView = ListView;
     this.incc = ListView.ItemsSource as INotifyCollectionChanged;
     if (this.incc != null)
     {
         this.incc.CollectionChanged += this.incc_CollectionChanged;
     }
 }

        private static NotifyCollectionChangedEventHandler SetupCollectionChangedEventHandler(DependencyObject dependencyObject,
                                                                                          INotifyCollectionChanged observableCollection)
        {
            NotifyCollectionChangedEventHandler sourceChangedHandler =
                (s, ev) => SelectedItemsCollectionChanged(dependencyObject, ev);
            observableCollection.CollectionChanged += sourceChangedHandler;

            return sourceChangedHandler;
        }

        /// <summary>
        /// Hookups the handler to the collection changed event. When the value changes it removes the handler.
        /// </summary>
        /// <param name="oldValue">The old collection.</param>
        /// <param name="newValue">The new collection.</param>
        /// <param name="handler">The handler to hookup.</param>
        public static void HookupToCollectionChanged(INotifyCollectionChanged oldValue, INotifyCollectionChanged newValue,
            NotifyCollectionChangedEventHandler handler)
        {
            if (oldValue != null)
                oldValue.CollectionChanged -= handler;

            if (newValue != null)
                newValue.CollectionChanged += handler;
        }