public void Subscribe(ISingleObserver <T> observer)
{
var parent = new TimeoutObserver(observer, fallback);
observer.OnSubscribe(parent);
parent.SetTask(scheduler.Schedule(parent, timeout, RUN));
source.Subscribe(parent);
}
public void Subscribe(ISignalObserver <T> observer)
{
var parent = new TimeoutObserver(observer, timeout, scheduler, fallback);
observer.OnSubscribe(parent);
parent.StartTimer(0);
source.Subscribe(parent);
}
private void SetTimer(IObservable <TTimeout> timeout, long idx)
{
var timeoutObserver = new TimeoutObserver(this, idx);
if (Disposable.TrySetSerial(ref _timerDisposable, timeoutObserver))
{
var d = timeout.Subscribe(timeoutObserver);
timeoutObserver.SetResource(d);
}
}
/// <summary>
/// 活动处理超时。
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void timeoutObserver_OnTick(object sender, EventArgs e)
{
this.timeoutObserver = null;
if (_state == ActionState.Processing || _state == ActionState.Hangup)
{
ActionTimout();
}
}
/// <summary>
/// 复位运行时数据。
/// </summary>
private void ResetRuntimeData()
{
try
{
_activateTime = null;
_deactivateTime = null;
if (timeoutObserver != null)
{
timeoutObserver.Stop();
timeoutObserver = null;
}
resultEventArgs = null;
faultEventArgs = null;
}
catch
{
//不处理。
}
}
protected override void ClearUnmanagedResources()
{
if (timeoutObserver != null)
{
timeoutObserver.Stop();
timeoutObserver = null;
}
if (light != null)
{
light.Dispose();
light = null;
}
}
/// <summary>
/// 失败。因为存在状态判断，未防止子类覆盖后出现状态漏判，故不允许子类覆盖改方法。
/// </summary>
/// <param name="eventArgs">事件参数</param>
public virtual void Fault(ActionFaultEventArgs eventArgs)
{
if (_state == ActionState.Processing || _state == ActionState.Hangup)
{
_state = ActionState.Fault;
_deactivateTime = DateTime.Now;
if (timeoutObserver != null)
{
timeoutObserver.Stop();
timeoutObserver = null;
}
faultEventArgs = eventArgs;
if (light != null)
{
light.TurnOn();
}
if (OnFault != null)
{
OnFault(this, faultEventArgs);
}
InnerFault(eventArgs);
}
}
/// <summary>
/// 完成。因为存在状态判断，未防止子类覆盖后出现状态漏判，故不允许子类覆盖改方法。
/// </summary>
/// <param name="result"></param>
public void Complete(object result)
{
if (_state == ActionState.Processing || _state == ActionState.Hangup)
{
_state = ActionState.Completed;
_deactivateTime = DateTime.Now;
if (timeoutObserver != null)
{
timeoutObserver.Stop();
timeoutObserver = null;
}
resultEventArgs = new ActionResultEventArgs(this, result);
if (light != null)
{
light.TurnOn();
}
if (OnComplete != null)
{
OnComplete(this, resultEventArgs);
}
InnerComplete(result);
}
}
/// <summary>
/// 异步方式执行活动。
/// </summary>
/// <param name="bWaitForComplete"></param>
/// <returns></returns>
public ActionExecuteResult AsyncExecute(bool bWaitForComplete)
{
try
{
ResetRuntimeData();
_state = ActionState.Processing;
_activateTime = DateTime.Now;
if (bWaitForComplete)
{
light = new LightObject(Guid.NewGuid().ToString("N"), false, false, IntPtr.Zero, null);
InnerExecute();
WaitResult waitResult = light.Wait(_executeTimeout, false);
if (waitResult == WaitResult.TimeOut)
{
ActionTimout();
}
light.Dispose();
light = null;
return new ActionExecuteResult(resultEventArgs, faultEventArgs);
}
else
{
if (_executeTimeout > 0)
{
this.timeoutObserver = new TimeoutObserver();
this.timeoutObserver.OnTick += new EventHandler(timeoutObserver_OnTick);
this.timeoutObserver.Execute(_executeTimeout);
}
InnerExecute();
return null;
}
}
catch (Exception ex)
{
Fault(ActionErrorCodes.UNKNOWN_ERROR, ex);
if (bWaitForComplete)
{
return new ActionExecuteResult(resultEventArgs, faultEventArgs);
}
else
{
return null;
}
}
}
