C# NotifyCollectionChangedEventHandler类代码示例

 /// <summary>
 /// Låter andra klasser lyssna på förändringar i repositoryt så att de kan uppdateras.
 /// </summary>
 /// <param name="handler"></param>
 /// <returns>Referns till en instans av FDRFeedRepository med eventhanterare</returns>
 public static IRepository<Feed> getFeeds(NotifyCollectionChangedEventHandler handler)
 {
     if (feeds == null)
         feeds = new FDRFeedRepository();
     feeds.CollectionChanged += handler;
     return feeds;
 }

    public GeneratorNodeFactory( NotifyCollectionChangedEventHandler itemsChangedHandler,
                                 NotifyCollectionChangedEventHandler groupsChangedHandler,
                                 EventHandler<ExpansionStateChangedEventArgs> expansionStateChangedHandler,
                                 EventHandler isExpandedChangingHandler,
                                 EventHandler isExpandedChangedHandler,
                                 DataGridControl dataGridControl )
    {
      if( itemsChangedHandler == null )
        throw new ArgumentNullException( "itemsChangedHandler" );

      if( groupsChangedHandler == null )
        throw new ArgumentNullException( "groupsChangedHandler" );

      if( expansionStateChangedHandler == null )
        throw new ArgumentNullException( "expansionStateChangedHandler" );

      if( isExpandedChangingHandler == null )
        throw new ArgumentNullException( "isExpandedChangingHandler" );

      if( isExpandedChangedHandler == null )
        throw new ArgumentNullException( "isExpandedChangedHandler" );

      m_itemsChangedHandler = itemsChangedHandler;
      m_groupsChangedHandler = groupsChangedHandler;
      m_expansionStateChangedHandler = expansionStateChangedHandler;
      m_isExpandedChangingHandler = isExpandedChangingHandler;
      m_isExpandedChangedHandler = isExpandedChangedHandler;

      if( dataGridControl != null )
      {
        m_dataGridControl = new WeakReference( dataGridControl );
      }
    }

 public void AddHandler(NotifyCollectionChangedEventHandler handler)
 {
     if(handler != null)
     {
         _books.CollectionChanged += handler;
     }
 }

 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;
 }

        public static void OnAutoScrollToEndChanged(DependencyObject s, DependencyPropertyChangedEventArgs e)
        {
            var ctrl = s as ItemsControl;
            if (ctrl == null)
                throw new InvalidOperationException("This attached property only supports ItemsControl or derived types.");

            var data = ctrl.Items as INotifyCollectionChanged;
            if (data == null)
                throw new InvalidOperationException("Collection does not support change notifications.");

            Control parentCtrl = ctrl;
            while (parentCtrl != null && parentCtrl.GetType() != typeof(ScrollViewer))
                parentCtrl = parentCtrl.Parent as Control;
            ScrollViewer sv = parentCtrl as ScrollViewer;

            var scrollToEndHandler = new NotifyCollectionChangedEventHandler(
                (s1, e1) =>
                {
                    if (e1.Action == NotifyCollectionChangedAction.Add && sv != null)
                        sv.ScrollToBottom();
                });

            if ((bool)e.NewValue)
                data.CollectionChanged += scrollToEndHandler;
            else
                data.CollectionChanged -= scrollToEndHandler;
        }

        public static void OnAutoScrollChanged(DependencyObject s, DependencyPropertyChangedEventArgs e)
        {
            var val = (bool)e.NewValue;
            var lb = s as ListView;
            if (lb == null)
                throw new InvalidOperationException("This behavior can only be attached to a ListView.");

            var ic = lb.Items;
            var data = ic.SourceCollection as INotifyCollectionChanged;
            if (data == null) return;

            var autoscroller = new NotifyCollectionChangedEventHandler(
                (s1, e1) =>
                {
                    var selectedItem = default(object);
                    switch (e1.Action)
                    {
                        case NotifyCollectionChangedAction.Add:
                        case NotifyCollectionChangedAction.Move: selectedItem = e1.NewItems[e1.NewItems.Count - 1]; break;
                        case NotifyCollectionChangedAction.Remove: if (ic.Count < e1.OldStartingIndex) { selectedItem = ic[e1.OldStartingIndex - 1]; } else if (ic.Count > 0) selectedItem = ic[0]; break;
                        case NotifyCollectionChangedAction.Reset: if (ic.Count > 0) selectedItem = ic[0]; break;
                    }

                    if (selectedItem == default(object)) return;
                    ic.MoveCurrentTo(selectedItem);
                    lb.ScrollIntoView(selectedItem);
                });

            if (val) data.CollectionChanged += autoscroller;
            else data.CollectionChanged -= autoscroller;
        }

        public static void OnAutoScrollToEndChanged(DependencyObject s, DependencyPropertyChangedEventArgs e)
        {
            var listBox = s as ListBox;
            if(listBox==null)
                return;
            var listBoxItems = listBox.Items;
            var data = listBoxItems.SourceCollection as INotifyCollectionChanged;
            if (data == null)
                return;

            var scrollToEndHandler = new NotifyCollectionChangedEventHandler(
                (s1, e1) =>
                {
                    if (listBox.Items.Count <= 0) 
                        return;
                    var lastItem = listBox.Items[listBox.Items.Count - 1];
                    listBoxItems.MoveCurrentTo(lastItem);
                    listBox.ScrollIntoView(lastItem);
                });

            if ((bool)e.NewValue)
                data.CollectionChanged += scrollToEndHandler;
            else
                data.CollectionChanged -= scrollToEndHandler;
        }

 /// <summary>
 /// Låter andra klasser lyssna på förändringar i repositoryt så att de kan uppdateras.
 /// </summary>
 /// <param name="handler"></param>
 /// <returns>Referns till en instans av FDRCategoryRepository med eventhanterare</returns>
 public static IRepository<Category> getCategories(NotifyCollectionChangedEventHandler handler)
 {
     if (categories == null)
         categories = new FDRCategoryRepository();
     categories.CollectionChanged += handler;
     return categories;
 }

        /// <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;
        }

        /// <summary>
        /// Adds a weak event listener for a CollectionChanged event.
        /// </summary>
        /// <param name="source">The source of the event.</param>
        /// <param name="handler">The event handler.</param>
        /// <exception cref="ArgumentNullException">source must not be <c>null</c>.</exception>
        /// <exception cref="ArgumentNullException">handler must not be <c>null</c>.</exception>
        protected void AddWeakEventListener(INotifyCollectionChanged source, NotifyCollectionChangedEventHandler handler)
        {
            if (source == null) { throw new ArgumentNullException("source"); }
            if (handler == null) { throw new ArgumentNullException("handler"); }

            CollectionChangedEventListener listener = new CollectionChangedEventListener(source, handler);

            collectionChangedListeners.Add(listener);

            CollectionChangedEventManager.AddListener(source, listener);
        }

		private static void Subscribe(DataGrid dataGrid)
		{
			var handler = new NotifyCollectionChangedEventHandler((sender, eventArgs) => ScrollToEnd(dataGrid));
			if (handlersDict.ContainsKey(dataGrid))
			{
				return;
			}
            handlersDict.Add(dataGrid, handler);
			((INotifyCollectionChanged)dataGrid.Items).CollectionChanged += handler;
			ScrollToEnd(dataGrid);
		}

 private static void SetupOnUnloadedHandler(DependencyObject dependencyObject, INotifyCollectionChanged observableCollection,
                                            NotifyCollectionChangedEventHandler sourceChangedHandler)
 {
     RoutedEventHandler unloadedEventHandler = null;
     unloadedEventHandler = (sender, args) =>
                                {
                                    observableCollection.CollectionChanged -= sourceChangedHandler;
                                    ((ListViewBase)sender).SelectionChanged -= OnGridSelectionChanged;
                                    ((ListViewBase)sender).Unloaded -= unloadedEventHandler;
                                };
     ((ListViewBase)dependencyObject).Unloaded += unloadedEventHandler;
 }

        protected void RemoveEventListener(INotifyCollectionChanged source, NotifyCollectionChangedEventHandler handler)
        {
            if (source == null) { throw new ArgumentException("source"); }
            if (handler == null) { throw new ArgumentException("handler"); }

            CollectionChangedEventListener listener = collectionEventListeners.LastOrDefault(c => c.Source == source && c.Handler == handler);

            if (listener != null)
            {
                collectionEventListeners.Remove(listener);
                CollectionChangedEventManager.RemoveListener(source, listener);
            }
        }

        public DataMappingViewModel(IWebActivity activity, NotifyCollectionChangedEventHandler mappingCollectionChangedEventHandler = null)
        {
            _activity = activity;
            _actionManager = new ActionManager();
            Inputs = new ObservableCollection<IInputOutputViewModel>();
            Outputs = new ObservableCollection<IInputOutputViewModel>();

            if(mappingCollectionChangedEventHandler != null)
            {
                Inputs.CollectionChanged += mappingCollectionChangedEventHandler;
                Outputs.CollectionChanged += mappingCollectionChangedEventHandler;
            }
            Initialize(_activity);
        }

 public ItemsSourceCollectionViewSource([NotNull] UICollectionView collectionView,
     string itemTemplate = AttachedMemberConstants.ItemTemplate)
     : base(collectionView, itemTemplate)
 {
     _weakHandler = ReflectionExtensions.MakeWeakCollectionChangedHandler(this,
         (adapter, o, arg3) => adapter.OnCollectionChanged(o, arg3));
 }