|
//---------------------------------------------------------------------------
//
// <copyright file="CanExecuteChangedEventManager.cs" company="Microsoft">
// Copyright (C) Microsoft Corporation. All rights reserved.
// </copyright>
//
// Description: Manager for the CanExecuteChanged event in the "weak event listener"
// pattern. See WeakEventTable.cs for an overview.
//
//---------------------------------------------------------------------------
using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.CompilerServices; // ConditionalWeakTable
using System.Windows; // WeakEventManager
using MS.Internal; // NamedObject
namespace System.Windows.Input
{
/// <summary>
/// Manager for the ICommand.CanExecuteChanged event.
/// </summary>
public class CanExecuteChangedEventManager : WeakEventManager
{
#region Constructors
//
// Constructors
//
private CanExecuteChangedEventManager()
{
}
#endregion Constructors
#region Public Methods
//
// Public Methods
//
/// <summary>
/// Add a handler for the given source's event.
/// </summary>
public static void AddHandler(ICommand source, EventHandler<EventArgs> handler)
{
if (source == null)
throw new ArgumentNullException("source");
if (handler == null)
throw new ArgumentNullException("handler");
CurrentManager.PrivateAddHandler(source, handler);
}
/// <summary>
/// Remove a handler for the given source's event.
/// </summary>
public static void RemoveHandler(ICommand source, EventHandler<EventArgs> handler)
{
if (source == null)
throw new ArgumentNullException("source");
if (handler == null)
throw new ArgumentNullException("handler");
CurrentManager.PrivateRemoveHandler(source, handler);
}
#endregion Public Methods
#region Protected Methods
//
// Protected Methods
//
/// <summary>
/// Listen to the given source for the event.
/// </summary>
protected override void StartListening(object source)
{
// never called
}
/// <summary>
/// Stop listening to the given source for the event.
/// </summary>
protected override void StopListening(object source)
{
// never called
}
protected override bool Purge(object source, object data, bool purgeAll)
{
// Incremental cleanups (!purgeAll) are guaranteed to be on the right thread,
// but the final cleanup (purgeAll) can happen on a different thread.
bool isOnOriginalThread = !purgeAll || CheckAccess();
ICommand command = source as ICommand;
List<HandlerSink> list = data as List<HandlerSink>;
List<HandlerSink> toRemove = null;
bool foundDirt = false;
bool removeList = purgeAll || source == null;
// find dead entries to be removed from the list
if (!removeList)
{
foreach (HandlerSink sink in list)
{
if (sink.IsInactive)
{
if (toRemove == null)
{
toRemove = new List<HandlerSink>();
}
toRemove.Add(sink);
}
}
removeList = (toRemove != null && toRemove.Count == list.Count);
}
if (removeList)
{
toRemove = list;
}
foundDirt = (toRemove != null);
// if the whole list is going away, remove the data (unless parent table
// is already doing that for us - purgeAll=true)
if (removeList && !purgeAll && source != null)
{
Remove(source);
}
// remove and detach the dead entries
if (foundDirt)
{
foreach (HandlerSink sink in toRemove)
{
EventHandler<EventArgs> handler = sink.Handler;
sink.Detach(isOnOriginalThread);
if (!removeList) // if list is going away, no need to remove from it
{
list.Remove(sink);
}
if (handler != null)
{
RemoveHandlerFromCWT(handler, _cwt);
}
}
}
return foundDirt;
}
#endregion Protected Methods
#region Private Properties
//
// Private Properties
//
// get the event manager for the current thread
private static CanExecuteChangedEventManager CurrentManager
{
get
{
Type managerType = typeof(CanExecuteChangedEventManager);
CanExecuteChangedEventManager manager = (CanExecuteChangedEventManager)GetCurrentManager(managerType);
// at first use, create and register a new manager
if (manager == null)
{
manager = new CanExecuteChangedEventManager();
SetCurrentManager(managerType, manager);
}
return manager;
}
}
#endregion Private Properties
#region Private Methods
//
// Private Methods
//
private void PrivateAddHandler(ICommand source, EventHandler<EventArgs> handler)
{
// get the list of sinks for this source, creating if necessary
List<HandlerSink> list = (List<HandlerSink>)this[source];
if (list == null)
{
list = new List<HandlerSink>();
this[source] = list;
}
// add a new sink to the list
HandlerSink sink = new HandlerSink(this, source, handler);
list.Add(sink);
// keep the handler alive
AddHandlerToCWT(handler, _cwt);
}
private void PrivateRemoveHandler(ICommand source, EventHandler<EventArgs> handler)
{
// get the list of sinks for this source
List<HandlerSink> list = (List<HandlerSink>)this[source];
if (list != null)
{
HandlerSink sinkToRemove = null;
bool foundDirt = false;
// look for the given sink on the list
foreach (HandlerSink sink in list)
{
if (sink.Matches(source, handler))
{
sinkToRemove = sink;
break;
}
else if (sink.IsInactive)
{
foundDirt = true;
}
}
// remove the sink (outside the loop, to avoid re-entrancy issues)
if (sinkToRemove != null)
{
list.Remove(sinkToRemove);
sinkToRemove.Detach(isOnOriginalThread:true);
RemoveHandlerFromCWT(handler, _cwt);
}
// if we noticed any stale sinks, schedule a purge
if (foundDirt)
{
ScheduleCleanup();
}
}
}
// add the handler to the CWT - this keeps the handler alive throughout
// the lifetime of the target, without prolonging the lifetime of
// the target
void AddHandlerToCWT(Delegate handler, ConditionalWeakTable<object, object> cwt)
{
object value;
object target = handler.Target;
if (target == null)
target = StaticSource;
if (!cwt.TryGetValue(target, out value))
{
// 99% case - the target only listens once
cwt.Add(target, handler);
}
else
{
// 1% case - the target listens multiple times
// we store the delegates in a list
List<Delegate> list = value as List<Delegate>;
if (list == null)
{
// lazily allocate the list, and add the old handler
Delegate oldHandler = value as Delegate;
list = new List<Delegate>();
list.Add(oldHandler);
// install the list as the CWT value
cwt.Remove(target);
cwt.Add(target, list);
}
// add the new handler to the list
list.Add(handler);
}
}
void RemoveHandlerFromCWT(Delegate handler, ConditionalWeakTable<object, object> cwt)
{
object value;
object target = handler.Target;
if (target == null)
target = StaticSource;
if (_cwt.TryGetValue(target, out value))
{
List<Delegate> list = value as List<Delegate>;
if (list == null)
{
// 99% case - the target is removing its single handler
_cwt.Remove(target);
}
else
{
// 1% case - the target had multiple handlers, and is removing one
list.Remove(handler);
if (list.Count == 0)
{
_cwt.Remove(target);
}
}
}
}
#endregion Private Methods
#region Private Data
ConditionalWeakTable<object, object> _cwt = new ConditionalWeakTable<object, object>();
static readonly object StaticSource = new NamedObject("StaticSource");
#endregion Private Data
#region HandlerSink
// Some sources delegate their CanExecuteChanged event to another event
// on a different object. For example, RoutedCommands delegate to
// CommandManager.RequerySuggested, as do some custom commands (dev11 281808).
// Similarly, some 3rd-party commands delegate to a custom class (dev11 449384).
// The standard weak-event pattern won't work in these cases. It registers
// the source at AddHandler-time, and uses the 'sender' argument at event-delivery
// time to look up the relevant information; if these are different, we won't find
// the information and therefore won't deliver the event to the intended listeners.
//
// To cope with this, we use the HandlerSink class. Each call to AddHandler
// creates a new HandlerSink, in which we record the original source and
// handler, and register a local listener. When the event is raised to a
// sink's local listener, the sink merely passes the event along to the original
// handler. With judicious use of WeakReference and ConditionalWeakTable,
// we can do this without extending the lifetime of the original source or
// listener, and without leaking any of the internal data structures.
// Here's a diagram illustrating a Button listening to CanExecuteChanged from
// a Command that delegates to some other event Proxy.Foo.
//
// Button --*--> OriginalHandler <---o--- Sink --------o------------> Command
// ^ | ^ ^
// --------------------- | |
// List ------- ----> LocalHandler <---- Proxy.Foo
// Table: (Command) ---^
//
// Legend: Weak reference: --o-->
// CWT reference: --*-->
// Strong reference: ----->
//
// For each source (i.e. Command), the Manager stores a list of Sinks pertaining
// to that Command. Each Sink remembers (weakly) its original source and handler,
// and registers for the Command.CanExecuteChanged event in the normal way.
// The event may be raised from a different place (Proxy.Foo), but the Sink
// knows to pass the event along to the original handler. The Manager uses a
// ConditionalWeakTable to keep the original handlers alive, and the Sink
// keeps its local handler alive with a local strong reference.
// The internal data structures (Sink, List entry, LocalHandler) can be purged
// when either the Button or the Command is GC'd. Both conditions are
// testable by querying the Sink's weak references.
private class HandlerSink
{
public HandlerSink(CanExecuteChangedEventManager manager, ICommand source, EventHandler<EventArgs> originalHandler)
{
_manager = manager;
_source = new WeakReference(source);
_originalHandler = new WeakReference(originalHandler);
// In WPF 4.0, elements with commands (Button, Hyperlink, etc.) listened
// for CanExecuteChanged and also stored a strong reference to the handler
// (in an uncommon field). Some third-party commands relied on this
// undocumented implementation detail by storing a weak reference to
// the handler. (One such example is Win8 Server Manager's DelegateCommand -
// Microsoft.Management.UI.DelegateCommand<T> - see Win8 Bugs 588129.)
//
// Commands that do this won't work with normal listeners: the listener
// simply calls command.CanExecuteChanged += new EventHandler(MyMethod);
// the command stores a weak-ref to the handler, no one has a strong-ref
// so the handler is soon GC'd, after which the event doesn't get
// delivered to the listener.
//
// In WPF 4.5, Button et al. use this weak event manager to listen to
// CanExecuteChanged, indirectly. Only the manager actually listens
// directly to the command's event. For compat, the manager stores a
// strong reference to its handler. The only reason for this is to
// support those commands that relied on the 4.0 implementation.
_onCanExecuteChangedHandler = new EventHandler(OnCanExecuteChanged);
// BTW, the reason commands used weak-references was to avoid leaking
// the Button - see Dev11 267916. This is fixed in 4.5, precisely
// by using the weak-event pattern. Commands can now implement
// the CanExecuteChanged event the default way - no need for any
// fancy weak-reference tricks (which people usually get wrong in
// general, as in the case of DelegateCommand<T>).
// register the local listener
source.CanExecuteChanged += _onCanExecuteChangedHandler;
}
public bool IsInactive
{
get
{
return _source == null || !_source.IsAlive
|| _originalHandler == null || !_originalHandler.IsAlive;
}
}
public EventHandler<EventArgs> Handler
{
get { return (_originalHandler != null) ? (EventHandler<EventArgs>)_originalHandler.Target : null; }
}
public bool Matches(ICommand source, EventHandler<EventArgs> handler)
{
return (_source != null && (ICommand)_source.Target == source) &&
(_originalHandler != null && (EventHandler<EventArgs>)_originalHandler.Target == handler);
}
public void Detach(bool isOnOriginalThread)
{
if (_source != null)
{
ICommand source = (ICommand)_source.Target;
if (source != null && isOnOriginalThread)
{
// some sources delegate the event to another weak-event
// manager, using thread-static information (CurrentManager)
// along the way; e.g. all built-in RoutedCommands.
// If we're on the wrong thread, bypass this step as it
// would create a new WeakEventTable and Dispatcher on
// the wrong thread, causing problems at shutdown (DDVSO 543980).
source.CanExecuteChanged -= _onCanExecuteChangedHandler;
}
_source = null;
_originalHandler = null;
}
}
void OnCanExecuteChanged(object sender, EventArgs e)
{
// this protects against re-entrancy: a purge happening
// while a CanExecuteChanged event is being delivered
if (_source == null)
return;
// if the sender is our own CommandManager, the original
// source delegated is CanExecuteChanged event to
// CommandManager.RequerySuggested. We use the original
// source as the sender when passing the event along, so that
// listeners can distinguish which command is changing.
// We could do that for 3rd-party commands that delegate as
// well, but we don't for compat with 4.0.
if (sender is CommandManager)
{
sender = _source.Target;
}
// pass the event along to the original listener
EventHandler<EventArgs> handler = (EventHandler<EventArgs>)_originalHandler.Target;
if (handler != null)
{
handler(sender, e);
}
else
{
// listener has been GC'd - schedule a purge
_manager.ScheduleCleanup();
}
}
CanExecuteChangedEventManager _manager;
WeakReference _source;
WeakReference _originalHandler;
EventHandler _onCanExecuteChangedHandler; // see remarks in the constructor
}
#endregion HandlerSink
}
}
|