public void AfterListenerIsNull_EventDetaching()
        {
            WasDetached = false;
            EventCounter = 0;

            var list = new ObservableCollection<int>();

            WeakEventListener<object, ObservableCollection<int>, EventArgs> weakEventListener = null;

            var obj = new object();

            weakEventListener = new WeakEventListener<object, ObservableCollection<int>, EventArgs>(obj, list);

            list.CollectionChanged += weakEventListener.OnEvent;
            weakEventListener.OnEventAction += (o, o1, arg3) =>
                {
                    EventCounter++;
                };
            weakEventListener.OnDetachAction += (listener, source) =>
                {
                    source.CollectionChanged -= listener.OnEvent;
                    WasDetached = true;
                };

            list.Add(1);
            obj = null;
            GC.Collect();

            list.Add(2);
            GC.Collect();

            Assert.IsTrue(WasDetached);
            Assert.AreEqual(EventCounter, 1);
        }

        public SpreadsheetCellDataFieldViewModel(Type viewModelType, PropertyInfo propertyInfo, IEditableProxy model, DetailsViewModel parentViewModel, IColumnItem column)
        {            
            _propertyInfo = propertyInfo;            
            _parentModel = model;
            if (_parentModel != null)
            {                
                var parentModelBO = _parentModel as BusinessBase;
                if (parentModelBO != null)
                {
                    var weakListener = new WeakEventListener<SpreadsheetCellDataFieldViewModel, BusinessBase, PropertyChangedEventArgs>(this, parentModelBO);

                    parentModelBO.PropertyChanged += weakListener.OnEvent;
                    weakListener.OnEventAction += OnParentModelPropertyChanged;
                    weakListener.OnDetachAction += Static;
                }

                _allProperties = _parentModel.GetAllPropertiesForInstance();
                var root = _parentModel.GetModel();
                if (root != null)
                    _allMasterProperties = root.GetAllPropertiesForInstance();                
            }

            _parentDetailsVM = parentViewModel;
            _fieldViewModelType = viewModelType;
            _column = column;
        }

        public virtual void Initialize(ChecklistSingleViewModel parentVM, IFieldDefinitionEntity fieldDef, IEventAggregator eventAggregator)
        {
            _eventAggregator = eventAggregator;

            _process = (TemplateEntity)parentVM.QuestionsTemplate;
            _parentVM = parentVM;
            _fieldDefinition = fieldDef;
            ChangeChartTypeCommand = new DelegateCommand(ExecuteChange);

            PrepareFieldDefRelatedData();

            var weakListener = new WeakEventListener<SPCChartControlViewModel, ChecklistViewModelBase, EventArgs>(this, parentVM);
            parentVM.SelectesQuestionChanged += weakListener.OnEvent;
            weakListener.OnEventAction = OnSelectedQuestionChanged;
            weakListener.OnDetachAction = (listener, source) =>
            {
                source.SelectesQuestionChanged -= listener.OnEvent;
            };

            ShowLCLAnyChart = true; ShowUCLAnyChart = true; ShowMeanAnyChart = true;
            ShowLCLRangeChart = true; ShowUCLRangeChart = true; ShowMeanRangeChart = true;
            ShowUSL = false; ShowLSL = false;

            OnSelectedQuestionChanged(this, parentVM, EventArgs.Empty);            
        }

		private static void AttachObservableModelCallback(DependencyObject source, DependencyPropertyChangedEventArgs args)
		{
			var typeName = args.NewValue as string;
			var view = source as FrameworkElement;
			if (typeName == null || view == null)
				return;

			var modelType = Type.GetType("Raven.Studio.Models." + typeName) ?? Type.GetType(typeName);
			if (modelType == null)
				return;

			try
			{
				var model = (Model)Activator.CreateInstance(modelType);
				model.ForceTimerTicked();

				var observable = (IObservable)Activator.CreateInstance(typeof(Observable<>).MakeGenericType(modelType));
				observable.Value = model;
				view.DataContext = observable;

				SetPageTitle(model, view);
				
				var weakListener = new WeakEventListener<IObservable, object, RoutedEventArgs>(observable);
				view.Loaded += weakListener.OnEvent;
				weakListener.OnEventAction = OnViewLoaded;
				weakListener.OnDetachAction = listener => view.Loaded -= listener.OnEvent;
			}
			catch (Exception ex)
			{
				throw new InvalidOperationException(string.Format("Cannot create instance of model type: {0}", modelType), ex);
			}
		}

        private void Handler()
        {
            var propertyChangedListener = new WeakEventListener<PopUpSearchView, ListBox, SelectionChangedEventArgs>(this, ListBoxItems);

            ListBoxItems.SelectionChanged += propertyChangedListener.OnEvent;
            propertyChangedListener.OnEventAction += ValuePropertyChanged;
            propertyChangedListener.OnDetachAction += Static;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="SelectCrossRefViewModel"/> class.
        /// </summary>
        public SelectCrossRefViewModel()
        {
            CloseOnReturn = false;

            var weakListener = new WeakEventListener<SelectCrossRefViewModel, ObservableCollection<object>, NotifyCollectionChangedEventArgs>(this, _selectedItems);
            _selectedItems.CollectionChanged += weakListener.OnEvent;
            weakListener.OnEventAction += SelectedItemsOnCollectionChanged;
            weakListener.OnDetachAction += Static;
        }

        public SearchListView()
        {
            InitializeComponent();

            var dataContextChangedListener = 
                new WeakEventListener<SearchListView, SearchListView, DependencyPropertyChangedEventArgs>(this, this);
            DataContextChanged += dataContextChangedListener.OnEvent;
            dataContextChangedListener.OnEventAction = OnDataContextChanged;
            dataContextChangedListener.OnDetachAction = OnDetachDataContextChanged;
        }

 public WeakCollectionChangedWrapper( IList sourceList )
 {
     _innerList = sourceList;
       var notifyList = _innerList as INotifyCollectionChanged;
       if( notifyList != null )
       {
     _innerListListener = new WeakEventListener<NotifyCollectionChangedEventArgs>( OnInnerCollectionChanged );
     CollectionChangedEventManager.AddListener( notifyList, _innerListListener );
       }
 }

		/// <summary>
		/// Initializes a new instance of the <see cref="NetworkConnectionStateTrigger"/> class.
		/// </summary>
		public NetworkConnectionStateTrigger()
		{
			var weakEvent =
				new WeakEventListener<NetworkConnectionStateTrigger, object>(this)
				{
					OnEventAction = (instance, source) => NetworkInformation_NetworkStatusChanged(source),
					OnDetachAction = (instance, weakEventListener) => NetworkInformation.NetworkStatusChanged -= weakEventListener.OnEvent
				};
			NetworkInformation.NetworkStatusChanged += weakEvent.OnEvent;
			UpdateState();
		}

        public ResolveDatabaseObjectsViewModel()
        {
            DatabaseObjectList = new ObservableCollection<DatabaseObject>();

            var weakEventListener = new WeakEventListener<object, ObservableCollection<DatabaseObject>, EventArgs>(this, DatabaseObjectList);

            DatabaseObjectList.CollectionChanged += weakEventListener.OnEvent;
            weakEventListener.OnEventAction += RaiseChanges;

            weakEventListener.OnDetachAction += Static;
        }

        public DiagramView()
        {
            InitializeComponent();
            KeyDown += DiagramPanel_KeyDown;

            var weakListener = new WeakEventListener<DiagramView, DiagramView, RoutedEventArgs>(this, this);

            this.Loaded += weakListener.OnEvent;
            weakListener.OnEventAction += OnDiagramViewLoaded;
            weakListener.OnDetachAction += Static;
        }

        public void HandleWeakEvent()
        {
            Dummy dummy = new Dummy();
            bool weakEventReceived = false;
            var listener = new WeakEventListener<PropertyChangedEventArgs>((sender, eventArgs) => weakEventReceived = true);

            PropertyChangedEventManager.AddListener(dummy, listener, String.Empty);
            dummy.RaisePropertyChanged();
            Assert.IsTrue(weakEventReceived);
            weakEventReceived = false;
        }

        /// <summary>
        /// Adds the event handlers.
        /// </summary>
        private void AddEventHandlers()
        {
            var propertyChangedListener = new WeakEventListener<BusinessObjectIsValidListener, BusinessBase, PropertyChangedEventArgs>(this, Model);
            Model.PropertyChanged += propertyChangedListener.OnEvent;
            propertyChangedListener.OnEventAction = OnModelPropertyChanged;
            propertyChangedListener.OnDetachAction = Static;

            var childChangedListener = new WeakEventListener<BusinessObjectIsValidListener, BusinessBase, ChildChangedEventArgs>(this, Model);
            Model.ChildChanged += childChangedListener.OnEvent;
            childChangedListener.OnEventAction = OnModelChildChanged;
            childChangedListener.OnDetachAction = Static;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ServiceTypeInfo"/> class.
        /// </summary>
        /// <param name="type">The type.</param>
        public ServiceTypeInfo(ServiceExposedTypeEdit type)
        {
            _nameExpression = () => type.Name;
            _guidExpression = () => type.Guid;

            var propertyChangedListener =
                new WeakEventListener<ServiceTypeInfo, ServiceExposedTypeEdit, PropertyChangedEventArgs>(this, type);

            type.PropertyChanged += propertyChangedListener.OnEvent;
            propertyChangedListener.OnEventAction += OnTypePropertyChanged;
            propertyChangedListener.OnDetachAction += Static;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="TableDefinition" /> class.
        /// </summary>
        public TableDefinition()
        {
            FieldList = new List<TableFieldDefinition>();

            var relationships = new ObservableCollection<TableRelationshipDefinition>();
            Relationships = relationships;

            var weakListenerKeyDown = new WeakEventListener<TableDefinition, ObservableCollection<TableRelationshipDefinition>, NotifyCollectionChangedEventArgs>(this, relationships);
            relationships.CollectionChanged += weakListenerKeyDown.OnEvent;
            weakListenerKeyDown.OnEventAction += RelationshipsCollectionChanged;
            weakListenerKeyDown.OnDetachAction += Static;
        }

        public void ShouldStoreEventHandler()
        {
            bool weakEventReceived = false;

            var listener = new WeakEventListener<PropertyChangedEventArgs>((sender, eventArgs) => weakEventReceived = true);

            // Check whether EventHandler was stored correctly.
            Assert.IsNotNull(listener.EventHandler);
            listener.EventHandler(null, null);
            Assert.IsTrue(weakEventReceived);
            weakEventReceived = false;
        }

        private static void OnDataContextChanged(SearchListView view, object sender, DependencyPropertyChangedEventArgs args)
        {
            var dc = args.NewValue as SearchListViewModel;
            if (dc == null)
                return;

            var selectedChangedListener = 
                new WeakEventListener<SearchListView, SearchListViewModel, SelectedChangedEventArgs>(view, dc);
            dc.SelectedChanged += selectedChangedListener.OnEvent;
            selectedChangedListener.OnEventAction = OnSelectedChanged;
            selectedChangedListener.OnDetachAction = OnDetachSelectedChanged;
        }

		private static void OnValuePropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
		{
			var obj = (IsNullOrEmptyStateTrigger)d;
			var val = e.NewValue;

			obj.IsActive = IsNullOrEmpty(val);

			if (val == null)
				return;

			// Try to listen for various notification events
			// Starting with INorifyCollectionChanged
			var valNotifyCollection = val as INotifyCollectionChanged;
			if (valNotifyCollection != null)
			{
				var weakEvent = new WeakEventListener<INotifyCollectionChanged, object, NotifyCollectionChangedEventArgs>(valNotifyCollection)
				{
					OnEventAction = (instance, source, args) => obj.IsActive = IsNullOrEmpty(instance),
					OnDetachAction = (instance, weakEventListener) => instance.CollectionChanged -= weakEventListener.OnEvent
				};

				valNotifyCollection.CollectionChanged += weakEvent.OnEvent;
				return;
			}

			// Not INotifyCollectionChanged, try IObservableVector
			var valObservableVector = val as IObservableVector<object>;
			if (valObservableVector != null)
			{
				var weakEvent = new WeakEventListener<IObservableVector<object>, object, IVectorChangedEventArgs>(valObservableVector)
				{
					OnEventAction = (instance, source, args) => obj.IsActive = IsNullOrEmpty(instance),
					OnDetachAction = (instance, weakEventListener) => instance.VectorChanged -= weakEventListener.OnEvent
				};

				valObservableVector.VectorChanged += weakEvent.OnEvent;
				return;
			}

			// Not INotifyCollectionChanged, try IObservableMap
			var valObservableMap = val as IObservableMap<object,object>;
			if (valObservableMap != null)
			{
				var weakEvent = new WeakEventListener<IObservableMap<object, object>, object, IMapChangedEventArgs<object>>(valObservableMap)
				{
					OnEventAction = (instance, source, args) => obj.IsActive = IsNullOrEmpty(instance),
					OnDetachAction = (instance, weakEventListener) => instance.MapChanged -= weakEventListener.OnEvent
				};

				valObservableMap.MapChanged += weakEvent.OnEvent;
			}
		}

		/// <summary>
		/// Initializes a new instance of the <see cref="OrientationStateTrigger"/> class.
		/// </summary>
		public OrientationStateTrigger()
		{
			if (!Windows.ApplicationModel.DesignMode.DesignModeEnabled)
			{
				var weakEvent =
					new WeakEventListener<OrientationStateTrigger, DisplayInformation, object>(this)
					{
						OnEventAction = (instance, source, eventArgs) => OrientationStateTrigger_OrientationChanged(source, eventArgs),
						OnDetachAction = (instance, weakEventListener) => DisplayInformation.GetForCurrentView().OrientationChanged -= weakEventListener.OnEvent
					};
				DisplayInformation.GetForCurrentView().OrientationChanged += weakEvent.OnEvent;
			}
		}

        public MasterDetailStateTrigger()
        {
            if (!Windows.ApplicationModel.DesignMode.DesignModeEnabled)
            {
                var weakEvent = new WeakEventListener<MasterDetailStateTrigger, ApplicationView, object>(this)
                {
                    OnEventAction = (instance, source, eventArgs) => MasterDetailStatetateTrigger_MasterDetailStateChanged(source, eventArgs),
                    OnDetachAction = (instance, weakEventListener) => ApplicationView.GetForCurrentView().VisibleBoundsChanged -= weakEventListener.OnEvent
                };

                ApplicationView.GetForCurrentView().VisibleBoundsChanged += weakEvent.OnEvent;
            }
        }