public void TestInternalClassAnonymousMethod()
{
Reset();
const int index = 99;
_itemInternal = new InternalTestClass(index);
_reference = new WeakReference(_itemInternal);
_action = _itemInternal.GetAction(WeakActionTestCase.AnonymousMethod);
Assert.IsTrue(_reference.IsAlive);
Assert.IsTrue(_action.IsAlive);
_action.Execute();
Assert.AreEqual(
InternalTestClass.Expected + index,
InternalTestClass.Result);
_itemInternal = null;
GC.Collect();
Assert.IsFalse(_reference.IsAlive);
}
/// <summary>
/// Initializes a new instance of the <see cref="AsyncRelayCommand"/> class.
/// </summary>
/// <param name="executeAsync">The execution logic for async processing.</param>
/// <param name="executeFinished">The execution logic to perform when the async operation has finished.</param>
/// <param name="canExecute">The execution status logic.</param>
/// <exception cref="T:System.ArgumentNullException">If the executeAsync argument is null.</exception>
public AsyncRelayCommand(Action executeAsync, Action executeFinished, Func<bool> canExecute) : base(executeAsync, canExecute)
{
if (executeFinished == null)
{
throw new ArgumentNullException("executeFinished");
}
_executeFinished = new WeakAction(executeFinished);
}
public WeakAction GetAction(WeakActionTestCase testCase)
{
WeakAction action = null;
switch (testCase)
{
case WeakActionTestCase.PublicNamedMethod:
action = new WeakAction(
this,
DoStuffPublically);
break;
case WeakActionTestCase.InternalNamedMethod:
action = new WeakAction(
this,
DoStuffInternally);
break;
case WeakActionTestCase.PrivateNamedMethod:
action = new WeakAction(
this,
DoStuffPrivately);
break;
case WeakActionTestCase.PublicStaticMethod:
action = new WeakAction(
this,
DoStuffPublicallyAndStatically);
break;
case WeakActionTestCase.InternalStaticMethod:
action = new WeakAction(
this,
DoStuffInternallyAndStatically);
break;
case WeakActionTestCase.PrivateStaticMethod:
action = new WeakAction(
this,
DoStuffPrivatelyAndStatically);
break;
case WeakActionTestCase.AnonymousStaticMethod:
action = new WeakAction(
this,
() => Result = Expected);
break;
case WeakActionTestCase.AnonymousMethod:
action = new WeakAction(
this,
() => Result = Expected + _index);
break;
}
return action;
}
/// <summary>
/// Initializes a new instance of the RelayCommand class.
/// </summary>
/// <param name="execute">The execution logic.</param>
/// <param name="canExecute">The execution status logic.</param>
/// <exception cref="ArgumentNullException">If the execute argument is null.</exception>
public RelayCommand(Action execute, Func<bool> canExecute)
{
Idle = true;
if (execute == null)
{
throw new ArgumentNullException("execute");
}
ExecuteAction = new WeakAction(execute);
if (canExecute != null)
{
_canExecute = new WeakFunc<bool>(canExecute);
}
}
public void TestStaticMethodWithNullTarget()
{
Reset();
WeakAction action = new WeakAction(null, DoStuffStatic);
Assert.IsTrue(action.IsAlive);
}
public void TestStaticMethodWithNonNullTarget()
{
Reset();
_common = new CommonTestClass();
_reference = new WeakReference(_common);
Assert.IsTrue(_reference.IsAlive);
WeakAction action = new WeakAction(_common, DoStuffStatic);
Assert.IsTrue(action.IsAlive);
_common = null;
GC.Collect();
Assert.IsFalse(_reference.IsAlive);
Assert.IsFalse(action.IsAlive);
}
public void TestPublicClassPublicStaticMethod()
{
Reset();
_itemPublic = new PublicTestClass();
_reference = new WeakReference(_itemPublic);
_action = _itemPublic.GetAction(WeakActionTestCase.PublicStaticMethod);
Assert.IsTrue(_reference.IsAlive);
Assert.IsTrue(_action.IsAlive);
_action.Execute();
Assert.AreEqual(
PublicTestClass.Expected + PublicTestClass.PublicStatic,
PublicTestClass.Result);
_itemPublic = null;
GC.Collect();
Assert.IsFalse(_reference.IsAlive);
}
public void TestPublicClassPrivateNamedMethod()
{
Reset();
const int index = 99;
_itemPublic = new PublicTestClass(index);
_reference = new WeakReference(_itemPublic);
_action = _itemPublic.GetAction(WeakActionTestCase.PrivateNamedMethod);
Assert.IsTrue(_reference.IsAlive);
Assert.IsTrue(_action.IsAlive);
_action.Execute();
Assert.AreEqual(
PublicTestClass.Expected + PublicTestClass.Private + index,
PublicTestClass.Result);
_itemPublic = null;
GC.Collect();
Assert.IsFalse(_reference.IsAlive);
}
public void TestInternalClassPublicStaticMethod()
{
Reset();
_itemInternal = new InternalTestClass();
_reference = new WeakReference(_itemInternal);
_action = _itemInternal.GetAction(WeakActionTestCase.PublicStaticMethod);
Assert.IsTrue(_reference.IsAlive);
Assert.IsTrue(_action.IsAlive);
_action.Execute();
Assert.AreEqual(
InternalTestClass.Expected + InternalTestClass.PublicStatic,
InternalTestClass.Result);
_itemInternal = null;
GC.Collect();
Assert.IsFalse(_reference.IsAlive);
}
public void TestPrivateNestedClassPrivateStaticMethod()
{
Reset();
_itemPrivate = new PrivateNestedTestClass();
_reference = new WeakReference(_itemPrivate);
_action = _itemPrivate.GetAction(WeakActionTestCase.PrivateStaticMethod);
Assert.IsTrue(_reference.IsAlive);
Assert.IsTrue(_action.IsAlive);
_action.Execute();
Assert.AreEqual(
PrivateNestedTestClass.Expected + PrivateNestedTestClass.PrivateStatic,
PrivateNestedTestClass.Result);
_itemPrivate = null;
GC.Collect();
Assert.IsFalse(_reference.IsAlive);
}
public void TestPrivateNestedClassInternalNamedMethod()
{
Reset();
const int index = 99;
_itemPrivate = new PrivateNestedTestClass(index);
_reference = new WeakReference(_itemPrivate);
_action = _itemPrivate.GetAction(WeakActionTestCase.InternalNamedMethod);
Assert.IsTrue(_reference.IsAlive);
Assert.IsTrue(_action.IsAlive);
_action.Execute();
Assert.AreEqual(
PrivateNestedTestClass.Expected + PrivateNestedTestClass.Internal + index,
PrivateNestedTestClass.Result);
_itemPrivate = null;
GC.Collect();
Assert.IsFalse(_reference.IsAlive);
}
/// <summary>
/// Initializes a new instance of the <see cref="AsyncRelayCommand"/> class.
/// </summary>
/// <param name="executeAsync">The execution logic for async processing.</param>
/// <param name="canExecute">The execution status logic.</param>
/// <exception cref="T:System.ArgumentNullException">If the executeAsync argument is null.</exception>
public AsyncRelayCommand(Action executeAsync, Func<bool> canExecute) : base(executeAsync, canExecute)
{
_executeFinished = new WeakAction(DummySyncAction);
}
public void TestNonStaticMethodWithNullTarget()
{
Reset();
WeakAction<string> action = new WeakAction<string>(null, DoStuff);
Assert.IsFalse(action.IsAlive);
}