Catel.Data.ChangeNotificationWrapper.SubscribeNotifyChangedEvent C# (CSharp) Method

        private void SubscribeNotifyChangedEvent(object value, EventChangeType eventChangeType, ICollection parentCollection)
        {
            if (value == null)
            {
                return;
            }

            lock (_lockObject)
            {
                ConditionalWeakTable<object, IWeakEventListener> eventsTable;
                List<IWeakEventListener> eventsList;

                switch (eventChangeType)
                {
                    case EventChangeType.Property:
                        if (_weakPropertyChangedListenersTable == null)
                        {
                            _weakPropertyChangedListenersTable = new ConditionalWeakTable<object, IWeakEventListener>();
                        }

                        if (_weakPropertyChangedListeners == null)
                        {
                            _weakPropertyChangedListeners = new List<IWeakEventListener>();
                        }

                        eventsTable = _weakPropertyChangedListenersTable;
                        eventsList = _weakPropertyChangedListeners;
                        break;

                    case EventChangeType.Collection:
                        if (_weakCollectionChangedListenersTable == null)
                        {
                            _weakCollectionChangedListenersTable = new ConditionalWeakTable<object, IWeakEventListener>();
                        }

                        if (_weakCollectionChangedListeners == null)
                        {
                            _weakCollectionChangedListeners = new List<IWeakEventListener>();
                        }

                        if (_collectionItems == null)
                        {
                            _collectionItems = new ConditionalWeakTable<object, List<WeakReference>>();
                        }

                        eventsTable = _weakCollectionChangedListenersTable;
                        eventsList = _weakCollectionChangedListeners;
                        break;

                    default:
                        throw new ArgumentOutOfRangeException("eventChangeType");
                }

                IWeakEventListener oldSubscription;
                if (eventsTable != null && eventsTable.TryGetValue(value, out oldSubscription))
                {
                    oldSubscription.Detach();

                    eventsList.Remove(oldSubscription);
                    eventsTable.Remove(value);
                }

                IWeakEventListener weakListener;
                switch (eventChangeType)
                {
                    case EventChangeType.Property:
                        if (parentCollection != null)
                        {
                            weakListener = this.SubscribeToWeakPropertyChangedEvent(value, OnObjectCollectionItemPropertyChanged, false);
                            if (weakListener == null)
                            {
                                Log.Debug("Failed to use weak events to subscribe to 'value.PropertyChanged', going to subscribe without weak events");

                                ((INotifyPropertyChanged) value).PropertyChanged += OnObjectCollectionItemPropertyChanged;
                            }

                            var collectionItems = _collectionItems.GetOrCreateValue(parentCollection);
                            collectionItems.Add(weakListener != null ? weakListener.SourceWeakReference : new WeakReference(value));
                        }
                        else
                        {
                            weakListener = this.SubscribeToWeakPropertyChangedEvent(value, OnObjectPropertyChanged, false);
                            if (weakListener == null)
                            {
                                Log.Debug("Failed to use weak events to subscribe to 'value.PropertyChanged', going to subscribe without weak events");

                                ((INotifyPropertyChanged)value).PropertyChanged += OnObjectPropertyChanged;
                            }
                        }
                        break;

                    case EventChangeType.Collection:
                        weakListener = this.SubscribeToWeakCollectionChangedEvent(value, OnObjectCollectionChanged, false);
                        if (weakListener == null)
                        {
                            Log.Debug("Failed to use weak events to subscribe to 'value.CollectionChanged', going to subscribe without weak events");

                            ((INotifyCollectionChanged)value).CollectionChanged += OnObjectCollectionChanged;
                        }
                        break;

                    default:
                        throw new ArgumentOutOfRangeException("eventChangeType");
                }

                if (eventsTable != null)
                {
                    eventsTable.Add(value, weakListener);
                }

                if (eventsList != null)
                {
                    eventsList.Add(weakListener);
                }
            }
        }