/// <summary>
/// Releases unmanaged and - optionally - managed resources
/// </summary>
/// <param name="disposing">
/// <c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.
/// </param>
/// <returns></returns>
protected override bool Dispose(bool disposing)
{
if (!disposing)
{
return(false);
}
_isActive = false;
if (_canExecuteMethod != null)
{
_canExecuteMethod.Dispose();
_canExecuteMethod = null;
}
if (_executeMethod != null)
{
_executeMethod.Dispose();
_executeMethod = null;
}
if (_isActiveChangedHandlers != null)
{
_isActiveChangedHandlers.Dispose();
_isActiveChangedHandlers = null;
}
if (_canExecuteChangedHandlers != null)
{
_canExecuteChangedHandlers.Dispose();
_canExecuteChangedHandlers = null;
}
return(base.Dispose(true));
}
public static void RegisterWeakDelegate(IWeakDelegate weak)
{
// If this is not an instance delegate we haven nothing to register
if (weak.Reference.Target == null)
{
return;
}
bool startThread = false;
// Add a reference to our instance delegate
lock (InstanceDelegates) {
if (!InstanceDelegates.ContainsKey(weak))
{
InstanceDelegates.Add(weak, weak);
startThread = (InstanceDelegates.Count == 1 && CollectionThread == null);
if (startThread)
{
CollectionThread = new Thread(RunCollectionThread);
}
}
}
// If we need to start our garbage collection thread then start it up
if (startThread)
{
CollectionThread.IsBackground = true;
CollectionThread.Start();
}
}
/// <summary>
/// Initialize with specified execute methods.
/// </summary>
/// <param name="executeMethod">The execute method.</param>
/// <param name="canExecuteMethod">The can execute method.</param>
/// <exception cref="System.ArgumentNullException">executeMethod</exception>
internal protected virtual void Init(Action <object> executeMethod, Func <object, bool> canExecuteMethod)
{
if (executeMethod == null || canExecuteMethod == null)
{
throw new ArgumentNullException("executeMethod", Properties.Resources.ErrMsg_CommandDelegatesCantBeNull);
}
_executeMethod = new DelegateReference(executeMethod, true);
_canExecuteMethod = new DelegateReference(canExecuteMethod, true);
}
/// <summary>
/// Initialize with specified execute method.
/// </summary>
/// <param name="executeMethod">The execute method.</param>
/// <exception cref="System.ArgumentNullException">executeMethod</exception>
internal protected virtual void Init(Action <object> executeMethod)
{
if (executeMethod == null)
{
//System.Diagnostics.Debug.WriteLine(string.Format("[{0}] executeMethod == null !!!", typeof(DelegateCommand)));
throw new ArgumentNullException("executeMethod", Properties.Resources.ErrMsg_CommandDelegatesCantBeNull);
}
_executeMethod = new DelegateReference(executeMethod, true);
//System.Diagnostics.Debug.WriteLine(string.Format("[{0}] _executeMethod == {1} !!!", typeof(DelegateCommand), _executeMethod));
Func <object, bool> func = o => CanExecuteCommand(this);
_canExecuteMethod = new DelegateReference(func, true);
//System.Diagnostics.Debug.WriteLine(string.Format("[{0}] _canExecuteMethod == {1} !!!", typeof(DelegateCommand), _canExecuteMethod));
}
public void TestDisposeWithMethod()
{
IWeakDelegate weakDel = null;
new Action(() =>
{
Subscriber sub = new Subscriber();
weakDel = new WeakDelegate(sub, sub, ((Action <bool>)sub.Listener).GetMethodInfo());
Assert.IsTrue(weakDel.IsSubscriberAlive);
sub = null;
})();
GC.Collect();
GC.WaitForPendingFinalizers();
Assert.IsFalse(weakDel.IsSubscriberAlive);
}
public XChannel(ChannelIdentification channelIdentification, object?targetId, bool exclusiveChannel, IWeakDelegate weakDelegate)
{
this.Identification = channelIdentification;
this.TargetId = targetId;
this.ExclusiveChannel = exclusiveChannel;
this.WeakDelegate = weakDelegate;
}
private static XChannel AddXChannel(LinkedList <XChannel> list, ChannelIdentification identification, object?targetId, bool exclusiveChannel, IWeakDelegate weakDelegate)
{ // lock (cs) required.
if (exclusiveChannel)
{
if (list.Count > 0)
{ // other channel already exists.
throw new InvalidOperationException();
}
}
else
{
if (list.First?.Value.ExclusiveChannel == true)
{ // Exclusive channel exists.
throw new InvalidOperationException();
}
}
// New XChannel
var channel = new XChannel(identification, targetId, exclusiveChannel, weakDelegate);
// list: Identification to XChannels.
channel.Node = list.AddLast(channel);
return(channel);
}
private bool Subscribe(int key, IWeakDelegate weakDel)
{
return(GetSubscriberSet(key).Add(weakDel));
}
public static void UnregisterWeakDelegate(IWeakDelegate weak)
{
lock (InstanceDelegates) {
InstanceDelegates.Remove(weak);
}
}
