public ChoWeakEventHandlerState(EventHandler <E> eventHandler, UnregisterCallback <E> unregister)
{
_target = new WeakReference(eventHandler.Target);
_openHandler = (OpenEventHandler)Delegate.CreateDelegate(typeof(OpenEventHandler), null, eventHandler.Method);
_eventHandler = Invoke;
_unregister = unregister;
}
/// <summary>
/// Gestiona los eventos de multiples propiedades.
/// </summary>
public RegisterForImp <TSender> RegisterProperties(Type[] propertyTypes, string[] propertyNames, Func <TSender, object>[] getValues,
RegisterCallback <TSender, EventHandler_v2 <PropertyChangedExEventArgs> > register,
UnregisterCallback <TSender, EventHandler_v2 <PropertyChangedExEventArgs> > unregister,
bool valuesToManager = true)
{
return(this.RegisterProperties(propertyTypes, propertyNames, getValues, null, register, unregister, valuesToManager));
}
/// <summary>
/// Creates a new object.
/// </summary>
/// <param name="eventHandler"></param>
/// <param name="unregister"></param>
public WeakEventHandler(EventHandler <E> eventHandler, UnregisterCallback <E> unregister)
{
_WeakReference = new WeakReference(eventHandler.Target);
_OpenEventHandler = (OpenEventHandler)Delegate.CreateDelegate(typeof(OpenEventHandler), null, eventHandler.Method);
_EventHandler = Invoke;
_UnregisterCallback = unregister;
}
public WeakEventHandler(EventHandler <E> eventHandler, UnregisterCallback <E> unregister)
{
_TargetRef = new WeakReference(eventHandler.Target);
_OpenHandler = (OpenEventHandler)eventHandler.GetMethodInfo().CreateDelegate(typeof(OpenEventHandler), null);
_Handler = Invoke;
_Unregister = unregister;
}
/// <summary>
/// Initializes a new instance of the WeakEventHandler
/// </summary>
/// <param name="eventHandler">event handler to hook up</param>
/// <param name="unregister">callback to unregister the event handler</param>
public WeakEventHandler(EventHandler <E> eventHandler, UnregisterCallback <E> unregister = null)
{
this.reference = new WeakReference(eventHandler.Target);
this.openHandler = (OpenEventHandler)Delegate.CreateDelegate(typeof(OpenEventHandler), null, eventHandler.Method);
this.handler = Invoke;
this.unregister = unregister;
}
/// <summary>
/// Crea un handler debil para eventos de tipo <c>TEventHandler</c>,
/// </summary>
/// <param name="eventHandler">Handler origen.</param>
/// <param name="unregister">Delegado para deregistrar el evento.</param>
/// <returns>Handler debil.</returns>
public static IWeakEventHandler <TEventHandler> MakeWeak <TEventHandler, TEventArgs>(
TEventHandler eventHandler,
UnregisterCallback <TEventHandler> unregister)
where TEventArgs : EventArgs
{
Delegate delEventHandler = eventHandler as Delegate;
Contract.Requires(delEventHandler != null);
// Only instance methods are supported.
Contract.Requires(!delEventHandler.Method.IsStatic && delEventHandler.Target != null);
Type wehType = typeof(WeakEventHandler <, ,>).MakeGenericType(
delEventHandler.Method.DeclaringType,
typeof(TEventHandler),
typeof(TEventArgs));
ConstructorInfo wehConstructor = wehType.GetConstructor(new[]
{
typeof(TEventHandler),
typeof(UnregisterCallback <TEventHandler>)
});
Contract.Assert(wehConstructor != null);
IWeakEventHandler <TEventHandler> weh = (IWeakEventHandler <TEventHandler>)wehConstructor.Invoke(new object[]
{
eventHandler,
unregister
});
return(weh);
}
/// <summary>
/// Gestiona los eventos de una lista.
/// </summary>
public RegisterForImp <TSender> RegisterList <TItem>(Func <TSender, IList <TItem> > getValues,
RegisterCallback <TSender, EventHandler_v2 <ListEventArgs> > register,
UnregisterCallback <TSender, EventHandler_v2 <ListEventArgs> > unregister,
bool valuesToManager = true)
{
return(this.RegisterList(getValues, null, register, unregister, valuesToManager));
}
public AnotherWeakEventHandler(EventHandler <E> eventHandler, UnregisterCallback <E> unregister)
{
m_TargetRef = new WeakReference(eventHandler.Target);
m_OpenHandler = (OpenEventHandler)Delegate.CreateDelegate(typeof(OpenEventHandler), null, eventHandler.Method);
m_Handler = Invoke;
m_Unregister = unregister;
}
/// <summary>
/// Creates a new weak event handler.
/// </summary>
/// <param name="eventHandler">The event handler to wrap</param>
/// <param name="unregister">A callback that will unsubscribe the handler once its target is garbage collected</param>
public WeakEventHandler(EventHandler <TArgs> eventHandler, UnregisterCallback <TArgs> unregister)
{
_targetRef = new WeakReference(eventHandler.Target);
_openHandler = (OpenEventHandler)Delegate.CreateDelegate(openEventHandlerType, null, eventHandler.Method);
_handler = Invoke;
_unregister = unregister;
}
/// <summary>
/// Sxtesion method for EventHandler<E>
/// </summary>
/// <typeparam name="E">The type</typeparam>
/// <param name="eventHandler">The EventHandler</param>
/// <param name="unregister">EventHandler unregister delegate</param>
/// <returns>An EventHandler</returns>
public static EventHandler <E> MakeWeak <E>(this EventHandler <E> eventHandler,
UnregisterCallback <E> unregister) where E : System.EventArgs
{
if (eventHandler == null)
{
throw new ArgumentNullException("eventHandler");
}
if (eventHandler.Method.IsStatic || eventHandler.Target == null)
{
throw new ArgumentException("Only instance methods are supported.", "eventHandler");
}
Type wehType = typeof(WeakEventHandler <,>).MakeGenericType(
eventHandler.Method.DeclaringType, typeof(E));
ConstructorInfo wehConstructor =
wehType.GetConstructor(new Type[] { typeof(EventHandler <E>),
typeof(UnregisterCallback <E>) });
IWeakEventHandler <E> weh = (IWeakEventHandler <E>)wehConstructor.Invoke(
new object[] { eventHandler, unregister });
return(weh.Handler);
}
/// <summary>
/// 対象がGC可能な弱い参照を持つイベントハンドラを作成します。
/// </summary>
public static EventHandler <TEventArgs> MakeWeak <TEventArgs>(
this EventHandler <TEventArgs> eventHandler,
UnregisterCallback <TEventArgs> unregister)
where TEventArgs : EventArgs
{
if (eventHandler == null)
{
throw new ArgumentNullException("eventHandler");
}
if (eventHandler.Method.IsStatic || eventHandler.Target == null)
{
// staticメソッドの場合はそのまま返します。
return(eventHandler);
}
var wehType = typeof(WeakEventHandler <,>).MakeGenericType(
eventHandler.Method.DeclaringType, typeof(TEventArgs));
var weh = (IWeakEventHandler <TEventArgs>)Activator.CreateInstance(
wehType,
new object[]
{
eventHandler,
unregister,
});
return(weh.Handler);
}
/// <summary>
/// Gestiona los eventos de una propiedad.
/// </summary>
public RegisterForImp <TSender> RegisterProperty <TItem>(string propertyName, Func <TSender, TItem> getValue,
RegisterCallback <TSender, EventHandler_v2 <PropertyChangedExEventArgs> > register,
UnregisterCallback <TSender, EventHandler_v2 <PropertyChangedExEventArgs> > unregister,
bool valuesToManager = true)
{
return(this.RegisterProperty(propertyName, getValue, null, register, unregister, valuesToManager));
}
public WeakEventHandler(EventHandler <TData> eventHandler, UnregisterCallback <TData> unregister)
{
_TargetRef = new WeakReference(eventHandler.Target);
_OpenHandler = (OpenEventHandler)eventHandler.CreateDelegate(typeof(OpenEventHandler), (object)null);
_Handler = Invoke;
_Unregister = unregister;
}
/// <summary>
/// Crea un handler debil para eventos de tipo <c>EventHandler</c>,
/// </summary>
/// <param name="eventHandler">Handler origen.</param>
/// <param name="register">Delegado para registrar el evento.</param>
/// <param name="unregister">Delegado para deregistrar el evento.</param>
/// <returns>Handler debil.</returns>
public static IWeakEventHandler <EventHandler> WeakListen(
this EventHandler eventHandler,
RegisterCallback <EventHandler> register,
UnregisterCallback <EventHandler> unregister)
{
return(WeakListen <EventHandler, EventArgs>(eventHandler, register, unregister));
}
/// <summary>
/// Crea un handler debil para eventos de tipo <c>EventHandler_v2</c>,
/// </summary>
/// <param name="eventHandler">Handler origen.</param>
/// <param name="unregister">Delegado para deregistrar el evento.</param>
/// <returns>Handler debil.</returns>
public static IWeakEventHandler <EventHandler_v2 <T> > MakeWeak <T>(
this EventHandler_v2 <T> eventHandler,
UnregisterCallback <EventHandler_v2 <T> > unregister)
where T : EventArgs
{
return(MakeWeak <EventHandler_v2 <T>, T>(eventHandler, unregister));
}
public AllPropertiesListener(EventHandler_v2 <PropertyChangedExEventArgs> eventHandler,
RegisterCallback <EventHandler_v2 <PropertyChangedExEventArgs> > register,
UnregisterCallback <EventHandler_v2 <PropertyChangedExEventArgs> > unregister,
bool valuesToManager)
: base(eventHandler, register, unregister)
{
this.ValuesToManager = valuesToManager;
}
public EventListener_v2(EventHandler_v2 <TEventArgs> eventHandler,
RegisterCallback <EventHandler_v2 <TEventArgs> > register,
UnregisterCallback <EventHandler_v2 <TEventArgs> > unregister)
{
this.register = register;
this.unregister = unregister;
this.eventHandler = eventHandler;
}
public EventListener(EventHandler eventHandler,
RegisterCallback <EventHandler> register,
UnregisterCallback <EventHandler> unregister)
{
this.eventHandler = eventHandler;
this.register = register;
this.unregister = unregister;
}
/// <summary>
/// Crea un handler debil para eventos de tipo <c>EventHandler_v2</c>,
/// </summary>
/// <param name="eventHandler">Handler origen.</param>
/// <param name="register">Delegado para registrar el evento.</param>
/// <param name="unregister">Delegado para deregistrar el evento.</param>
/// <returns>Handler debil.</returns>
public static IWeakEventHandler <EventHandler_v2 <T> > WeakListen <T>(
this EventHandler_v2 <T> eventHandler,
RegisterCallback <EventHandler_v2 <T> > register,
UnregisterCallback <EventHandler_v2 <T> > unregister)
where T : EventArgs
{
return(WeakListen <EventHandler_v2 <T>, T>(eventHandler, register, unregister));
}
public ForSource <TSource> RegisterWeak(string name,
EventHandler eventHandler,
RegisterCallback <TSource, EventHandler> register,
UnregisterCallback <TSource, EventHandler> unregister)
{
this.manager.RegisterWeak <TSource, EventHandler, EventArgs>(name, eventHandler, register, unregister);
return(this);
}
public ForSource <TSource> RegisterWeak(string name,
EventHandler <PropertyChangedExEventArgs> eventHandler,
RegisterCallback <TSource, EventHandler <PropertyChangedExEventArgs> > register,
UnregisterCallback <TSource, EventHandler <PropertyChangedExEventArgs> > unregister)
{
this.manager.RegisterWeak <TSource, EventHandler <PropertyChangedExEventArgs>, PropertyChangedExEventArgs>(name, eventHandler, register, unregister);
return(this);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="eventHandler">Handler origen.</param>
/// <param name="unregister">Delegado para deregistrar el evento.</param>
public WeakEventHandler(TEventHandler eventHandler, UnregisterCallback <TEventHandler> unregister)
{
Delegate delEventHandler = (Delegate)(object)eventHandler;
this.targetRef = new WeakReference(delEventHandler.Target);
this.openHandler = (OpenEventHandler)Delegate.CreateDelegate(typeof(OpenEventHandler), null, delEventHandler.Method);
this.handler = (TEventHandler)(object)Delegate.CreateDelegate(typeof(TEventHandler), this, invokeMth);
this.unregister = unregister;
}
public ForSource <TSource> RegisterWeak <TEventArgs>(string name,
EventHandler_v2 <TEventArgs> eventHandler,
RegisterCallback <TSource, EventHandler_v2 <TEventArgs> > register,
UnregisterCallback <TSource, EventHandler_v2 <TEventArgs> > unregister)
where TEventArgs : EventArgs
{
this.manager.RegisterWeak <TSource, EventHandler_v2 <TEventArgs>, TEventArgs>(name, eventHandler, register, unregister);
return(this);
}
public WeakEventHandler(EventHandler <TE> eventHandler, UnregisterCallback <TE> unregister)
{
_mTargetRef = new WeakReference(eventHandler.Target);
_mOpenHandler = (OpenEventHandler)Delegate.CreateDelegate(typeof(OpenEventHandler), null, eventHandler.Method);
_mHandler = Invoke;
_mUnregister = unregister;
}
public ListListener(EventHandler_v2 <ListEventArgs> eventHandler,
Func <object, IList <TItem> > getValues,
RegisterCallback <EventHandler_v2 <ListEventArgs> > register,
UnregisterCallback <EventHandler_v2 <ListEventArgs> > unregister,
bool valuesToManager)
: base(eventHandler, register, unregister)
{
this.ValuesToManager = valuesToManager;
this.getValues = getValues;
}
/// <summary>
/// Gestiona los eventos genericos.
/// </summary>
public RegisterForImp <TSender> Register(EventHandler eventHandler,
RegisterCallback <TSender, EventHandler> register,
UnregisterCallback <TSender, EventHandler> unregister)
{
ListenerManager.EventListener listener = new ListenerManager.EventListener(eventHandler,
(sender, h) => register((TSender)sender, h),
(sender, h) => unregister((TSender)sender, h));
this.manager.Add <TSender>(listener);
return(this);
}
/// <summary>
/// Escucha con un handler debil para eventos de tipo <c>TEventHandler</c>,
/// </summary>
/// <param name="eventHandler">Handler origen.</param>
/// <param name="register">Delegado para registrar el evento.</param>
/// <param name="unregister">Delegado para deregistrar el evento.</param>
/// <returns>Handler debil.</returns>
public static IWeakEventHandler <TEventHandler> WeakListen <TEventHandler, TEventArgs>(
TEventHandler eventHandler,
RegisterCallback <TEventHandler> register,
UnregisterCallback <TEventHandler> unregister)
where TEventArgs : EventArgs
{
IWeakEventHandler <TEventHandler> weak = MakeWeak <TEventHandler, TEventArgs>(eventHandler, unregister);
register(weak.Handler);
return(weak);
}
/// <summary>
/// Initializes a new instance of the WeakEventHandler
/// </summary>
/// <param name="eventHandler">event handler to hook up</param>
/// <param name="unregister">callback to unregister the event handler</param>
public WeakEventHandler(EventHandler <TArgs> eventHandler, UnregisterCallback <TArgs> unregister = null)
{
#if WINRT
throw new NotImplementedException();
#else
this.reference = new WeakReference(eventHandler.Target);
this.openHandler = (OpenEventHandler)Delegate.CreateDelegate(typeof(OpenEventHandler), null, eventHandler.Method);
this.handler = Invoke;
this.unregister = unregister;
#endif
}
/// <summary>
/// Gestiona los eventos genericos.
/// </summary>
public RegisterForImp <TSender> Register <TEventArgs>(EventHandler_v2 <TEventArgs> eventHandler,
RegisterCallback <TSender, EventHandler_v2 <TEventArgs> > register,
UnregisterCallback <TSender, EventHandler_v2 <TEventArgs> > unregister)
where TEventArgs : EventArgs
{
ListenerManager.EventListener_v2 <TEventArgs> listener = new ListenerManager.EventListener_v2 <TEventArgs>(eventHandler,
(sender, h) => register((TSender)sender, h),
(sender, h) => unregister((TSender)sender, h));
this.manager.Add <TSender>(listener);
return(this);
}
/// <summary>
/// Gestiona los eventos de multiples propiedades.
/// </summary>
public RegisterForImp <TSender> RegisterAllProperties(EventHandler_v2 <PropertyChangedExEventArgs> eventHandler,
RegisterCallback <TSender, EventHandler_v2 <PropertyChangedExEventArgs> > register,
UnregisterCallback <TSender, EventHandler_v2 <PropertyChangedExEventArgs> > unregister,
bool valuesToManager = false)
{
ListenerManager.AllPropertiesListener listener = new ListenerManager.AllPropertiesListener(eventHandler,
(sender, h) => register((TSender)sender, h),
(sender, h) => unregister((TSender)sender, h),
valuesToManager);
this.manager.Add <TSender>(listener);
return(this);
}
