public static void RaiseEvent(TEvent e) where TEvent : IEvent
{
foreach (var handler in ObjectFactory.GetAllInstances <IHandle <TEvent> >())
{
handler.Handle(e);
}
}
public static Task FireEventAsync <TEvent>() where TEvent : BaseMixpanelEvent
{
TEvent expr_05 = Activator.CreateInstance <TEvent>();
BaseMixpanelPeople thePeople = (BaseMixpanelPeople)Activator.CreateInstance(expr_05.PeopleType);
return(MixpanelEventSender.FireEventAsync(expr_05, thePeople));
}
/// <summary>
/// Adds a Transition to the collection for the specified event ID.
/// </summary>
/// <param name="eventId">
/// The event ID associated with the Transition.
/// </param>
/// <param name="trans">
/// The Transition to add.
/// </param>
/// <remarks>
/// When a Transition is added to the collection, it is associated with
/// the specified event ID. When a State receives an event, it looks up
/// the event ID in its TransitionCollection to see if there are any
/// Transitions for the specified event.
/// </remarks>
public void Add(TEvent eventId, Transition trans)
{
#region Preconditions
if (trans.Source != null)
{
throw new InvalidOperationException(
"This Transition has already been added to another State.");
}
#endregion
// Set the transition's source.
trans.Source = m_owner;
// If there are no Transitions for the specified event ID.
if (!m_transitions.ContainsKey(eventId))
{
// Create new list of Transitions for the specified event ID.
m_transitions[eventId] = new List <Transition>();
}
// Add Transition.
m_transitions[eventId].Add(trans);
}
public EventActionNode(
TEvent @event,
TParam param)
{
this.Event = @event;
this.Param = param;
}
private void NotifyEvent(TEvent aEvent)
{
if (StateChanged != null)
{
StateChanged(aEvent, this);
}
}
private void ReportEvent(TEvent aEvent)
{
// Ensure we only report significant events once
if (EventHandler != null)
{
switch (aEvent)
{
case TEvent.EAlgorithmStarted:
if ((iFlags & TFlags.EFlagsReportedStarted) != TFlags.EFlagsReportedStarted)
{
iFlags |= TFlags.EFlagsReportedStarted;
EventHandler(this, aEvent);
}
break;
case TEvent.EAlgorithmComplete:
if ((iFlags & TFlags.EFlagsReportedComplete) != TFlags.EFlagsReportedComplete)
{
iFlags |= TFlags.EFlagsReportedComplete;
EventHandler(this, aEvent);
}
break;
default:
EventHandler(this, aEvent);
break;
}
}
}
public TransitionNode(
TEvent myEvent,
TState state)
{
this.myEvent = myEvent;
this.state = state;
}
public TState Execute(TContext context, TState state, TEvent @event)
{
var transition = _configuration.OnExecute;
// no if here, we do want exception in such case
return(transition(context, state, @event));
}
public void ReportEvent(TEvent aEvent, object aData)
{
if (EventHandler != null)
{
EventHandler(aEvent, this, aData);
}
}
private void NotifyEvent(TEvent aEvent)
{
if (Observer != null)
{
Observer(aEvent);
}
}
private void ReportEvent(TEvent aEvent, SymToken aToken)
{
if (LexerObservers != null)
{
LexerObservers(this, aEvent, aToken);
}
}
private void NotifyEvent(TEvent aEvent)
{
if (iObserver != null)
{
iObserver(aEvent, this);
}
}
public static void FireEvent <TEvent>() where TEvent : BaseMixpanelEvent
{
TEvent expr_05 = Activator.CreateInstance <TEvent>();
BaseMixpanelPeople aCorrespondingPeopleProperty = (BaseMixpanelPeople)Activator.CreateInstance(expr_05.PeopleType);
MixpanelEventSender.FireEvent(expr_05, aCorrespondingPeopleProperty);
}
public bool TryGetNode(
TEvent @event,
out EventNodePersisted <TKey, TState, TEvent, TCtx, TParam, TUserId> eventNode)
{
return(this.eventActLookup.TryGetValue(
@event,
out eventNode));
}
public bool TryGetNode(
TEvent @event,
out EventNode <TState, TEvent, TCtx, TParam> eventNode)
{
return(this.eventActLookup.TryGetValue(
@event,
out eventNode));
}
private void CanRotate(TEvent tEvent)
{
ManualRotate = bool.Parse(tEvent.eventParams[0].ToString());
if (!ManualRotate)
{
AutoRotate = false;
}
}
/// <inheritdoc />
public Task <bool> RaiseAsync(TEvent @event)
{
if (@event is null)
{
throw new ArgumentNullException(nameof(@event));
}
return(_owner.PerformTransitionAsync <Unit, TRelay>(@event, default, _backupValue));
protected TEvent AddEvent <TEvent>()
where TEvent : IDomainEvent, new()
{
var @event = new TEvent();
AddEvent(@event);
return(@event);
}
/// <summary>
/// Initializes a new instance of the <see cref="TransitionDictionary{TState, TEvent}.TransitionInfo"/> class.
/// </summary>
/// <param name="eventId">The event id.</param>
/// <param name="source">The source.</param>
/// <param name="target">The target.</param>
/// <param name="guard">The guard.</param>
/// <param name="actions">The actions.</param>
public TransitionInfo(TEvent eventId, IState <TState, TEvent> source, IState <TState, TEvent> target, IGuardHolder guard, IEnumerable <ITransitionActionHolder> actions)
{
this.EventId = eventId;
this.Source = source;
this.Target = target;
this.Guard = guard;
this.Actions = actions;
}
/// <summary>
/// 设置even
/// </summary>
/// <param name="eventName"></param>
public void SetEventName(string eventName)
{
if (!string.IsNullOrEmpty(eventName))
{
data = new TEvent(eventName);
data.IsUseName = true;
}
}
public void Handle(TEvent evt)
{
if (!(evt is T))
{
throw new ArgumentException("This handler does not support the event type " + evt.GetType().FullName);
}
Handle((T)evt);
}
private void sub_4AA8DC()
{
TEvent Event;
Event = new TEvent(m_PEnvir, m_nCurrX, m_nCurrY, 1, 300000, true);// 5 * 60 * 1000
M2Share.g_EventManager.AddEvent(Event);
m_boFixedHideMode = false;
SendRefMsg(Grobal2.RM_DIGUP, m_btDirection, m_nCurrX, m_nCurrY, Parse(Event), "");
}
public void Trigger(TContext context, TState state, TEvent @event)
{
var trigger = _configuration.OnTrigger;
if (trigger != null)
{
trigger(context, state, @event);
}
}
/// <inheritdoc />
public bool Raise <T>(TEvent @event, T?argument)
{
if (@event is null)
{
throw new ArgumentNullException(nameof(@event));
}
return(_owner.PerformTransitionSync(@event, argument, _backupValue));
}
/// <inheritdoc />
public bool Raise(TEvent @event)
{
if (@event is null)
{
throw new ArgumentNullException(nameof(@event));
}
return(_owner.PerformTransitionSync <Unit, TRelay>(@event, null, _backupValue));
}
public int Send(TEvent @event)
{
foreach (var subscriber in _subscribers)
{
subscriber.Key(@event);
}
return(_subscribers.Count);
}
public void ReportEvent(TEvent aEvent)
{
if (aEvent == TEvent.EReadingComplete)
{
iAlwaysActivatedCollections.BuildLookupCache();
}
ReportEvent(aEvent, null);
}
public bool RaiseAsync <T>(TEvent @event, T?argument)
{
if (@event is null)
{
throw new ArgumentNullException(nameof(@event));
}
return(_owner.RaiseAsyncInternal(@event, argument, _backupValue));
}
/// <summary>
/// Create a new <see cref="Publish"/> message.
/// </summary>
/// <param name="eventMessage">
/// The event message to publish.
/// </param>
public Publish(TEvent eventMessage)
{
if (eventMessage == null)
{
throw new ArgumentNullException(nameof(eventMessage));
}
EventMessage = eventMessage;
}
public OnEvents On <T0>(TEvent @event, Func <T0, bool> guard = default)
{
var onEvents = new OnEvents();
ForEach(s =>
{
onEvents.Add(s.On(@event, guard));
});
return(onEvents);
}
public void Add(TEvent tEvent)
{
repObject.AddEvent(tEvent);
}
public void AddEvent(TEvent tEvent)
{
tEvent.id = nextId++;
events.Add(tEvent);
}
public static extern int TV_GetEvent(ref TEvent ee);
