using System;
namespace Pfz.Caching
{
/// <summary>
/// Static class used to convert real (strong) delegates into weak
/// delegates.
/// </summary>
public static class WeakDelegate
{
#region IsWeakDelegate
/// <summary>
/// Verifies if a handler is already a weak delegate.
/// </summary>
/// <param name="handler">The handler to verify.</param>
/// <returns>true if the handler is already a weak delegate, false otherwise.</returns>
public static bool IsWeakDelegate(Delegate handler)
{
return handler.Target != null && handler.Target is WeakDelegateBase;
}
#endregion
#region From(Action)
private sealed class WeakActionWrapper:
WeakDelegateBase
{
internal WeakActionWrapper(Action handler):
base(handler)
{
}
internal void Execute()
{
Invoke(null);
}
}
/// <summary>
/// Creates a weak delegate from an Action delegate.
/// </summary>
public static Action From(Action strongHandler)
{
if (IsWeakDelegate(strongHandler))
throw new ArgumentException("Your delegate is already a weak-delegate.");
var wrapper = new WeakActionWrapper(strongHandler);
return new Action(wrapper.Execute);
}
#endregion
#region From(Action<T>)
private sealed class WeakActionWrapper<T>:
WeakDelegateBase
{
internal WeakActionWrapper(Action<T> handler):
base(handler)
{
}
internal void Execute(T parameter)
{
Invoke(new object[]{parameter});
}
}
/// <summary>
/// Creates a weak delegate from an Action<T> delegate.
/// </summary>
public static Action<T> From<T>(Action<T> strongHandler)
{
if (IsWeakDelegate(strongHandler))
throw new ArgumentException("Your delegate is already a weak-delegate.");
var wrapper = new WeakActionWrapper<T>(strongHandler);
return new Action<T>(wrapper.Execute);
}
#endregion
#region From(Action<T1, T2>)
private sealed class WeakActionWrapper<T1, T2>:
WeakDelegateBase
{
internal WeakActionWrapper(Action<T1, T2> handler):
base(handler)
{
}
internal void Execute(T1 parameter1, T2 parameter2)
{
Invoke(new object[]{parameter1, parameter2});
}
}
/// <summary>
/// Creates a weak delegate from an Action<T1, T2> delegate.
/// </summary>
public static Action<T1, T2> From<T1, T2>(Action<T1, T2> strongHandler)
{
if (IsWeakDelegate(strongHandler))
throw new ArgumentException("Your delegate is already a weak-delegate.");
var wrapper = new WeakActionWrapper<T1, T2>(strongHandler);
return new Action<T1, T2>(wrapper.Execute);
}
#endregion
#region From(Action<T1, T2, T3>)
private sealed class WeakActionWrapper<T1, T2, T3>:
WeakDelegateBase
{
internal WeakActionWrapper(Action<T1, T2, T3> handler):
base(handler)
{
}
internal void Execute(T1 parameter1, T2 parameter2, T3 parameter3)
{
Invoke(new object[]{parameter1, parameter2, parameter3});
}
}
/// <summary>
/// Creates a weak delegate from an Action<T1, T2, T3> delegate.
/// </summary>
public static Action<T1, T2, T3> From<T1, T2, T3>(Action<T1, T2, T3> strongHandler)
{
if (IsWeakDelegate(strongHandler))
throw new ArgumentException("Your delegate is already a weak-delegate.");
var wrapper = new WeakActionWrapper<T1, T2, T3>(strongHandler);
return new Action<T1, T2, T3>(wrapper.Execute);
}
#endregion
#region From(Action<T1, T2, T3, T4>)
private sealed class WeakActionWrapper<T1, T2, T3, T4>:
WeakDelegateBase
{
internal WeakActionWrapper(Action<T1, T2, T3, T4> handler):
base(handler)
{
}
internal void Execute(T1 parameter1, T2 parameter2, T3 parameter3, T4 parameter4)
{
Invoke(new object[]{parameter1, parameter2, parameter3, parameter4});
}
}
/// <summary>
/// Creates a weak delegate from an Action<T1, T2, T3, T4> delegate.
/// </summary>
public static Action<T1, T2, T3, T4> From<T1, T2, T3, T4>(Action<T1, T2, T3, T4> strongHandler)
{
if (IsWeakDelegate(strongHandler))
throw new ArgumentException("Your delegate is already a weak-delegate.");
var wrapper = new WeakActionWrapper<T1, T2, T3, T4>(strongHandler);
return new Action<T1, T2, T3, T4>(wrapper.Execute);
}
#endregion
#region From(EventHandler)
private sealed class WeakEventHandlerWrapper:
WeakDelegateBase
{
internal WeakEventHandlerWrapper(EventHandler handler):
base(handler)
{
}
internal void Execute(object sender, EventArgs e)
{
Invoke(new object[]{sender, e});
}
}
/// <summary>
/// Creates a weak delegate from an EventHandler delegate.
/// </summary>
public static EventHandler From(EventHandler strongHandler)
{
if (IsWeakDelegate(strongHandler))
throw new ArgumentException("Your delegate is already a weak-delegate.");
var wrapper = new WeakEventHandlerWrapper(strongHandler);
return new EventHandler(wrapper.Execute);
}
#endregion
#region From(EventHandler<TEventArgs>)
private sealed class WeakEventHandlerWrapper<TEventArgs>:
WeakDelegateBase
where
TEventArgs: EventArgs
{
internal WeakEventHandlerWrapper(EventHandler<TEventArgs> handler):
base(handler)
{
}
internal void Execute(object sender, TEventArgs e)
{
Invoke(new object[]{sender, e});
}
}
/// <summary>
/// Creates a weak delegate from an Action<TEventArgs> delegate.
/// </summary>
public static EventHandler<TEventArgs> From<TEventArgs>(EventHandler<TEventArgs> strongHandler)
where
TEventArgs: EventArgs
{
if (IsWeakDelegate(strongHandler))
throw new ArgumentException("Your delegate is already a weak-delegate.");
var wrapper = new WeakEventHandlerWrapper<TEventArgs>(strongHandler);
return new EventHandler<TEventArgs>(wrapper.Execute);
}
#endregion
}
}