protected override void OnEventHandlerAdded(EventHandlerBase <FrameworkElement, UwpEventHandlerItem> eventHandlers, FrameworkElement element)
{
base.OnEventHandlerAdded(eventHandlers, element);
eventHandlers.GetBy(element.Name).From(element).Raise(nameof(FrameworkElement.DataContextChanged));
eventHandlers.GetBy(element.Name).From(element).With(new RoutedEventArgs()).Raise(nameof(FrameworkElement.Loaded));
}
/// <summary>
/// Returns a singleton instance of <see cref="ServiceClient"/>. Parameters are only
/// used during the first instantiation of the <see cref="ServiceClient"/>.
/// </summary>
/// <param name="dteEventHandler"></param>
/// <param name="logger"></param>
/// <returns></returns>
public static ServiceClient GetInstance(EventHandlerBase dteEventHandler, ILogger logger)
{
if (_instance == null)
{
_instance = new ServiceClient(dteEventHandler, logger);
}
return _instance;
}
static void OnSagaSaved(EventHandlerBase sender, ISaga saga, IEvent by)
{
if (by != null && saga != null)
{
Console.WriteLine("[SAGA] {0} -> {1} -> {2}",
by.GetType().FullName,
saga.GetType().FullName,
string.Join(", ", saga.GetUndispatchedMessages().OfType <object>().Select(e => e.GetType().FullName)));
}
}
public virtual void OnFlush(EventHandlerBase sender, NHibernate.Event.FlushEntityEvent e)
{
if (Tester != null)
{
Tester.OnFlush++;
if (Tester.ThrowOnFlush)
{
throw new Exception("Store.OnFlush()");
}
}
}
public virtual void OnDelete(EventHandlerBase sender, NHibernate.Event.DeleteEvent e, Iesi.Collections.ISet transientEntities)
{
if (Tester != null)
{
Tester.OnDelete++;
if (Tester.ThrowOnDelete)
{
throw new Exception("Store.OnDelete()");
}
}
}
public virtual void OnSave(EventHandlerBase sender, NHibernate.Event.SaveOrUpdateEvent e)
{
if (Tester != null)
{
Tester.OnSave++;
if (Tester.ThrowOnSave)
{
throw new Exception("Store.OnSave()");
}
}
}
protected override void OnEventHandlerAdded(EventHandlerBase <StyledElement, AvaloniaEventHandlerItem> eventHandlers, StyledElement element)
{
base.OnEventHandlerAdded(eventHandlers, element);
eventHandlers.GetBy(element.Name)
.From(element)
.With(new AvaloniaPropertyChangedEventArgs <object>(element, StyledElement.DataContextProperty, null, element.DataContext, BindingPriority.LocalValue))
.Raise(nameof(StyledElement.DataContextChanged));
eventHandlers.GetBy(element.Name)
.From(element)
.With(new LogicalTreeAttachmentEventArgs(element.FindLogicalRoot(), element, element.Parent))
.Raise(nameof(StyledElement.AttachedToLogicalTree));
}
private void OnAddNewHandlerSelected(object index)
{
EEventHandlerType handlerType = (EEventHandlerType)index;
EventHandlerBase newHandler = null;
newHandler = m_CurrentEventTrigger.CreateEventEntryHandler(handlerType);
if (newHandler == null)
{
return;
}
m_CurrentEventTrigger.Triggers[toBeAddEntry].AddEventHandler(newHandler);
serializedObject.ApplyModifiedProperties();
}
private ServiceClient(EventHandlerBase dteEventHandler, ILogger logger)
{
var events = dteEventHandler;
_logger = logger;
//AC: "events" ends up being null during unit testing. Otherwise, it should never happen.
if (events != null)
{
events.EventCreated += OsbideEventCreated;
}
//if we don't have a cache record of pending logs when we start, create a dummy list
if (!_cache.Contains(CacheKey, CacheRegion))
{
SaveLogsToCache(new List <IActivityEvent>());
}
}
private ServiceClient(EventHandlerBase dteEventHandler, ILogger logger)
{
_events = dteEventHandler;
this._logger = logger;
_webServiceClient = new OsbideWebServiceClient(ServiceBindings.OsbideServiceBinding, ServiceBindings.OsbideServiceEndpoint);
//AC: "events" ends up being null during unit testing. Otherwise, it should never happen.
if (_events != null)
{
_events.EventCreated += new EventHandler<EventCreatedArgs>(OsbideEventCreated);
}
//if we don't have a cache record of pending logs when we start, create a dummy list
if (!_cache.Contains(_cacheKey, _cacheRegion))
{
SaveLogsToCache(new List<EventLog>());
}
}
/// <summary>
/// Retrieves event handlers from the specified controller.
/// </summary>
/// <param name="controller">The controller in which event handlers are defined.</param>
/// <param name="element">The element that raises the event.</param>
/// <returns>The <see cref="EventHandlerBase{TElement,TItem}"/> to add retrieved event handlers.</returns>
protected virtual EventHandlerBase <TElement, TItem> RetrieveEventHandlers(object controller, TElement?element)
{
var eventHandlerBases = EnsureEventHandlerBases(element);
if (eventHandlerBases.ContainsKey(controller))
{
return(eventHandlerBases[controller]);
}
var eventHandlers = new EventHandlerBase <TElement, TItem>();
eventHandlerBases[controller] = eventHandlers;
RetrieveEventHandlersFromField(controller, element, eventHandlers);
RetrieveEventHandlersFromProperty(controller, element, eventHandlers);
RetrieveEventHandlersFromMethod(controller, element, eventHandlers);
RetrieveEventHandlersFromMethodUsingNamingConvention(controller, element, eventHandlers);
return(eventHandlers);
}
public static EventHandlerBase AddUISoundTrigger(this GameObject _uGameObject, UnityEngine.EventSystems.EventTriggerType _eTriggerType, string _strFilter, string _strKey)
{
UEventTrigger tmpTrigger = null;
if (_uGameObject.GetComponent <UEventTrigger>() == null)
{
tmpTrigger = _uGameObject.AddComponent <UEventTrigger>();
}
else
{
tmpTrigger = _uGameObject.GetComponent <UEventTrigger>();
}
EventHandlerBase handlerBase = tmpTrigger.CreateEventEntryHandler(EEventHandlerType.Sound);
handlerBase.SetSoundConfig(_strFilter, _strKey);
tmpTrigger.AddEventEntryHandler(_eTriggerType, handlerBase);
return(handlerBase);
}
/// <summary>
/// Retrieves event handlers from fields that are defined in the specified controller.
/// </summary>
/// <param name="controller">The controller in which event handlers are defined.</param>
/// <param name="element">The element that raises the event.</param>
/// <param name="eventHandlers">The <see cref="EventHandlerBase{TElement,TItem}"/> to add retrieved event handlers.</param>
protected virtual void RetrieveEventHandlersFromField(object controller, TElement?element, EventHandlerBase <TElement, TItem> eventHandlers)
=> controller.GetType()
.GetFields(EventHandlerBindingFlags)
.Where(field => field.GetCustomAttributes <EventHandlerAttribute>(true).Any())
.ForEach(field => AddEventHandlers(field, element, handlerType => CreateEventHandler(field.GetValue(controller) as Delegate, handlerType), eventHandlers));
/// <summary>
/// Retrieves event handlers from methods that are defined in the specified controller.
/// </summary>
/// <param name="controller">The controller in which event handlers are defined.</param>
/// <param name="element">The element that raises the event.</param>
/// <param name="eventHandlers">The <see cref="EventHandlerBase{TElement,TItem}"/> to add retrieved event handlers.</param>
protected virtual void RetrieveEventHandlersFromMethod(object controller, TElement?element, EventHandlerBase <TElement, TItem> eventHandlers)
=> controller.GetType()
.GetMethods(EventHandlerBindingFlags)
.Where(method => method.GetCustomAttributes <EventHandlerAttribute>(true).Any())
.ForEach(method => AddEventHandlers(method, element, handlerType => CreateEventHandler(method, controller, handlerType), eventHandlers));
protected override void AddEventHandler(TestElement?element, EventHandlerAttribute eventHandlerAttribute, Func <Type?, Delegate?> handlerCreator, EventHandlerBase <TestElement, EventHandlerItemTss> eventHandlers)
{
eventHandlers.Add(new EventHandlerItemTss(
eventHandlerAttribute.ElementName, element,
eventHandlerAttribute.Event, handlerCreator(null), eventHandlerAttribute.HandledEventsToo
));
}
private void OnCustomEvent(EventHandlerBase eventHandler)
{
Log.Info("接收到CustomEvent事件，参数：" + (eventHandler as CustomEvent).Args);
}
/// <summary>
/// Retrieves event handlers from methods that are defined in the specified controller.
/// </summary>
/// <param name="controller">The controller in which event handlers are defined using a naming convention (ElementName_EventName).</param>
/// <param name="element">The element that raises the event.</param>
/// <param name="eventHandlers">The <see cref="EventHandlerBase{TElement,TItem}"/> to add retrieved event handlers.</param>
protected virtual void RetrieveEventHandlersFromMethodUsingNamingConvention(object controller, TElement?element, EventHandlerBase <TElement, TItem> eventHandlers)
=> controller.GetType()
.GetMethods(EventHandlerBindingFlags)
.Where(FilterMethodUsingNamingConvention)
.Select(method =>
/// <summary>
/// Adds an event handler to the specified <see cref="EventHandlerBase{TElement,TItem}"/> using the specified element,
/// <see cref="EventHandlerAttribute"/>, and the function to create a delegate of the event handler.
/// </summary>
/// <param name="element">The element that raises the event.</param>
/// <param name="eventHandlerAttribute">The <see cref="EventHandlerAttribute"/> specified to the method that handles the event.</param>
/// <param name="handlerCreator">The function to create a delegate of the event handler.</param>
/// <param name="eventHandlers">The <see cref="EventHandlerBase{TElement,TItem}"/> to add the event handler.</param>
protected abstract void AddEventHandler(TElement?element, EventHandlerAttribute eventHandlerAttribute, Func <Type?, Delegate?> handlerCreator, EventHandlerBase <TElement, TItem> eventHandlers);
protected override void AddEventHandler(FrameworkElement element, EventHandlerAttribute eventHandlerAttribute, Func <Type, Delegate> handlerCreator, EventHandlerBase <FrameworkElement, UwpEventHandlerItem> eventHandlers)
{
var targetElement = element.FindElement <FrameworkElement>(eventHandlerAttribute.ElementName);
var routedEvent = RetrieveRoutedEvent(targetElement, eventHandlerAttribute.Event);
var eventInfo = RetrieveEventInfo(targetElement, eventHandlerAttribute.Event);
eventHandlers.Add(new UwpEventHandlerItem(
eventHandlerAttribute.ElementName, targetElement,
eventHandlerAttribute.Event, routedEvent, eventInfo,
handlerCreator(eventInfo?.EventHandlerType), eventHandlerAttribute.HandledEventsToo
));
}
/// <summary>
/// Returns a singleton instance of <see cref="ServiceClient"/>. Parameters are only
/// used during the first instantiation of the <see cref="ServiceClient"/>.
/// </summary>
/// <param name="dteEventHandler"></param>
/// <param name="logger"></param>
/// <returns></returns>
public static ServiceClient GetInstance(EventHandlerBase dteEventHandler, ILogger logger)
{
return(_instance ?? (_instance = new ServiceClient(dteEventHandler, logger)));
}
protected override void RetrieveEventHandlersFromMethodUsingNamingConvention(object controller, StyledElement element, EventHandlerBase <StyledElement, AvaloniaEventHandlerItem> eventHandlers)
=> controller.GetType()
.GetMethods(EventHandlerBindingFlags)
.Where(method => EventHandlerNamingConventionRegex.IsMatch(method.Name))
.Where(method => !method.Name.StartsWith("get_"))
.Where(method => !method.Name.StartsWith("set_"))
.Where(method => !method.GetCustomAttributes <EventHandlerAttribute>(true).Any())
.Select(method =>
{
var separatorIndex = method.Name.IndexOf("_", StringComparison.Ordinal);
return(new
{
MethodInfo = method,
EventHanndlerAttribute = new EventHandlerAttribute
{
ElementName = method.Name.Substring(0, separatorIndex),
Event = method.Name.Substring(separatorIndex + 1)
}
});
})
.ForEach(x => AddEventHandler(element, x.EventHanndlerAttribute, handlerType => CreateEventHandler(x.MethodInfo, controller, handlerType), eventHandlers));
protected override void AddEventHandler(StyledElement element, EventHandlerAttribute eventHandlerAttribute, Func <Type, Delegate> handlerCreator, EventHandlerBase <StyledElement, AvaloniaEventHandlerItem> eventHandlers)
{
var targetElement = element.FindElement <StyledElement>(eventHandlerAttribute.ElementName);
var routedEvent = RetrieveRoutedEvent(targetElement, eventHandlerAttribute.Event);
var eventInfo = RetrieveEventInfo(element, eventHandlerAttribute.Event);
eventHandlers.Add(new AvaloniaEventHandlerItem(
eventHandlerAttribute.ElementName, targetElement,
eventHandlerAttribute.Event, routedEvent, eventInfo,
handlerCreator(routedEvent?.EventArgsType == null ? eventInfo?.EventHandlerType : typeof(EventHandler <>).MakeGenericType(routedEvent.EventArgsType)),
eventHandlerAttribute.HandledEventsToo
));
}
/// <summary>
/// Retrieves event handlers from properties that are defined in the specified controller.
/// </summary>
/// <param name="controller">The controller in which event handlers are defined.</param>
/// <param name="element">The element that raises the event.</param>
/// <param name="eventHandlers">The <see cref="EventHandlerBase{TElement,TItem}"/> to add retrieved event handlers.</param>
protected virtual void RetrieveEventHandlersFromProperty(object controller, TElement?element, EventHandlerBase <TElement, TItem> eventHandlers)
=> controller.GetType()
.GetProperties(EventHandlerBindingFlags)
.Where(property => property.GetCustomAttributes <EventHandlerAttribute>(true).Any())
.Where(property => property.CanRead)
.ForEach(property => AddEventHandlers(property, element, handlerType => CreateEventHandler(property.GetValue(controller) as Delegate, handlerType), eventHandlers));
/// <summary>
/// Initializes a new instance of the <see cref="EventArgsResolverScopeEventHandlerBase{T}"/> class
/// with the specified event args resolvers and event handlers.
/// </summary>
/// <param name="eventArgsResolvers">The collection of the event args resolver.</param>
/// <param name="eventHandlerBase">The event handlers that handle an event.</param>
/// <exception cref="ArgumentNullException">
/// <paramref name="eventHandlerBase"/> is <c>null</c>.
/// </exception>
public EventArgsResolverScopeEventHandlerBase(IEnumerable <IEventArgsResolver> eventArgsResolvers, EventHandlerBase <FrameworkElement, UwpEventHandlerItem> eventHandlerBase)
{
this.eventArgsResolvers = eventArgsResolvers;
this.eventHandlerBase = eventHandlerBase;
}
/// <summary>
/// Initializes a new instance of the <see cref="Executor"/> class
/// with the specified event args resolvers and executor to raise an event.
/// </summary>
/// <param name="eventArgsResolvers">The collection of the event args resolver.</param>
/// <param name="executor">The executor to raise an event.</param>
/// <exception cref="ArgumentNullException">
/// <paramref name="executor"/> is <c>null</c>.
/// </exception>
public Executor(IEnumerable <IEventArgsResolver> eventArgsResolvers, EventHandlerBase <FrameworkElement, UwpEventHandlerItem> .Executor executor)
{
this.eventArgsResolvers = eventArgsResolvers;
this.executor = executor.RequireNonNull(nameof(executor));
}
