internal void Add(BeginEventHandler beginHandler, EndEventHandler endHandler, object state)
{
_beginHandlers.Add(beginHandler);
_endHandlers.Add(endHandler);
_stateObjects.Add(state);
_count++;
}
public Stealth(SkillArg arg)
: base(arg.Caster, "Stealth", 6000)
{
this.arg = arg;
OnAdditionStart += new StartEventHandler(Stealth_OnAdditionStart);
OnAdditionEnd += new EndEventHandler(Stealth_OnAdditionEnd);
}
protected void Button1_Click(object sender, EventArgs e)
{
try
{
SetLabel("Connecting...");
#region USING BeginExecuteReader AND EndExecuteReader
//BeginEventHandler begin_hanlder = new BeginEventHandler(BeginExecuteReader);
//EndEventHandler end_handler = new EndEventHandler(EndExecuteReader);
//AddOnPreRenderCompleteAsync(begin_hanlder, end_handler);
#endregion
#region USING BeginExecuteNonQuery AND EndExecuteNonQuery
BeginEventHandler begin_hanlder = new BeginEventHandler(BeginNonQuery);
EndEventHandler end_handler = new EndEventHandler(EndNonQuery);
AddOnPreRenderCompleteAsync(begin_hanlder, end_handler);
#endregion
}
catch (Exception ex)
{
SetLabel("Error: " + ex.Message);
if (connection != null)
{
connection.Close();
}
}
}
public void RegisterAsyncTask(
BeginEventHandler beginHandler,
EndEventHandler endHandler,
EndEventHandler timeoutHandler,
object state)
=> _page.RegisterAsyncTask(
new PageAsyncTask(beginHandler, endHandler, timeoutHandler, state));
private void AttachHandlers()
{
BeginEventHandler bh = new BeginEventHandler( this.BeginLoad );
EndEventHandler eh = new EndEventHandler( this.EndLoad );
AddOnPreRenderCompleteAsync( bh, eh );
}
public Mine(SkillArg arg)
: base(arg.Caster, "Mine", 10000)
{
this.arg = arg;
OnAdditionStart += new StartEventHandler(Mine_OnAdditionStart);
OnAdditionEnd += new EndEventHandler(Mine_OnAdditionEnd);
}
private void AttachHandlers()
{
BeginEventHandler bh = new BeginEventHandler( this.BeginLoad );
EndEventHandler eh = new EndEventHandler( this.EndLoad );
AddOnPreRenderCompleteAsync( bh, eh );
}
public void Test1()
{
BeginEventHandler beginEventHandler = default(BeginEventHandler);
EndEventHandler endEventHandler = default(EndEventHandler);
IAsyncResult iAsyncResult = default(IAsyncResult);
var mockHttpApplication = new Mock <HttpApplication>();
mockHttpApplication.Setup(m =>
m.AddOnBeginRequestAsync(It.IsAny <BeginEventHandler>(), It.IsAny <EndEventHandler>()))
.Callback <BeginEventHandler, EndEventHandler>((beginEventHandlerTmp, endEventHandlerTMp)
=>
{
beginEventHandler = beginEventHandlerTmp;
endEventHandler = endEventHandlerTMp;
});
mockHttpApplication.Setup(m =>
((IHttpAsyncHandler)m).BeginProcessRequest(It.IsAny <HttpContext>(), null, null))
.Callback <HttpApplication>((appTmp) =>
{
iAsyncResult = beginEventHandler(null, null, null, null);
});
mockHttpApplication.Setup(m =>
((IHttpAsyncHandler)m).EndProcessRequest(iAsyncResult))
.Callback <HttpApplication>((appTmp) =>
{
endEventHandler(iAsyncResult);
});
var httpApplicationModel = new HttpApplication();
IHttpModule iHttpModule = new StartUpHttpModule();
var listLog = new List <string> {
};
var starterModel = new Starter <IList <string> >(
httpApplication =>
{
listLog.Add("InitStarter");
return(listLog);
},
(httpApplication, logInput) => { logInput.Add("BeginBeginResult"); },
(httpApplication, logInput) => { logInput.Add("BeginEndResult"); }
);
starterModel.OnApplicationStart(httpApplicationModel);
iHttpModule.Init(httpApplicationModel);
var asyncResult = ((IHttpAsyncHandler)httpApplicationModel).BeginProcessRequest(httpApplicationModel.Context, null, null);
starterModel.OnBeginRequest(httpApplicationModel);
((IHttpAsyncHandler)httpApplicationModel).EndProcessRequest(asyncResult);
starterModel.OnEndRequest(httpApplicationModel);
Assert.True(listLog[0] == "InitStarter");
Assert.True(listLog[1] == "BeginBeginResult");
Assert.True(listLog[2] == "BeginEndResult");
}
internal AsyncEventExecutionStep(NetHttpApplication app, BeginEventHandler beginHandler, EndEventHandler endHandler, object state)
{
_application = app;
_beginHandler = beginHandler;
_endHandler = endHandler;
_state = state;
_completionCallback = new AsyncCallback(OnAsyncEventCompletion);
}
public Teleport(SkillArg arg, Dictionary <SagaBNS.Common.Item.Item, ushort> items)
: base(arg.Caster, "Teleport", 10000)
{
this.arg = arg;
this.items = items;
OnAdditionStart += new StartEventHandler(Teleport_OnAdditionStart);
OnAdditionEnd += new EndEventHandler(Teleport_OnAdditionEnd);
}
public void RegisterAsyncTask(
BeginEventHandler beginHandler,
EndEventHandler endHandler,
EndEventHandler timeoutHandler,
object state,
bool executeInParallel)
=> _page.RegisterAsyncTask(
new PageAsyncTask(beginHandler, endHandler, timeoutHandler, state, executeInParallel));
public Repair(SkillArg arg, Dictionary <SagaBNS.Common.Item.Item, ushort> items)
: base(arg.Caster, "Repair", 7500)
{
this.arg = arg;
this.items = items;
OnAdditionStart += new StartEventHandler(Repair_OnAdditionStart);
OnAdditionEnd += new EndEventHandler(Repair_OnAdditionEnd);
}
public Frost(SkillArg arg, ActorExt target)
: base(target, "Frost", 6400)
{
this.arg = arg;
this.target = target;
OnAdditionStart += new StartEventHandler(Frost_OnAdditionStart);
OnAdditionEnd += new EndEventHandler(Frost_OnAdditionEnd);
}
protected virtual void OnEndEvent()
{
EndEventHandler handler = EndEvent;
if (handler != null)
{
handler(this);
}
}
private void GetPage()
{
BeginEventHandler beh = new BeginEventHandler(BeginAsync);
EndEventHandler eeh = new EndEventHandler(EndAsync);
PageAsyncTask pat = new PageAsyncTask(beh, eeh, null, null, true);
this.RegisterAsyncTask(pat);
this.ExecuteRegisteredAsyncTasks();
}
public PageAsyncTask (BeginEventHandler beginHandler, EndEventHandler endHandler,
EndEventHandler timeoutHandler, Object state, bool executeInParallel)
{
this.beginHandler = beginHandler;
this.endHandler = endHandler;
this.timeoutHandler = timeoutHandler;
this.state = state;
this.executeInParallel = executeInParallel;
}
public PageAsyncTask(BeginEventHandler beginHandler, EndEventHandler endHandler,
EndEventHandler timeoutHandler, Object state, bool executeInParallel)
{
this.beginHandler = beginHandler;
this.endHandler = endHandler;
this.timeoutHandler = timeoutHandler;
this.state = state;
this.executeInParallel = executeInParallel;
}
internal LegacyPageAsyncTask(BeginEventHandler beginHandler, EndEventHandler endHandler, EndEventHandler timeoutHandler, Object state, bool executeInParallel) {
// Parameter checking is done by the public PageAsyncTask constructor
_beginHandler = beginHandler;
_endHandler = endHandler;
_timeoutHandler = timeoutHandler;
_state = state;
_executeInParallel = executeInParallel;
}
internal LegacyPageAsyncTask(BeginEventHandler beginHandler, EndEventHandler endHandler, EndEventHandler timeoutHandler, Object state, bool executeInParallel)
{
// Parameter checking is done by the public PageAsyncTask constructor
_beginHandler = beginHandler;
_endHandler = endHandler;
_timeoutHandler = timeoutHandler;
_state = state;
_executeInParallel = executeInParallel;
}
public ActorFrosen(SkillArg arg, ActorExt target, uint additionID, int damage = 0, int duration = 5000)
: base(target, "ActorFrosen", duration)
{
this.arg = arg;
this.target = target;
this.additionID = additionID;
this.damage = damage;
OnAdditionStart += new StartEventHandler(ActorFrosen_OnAdditionStart);
OnAdditionEnd += new EndEventHandler(ActorFrosen_OnAdditionEnd);
}
public void Init(HttpApplication context)
{
if (beginEventHandler == null)
{
beginEventHandler = new BeginEventHandler(ServiceHttpModule.BeginProcessRequest);
}
if (endEventHandler == null)
{
endEventHandler = new EndEventHandler(ServiceHttpModule.EndProcessRequest);
}
context.AddOnPostAuthenticateRequestAsync(beginEventHandler, endEventHandler);
}
public FireSelf(SkillArg arg)
: base(arg.Caster, "FireSelf", 10000)
{
this.arg = arg;
if (arg.Caster.Tasks.TryGetValue("FireSelf", out Task task))
{
task.Deactivate();
}
arg.Caster.Tasks["FireSelf"] = this;
OnAdditionStart += new StartEventHandler(Fire_OnAdditionStart);
OnAdditionEnd += new EndEventHandler(Fire_OnAdditionEnd);
}
private void AddAsyncEventHandlers <TEventArgs>(Action <BeginEventHandler, EndEventHandler, object> addAsyncEvent, Func <ModularityModule, RequestEventHandler <TEventArgs> > getEvent, Func <TEventArgs> getArgs)
where TEventArgs : EventArgs
{
foreach (var handler in Modules.Where(m => m.IsAsync).Select(m => getEvent(m)).Where(e => e != null))
{
BeginEventHandler begin = CreateBeginEventHandler <TEventArgs>(handler, getArgs);
EndEventHandler end = result =>
{
};
addAsyncEvent(begin, end, handler);
}
}
public DieTask(GameSession client)
: base(client.Character, "DieTask", 80000)
{
this.client = client;
OnAdditionStart += new StartEventHandler(DieTask_OnAdditionStart);
OnAdditionEnd += new EndEventHandler(DieTask_OnAdditionEnd);
if (client.Character.Tasks.TryRemove("DieTask", out Task removed))
{
removed.Deactivate();
}
}
public MovementLock(GameSession client, int lockDuration)
: base(client.Character, "MovementLock", lockDuration)
{
this.client = client;
if (client.Character.Tasks.TryGetValue("MovementLock", out Task task))
{
task.Deactivate();
}
client.Character.Tasks["MovementLock"] = this;
OnAdditionStart += new StartEventHandler(MovementLock_OnAdditionStart);
OnAdditionEnd += new EndEventHandler(MovementLock_OnAdditionEnd);
}
public Suicide(SkillArg arg, ActorExt target, uint additionID)
: base(target, "Suicide", 1000)
{
this.arg = arg;
this.target = target;
this.additionID = additionID;
if (target.Tasks.TryGetValue("Suicide", out Task task))
{
task.Deactivate();
}
target.Tasks["Suicide"] = this;
OnAdditionEnd += new EndEventHandler(ActorFrosen_OnAdditionEnd);
}
public Poisening(SkillArg arg)
: base(arg.Caster, "Poisening", 30000)
{
this.arg = arg;
if (arg.Caster.Tasks.TryRemove("Poisening", out Task removed))
{
removed.Deactivate();
}
arg.Caster.Tasks["Poisening"] = this;
OnAdditionStart += new StartEventHandler(Poisening_OnAdditionStart);
OnAdditionEnd += new EndEventHandler(Poisening_OnAdditionEnd);
}
public void Init(HttpApplication context)
{
if (ServiceHttpModule.beginEventHandler == null)
{
ServiceHttpModule.beginEventHandler = new BeginEventHandler(BeginProcessRequest);
}
if (ServiceHttpModule.endEventHandler == null)
{
ServiceHttpModule.endEventHandler = new EndEventHandler(EndProcessRequest);
}
context.AddOnPostAuthenticateRequestAsync(
ServiceHttpModule.beginEventHandler,
ServiceHttpModule.endEventHandler);
}
public WoodBlock(SkillArg arg)
: base(arg.Caster, "WoodBlock", 1500)
{
this.arg = arg;
if (arg.Caster.Tasks.TryRemove("WoodBlock", out Task removed))
{
removed.Deactivate();
}
arg.Caster.Tasks["WoodBlock"] = this;
CounterSkillID = 15116;
OnAdditionStart += new StartEventHandler(WoodBlock_OnAdditionStart);
OnAdditionEnd += new EndEventHandler(WoodBlock_OnAdditionEnd);
}
public CounterSelf(SkillArg arg, int lifeTime)
: base(arg.Caster, "CounterSelf", lifeTime)
{
this.arg = arg;
if (arg.Caster.Tasks.TryGetValue("CounterSelf", out Task task))
{
task.Deactivate();
}
arg.Caster.Tasks["CounterSelf"] = this;
OnAdditionStart += new StartEventHandler(CounterEnemy_OnAdditionStart);
OnAdditionEnd += new EndEventHandler(CounterEnemy_OnAdditionEnd);
}
protected void Start_Clicked(object sender, EventArgs e)
{
ProgressLabel.Text = "Page_Load: thread #" + System.Threading.Thread.CurrentThread.GetHashCode();
BeginEventHandler bh = new BeginEventHandler(this.BeginGetAsyncData);
EndEventHandler eh = new EndEventHandler(this.EndGetAsyncData);
AddOnPreRenderCompleteAsync(bh, eh);
// Initialize the WebRequest.
string address = "http://localhost/";
myRequest = System.Net.WebRequest.Create(address);
}
public ActorItemPickDropTask(ActorPC pc, ActorExt item, ActionTypes action)
: base(pc, "ActorItemPickDropTask", 400)
{
this.pc = pc;
this.item = item;
this.action = action;
OnAdditionStart += new StartEventHandler(ActorItemPickDropTask_OnAdditionStart);
OnAdditionEnd += new EndEventHandler(ActorItemPickDropTask_OnAdditionEnd);
if (pc.Tasks.TryRemove("ActorItemPickDropTask", out Task removed))
{
removed.Deactivate();
}
}
public Stun(SkillArg arg, ActorExt target, int lifeTime)
: base(target, "Stun", lifeTime)
{
this.arg = arg;
this.target = target;
if (target.Tasks.TryGetValue("Stun", out Task task))
{
task.Deactivate();
}
target.Tasks["Stun"] = this;
OnAdditionStart += new StartEventHandler(ActorDown_OnAdditionStart);
OnAdditionEnd += new EndEventHandler(ActorDown_OnAdditionEnd);
}
public CounterEnemy(SkillArg arg)
: base(arg.Caster, "CounterEnemy", arg.Skill.BaseData.Duration)
{
this.arg = arg;
CounterSkillID = 11104;
if (arg.Caster.Tasks.TryGetValue("CounterEnemy", out Task task))
{
task.Deactivate();
}
arg.Caster.Tasks["CounterEnemy"] = this;
OnAdditionStart += new StartEventHandler(CounterEnemy_OnAdditionStart);
OnAdditionEnd += new EndEventHandler(CounterEnemy_OnAdditionEnd);
}
public static EndEventHandler BuildSyncContextCallback(EndEventHandler callback)
{
SynchronizationContext sc = SynchronizationContext.Current;
if (sc == null)
{
return callback;
}
return ar =>
{
sc.Post(obj =>
{
callback((IAsyncResult)obj);
}, ar);
};
}
public PageAsyncTask(BeginEventHandler beginHandler, EndEventHandler endHandler, EndEventHandler timeoutHandler, object state, bool executeInParallel)
{
if (beginHandler == null)
{
throw new ArgumentNullException("beginHandler");
}
if (endHandler == null)
{
throw new ArgumentNullException("endHandler");
}
this._beginHandler = beginHandler;
this._endHandler = endHandler;
this._timeoutHandler = timeoutHandler;
this._state = state;
this._executeInParallel = executeInParallel;
}
public Poisen(SkillArg arg, ActorExt target, uint additionID, int damage = 0, int duration = 5000)
: base(target, "Poisen", duration, 2000)
{
this.arg = arg;
this.target = target;
this.additionID = additionID;
this.damage = damage;
if (target.Tasks.TryGetValue("Poisen", out Task task))
{
task.Deactivate();
}
target.Tasks["Poisen"] = this;
OnAdditionStart += new StartEventHandler(ActorFrosen_OnAdditionStart);
OnAdditionEnd += new EndEventHandler(ActorFrosen_OnAdditionEnd);
OnUpdate += new UpdateEventHandler(Poisen_OnUpdate);
}
// APM
internal PageAsyncTask(BeginEventHandler beginHandler, EndEventHandler endHandler, EndEventHandler timeoutHandler, Object state, bool executeInParallel, SynchronizationContextMode currentMode) {
if (beginHandler == null) {
throw new ArgumentNullException("beginHandler");
}
if (endHandler == null) {
throw new ArgumentNullException("endHandler");
}
// Only the legacy PageAsyncTaskManager supports timing out APM methods or executing them in parallel
if (timeoutHandler != null || executeInParallel) {
SynchronizationContextUtil.ValidateMode(currentMode, requiredMode: SynchronizationContextMode.Legacy, specificErrorMessage: SR.SynchronizationContextUtil_PageAsyncTaskTimeoutHandlerParallelNotCompatible);
}
BeginHandler = beginHandler;
EndHandler = endHandler;
TimeoutHandler = timeoutHandler;
State = state;
ExecuteInParallel = executeInParallel;
}
private void DoAsync()
{
if (IsAsync)
{
Session["Halted"] = false;
Timer1.Enabled = true;
var asyncHandler = new AsyncHandler(Context);
asyncHandler.NotifyHaltHandler += Halted;
asyncHandler.NotifyLogger += Logger;
BeginEventHandler bh = new BeginEventHandler(asyncHandler.BeginProcessRequest);
EndEventHandler eh = new EndEventHandler(asyncHandler.EndProcessRequest);
AddOnPreRenderCompleteAsync(bh, eh);
// Initialize the WebRequest.
string address = "http://localhost/";
asyncHandler.WebRequest = System.Net.WebRequest.Create(address);
}
GC.Collect();
GC.WaitForPendingFinalizers();
}
public void AddOnPreRequestHandlerExecuteAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, object state) {}
public void AddOnAcquireRequestStateAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, object state) {}
public void AddOnAcquireRequestStateAsync(BeginEventHandler bh, EndEventHandler eh) {}
public void AddOnMapRequestHandlerAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, Object state) {
if (!HttpRuntime.UseIntegratedPipeline) {
throw new PlatformNotSupportedException(SR.GetString(SR.Requires_Iis_Integrated_Mode));
}
AsyncEvents.AddHandler(EventMapRequestHandler, beginHandler, endHandler, state,
RequestNotification.MapRequestHandler, false, this);
}
public void AddOnBeginRequestAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, object state) {}
public void AddOnPostUpdateRequestCacheAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, object state) {}
public void AddOnPostReleaseRequestStateAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, object state) {}
public void AddOnPostAuthorizeRequestAsync(BeginEventHandler bh, EndEventHandler eh) {}
public void AddOnAuthenticateRequestAsync(BeginEventHandler bh, EndEventHandler eh) {}
public void AddOnPreRenderCompleteAsync (BeginEventHandler beginHandler, EndEventHandler endHandler, Object state)
{
if (!IsAsync) {
throw new InvalidOperationException ("AddOnPreRenderCompleteAsync called and Page.IsAsync == false");
}
if (IsPrerendered) {
throw new InvalidOperationException ("AddOnPreRenderCompleteAsync can only be called before and during PreRender.");
}
if (beginHandler == null) {
throw new ArgumentNullException ("beginHandler");
}
if (endHandler == null) {
throw new ArgumentNullException ("endHandler");
}
RegisterAsyncTask (new PageAsyncTask (beginHandler, endHandler, null, state, false));
}
public void AddOnPreRenderCompleteAsync (BeginEventHandler beginHandler, EndEventHandler endHandler)
{
AddOnPreRenderCompleteAsync (beginHandler, endHandler, null);
}
public void AddOnPostMapRequestHandlerAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, Object state) {
AsyncEvents.AddHandler(EventPostMapRequestHandler, beginHandler, endHandler, state,
RequestNotification.MapRequestHandler, true, this);
}
public void AddOnPostRequestHandlerExecuteAsync(BeginEventHandler bh, EndEventHandler eh) {}
public void AddOnPostReleaseRequestStateAsync(BeginEventHandler bh, EndEventHandler eh) {}
public void AddOnPostAuthorizeRequestAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, object state) {}
public void AddOnPostUpdateRequestCacheAsync(BeginEventHandler bh, EndEventHandler eh) {}
public void AddOnResolveRequestCacheAsync(BeginEventHandler bh, EndEventHandler eh) {}
public void AddOnBeginRequestAsync(BeginEventHandler bh, EndEventHandler eh) {}
public void AddOnPostMapRequestHandlerAsync(BeginEventHandler bh, EndEventHandler eh) {}
public void AddOnPostMapRequestHandlerAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, object state) {}
public void AddOnMapRequestHandlerAsync(BeginEventHandler bh, EndEventHandler eh) {
if (!HttpRuntime.UseIntegratedPipeline) {
throw new PlatformNotSupportedException(SR.GetString(SR.Requires_Iis_Integrated_Mode));
}
AddOnMapRequestHandlerAsync(bh, eh, null);
}
