public static void Load()
{
if (File.Exists(RankingPath))
{
int index = 0;
using (Stream stream = new FileStream(RankingPath, FileMode.Open, FileAccess.Read))
{
using (TextReader reader = new StreamReader(stream))
{
for (int i = 0; i < 3; ++i)
{
string elapsed = reader.ReadLine();
string recorded = reader.ReadLine();
rank [index++] = new Elapsed()
{
ElapsedTime = TimeSpan.FromTicks(int.Parse(elapsed)),
Recorded = DateTime.Parse(recorded)
};
}
}
}
Debug.Log("Ranking file loaded from " + RankingPath);
}
}
private void TimerElapsedHandler(object sender, ElapsedEventArgs e)
{
_updateTime = _updateTime.AddDays(1.0);
CalculateTimerInterval();
Elapsed?.Invoke(sender, e);
}
/// <summary>
/// This method is called by _taskTimer.
/// </summary>
/// <param name="state">Not used argument</param>
private void TimerCallBack(object state)
{
lock (_taskTimer)
{
if (!_isRunning || _performingTasks)
{
return;
}
_taskTimer.Change(Timeout.Infinite, Timeout.Infinite);
_performingTasks = true;
}
try
{
Elapsed?.Invoke(this, new EventArgs());
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
lock (_taskTimer)
{
_performingTasks = false;
if (_isRunning)
{
_taskTimer.Change(Period, Timeout.Infinite);
}
Monitor.Pulse(_taskTimer);
}
}
}
IEnumerator DespawnTimeout(float seconds)
{
yield return(new WaitForSeconds(seconds));
Elapsed?.Invoke(this);
GameObject.Destroy(gameObject);
}
public override bool OnIntervalClose()
{
if (Next.Position.IsFlat || Next.Position.IsLong)
{
diff[0] = Bars.Typical[0] - slowAvg[0];
if (diff[0] < -lowTrigger)
{
Orders.Enter.ActiveNow.BuyMarket();
}
if (diff[0] > highTrigger)
{
Orders.Exit.ActiveNow.GoFlat();
}
Elapsed span = Position.Time - Bars.Time[0];
if (span.TotalHours > maxHours)
{
Orders.Exit.ActiveNow.GoFlat();
}
}
else
{
Orders.Exit.ActiveNow.GoFlat();
}
return(true);
}
public void Tick()
{
if (Enabled)
{
Elapsed?.Invoke(0, 0);
}
}
private void ThreadMain()
{
float nextNotification = 0;
float elapsedMilliseconds;
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
while (this.runTimer)
{
nextNotification += Interval;
while ((elapsedMilliseconds = (float)stopWatch.Elapsed.TotalMilliseconds)
< nextNotification)
{
Thread.Yield();
}
if (elapsedMilliseconds - nextNotification >= IgnoreEventIfLateBy)
{
continue;
}
Elapsed?.Invoke();
}
stopWatch.Stop();
}
/// <summary>
/// _taskTimer调用
/// </summary>
/// <param name="state">暂未使用该参数</param>
private void TimerCallBack(object state)
{
lock (_taskTimer) {
if (!_isRunning || _performingTasks)
{
return;
}
_taskTimer.Change(Timeout.Infinite, Timeout.Infinite);
_performingTasks = true;
}
try {
Elapsed.InvokeSafely(this, new EventArgs());
} catch (Exception ex) {
Logger.LogException(ex);
AsyncHelper.RunSync(() => ExceptionNotifier.NotifyAsync(ex));
} finally {
lock (_taskTimer) {
_performingTasks = false;
if (_isRunning)
{
_taskTimer.Change(Period, Timeout.Infinite);
}
Monitor.Pulse(_taskTimer);
}
}
}
/// <summary>
/// This method is called by _taskTimer.
/// </summary>
/// <param name="state">Not used argument</param>
private void TimerCallBack(object state)
{
lock (_timer)
{
if (!_isRunning || _performingTasks)
{
return;
}
_timer.Change(Timeout.Infinite, Timeout.Infinite);
_performingTasks = true;
}
try
{
Elapsed.InvokeSafely(this, new EventArgs());
}
catch
{
}
finally
{
lock (_timer)
{
_performingTasks = false;
if (_isRunning)
{
_timer.Change(Period, Timeout.Infinite);
}
Monitor.Pulse(_timer);
}
}
}
public void ElapsedAction()
{
if (Elapsed != null)
{
Elapsed.Invoke(this, null);
}
}
private void OnElapsed(object source, ElapsedEventArgs e)
{
Elapsed?.Invoke(this, EventArgs.Empty);
// reset timer in case we modified it by Delay
timer.Interval = interval;
}
private void TimerCallBack(object state)
{
lock (_taskTimer) {
if (!_running || _performingTasks)
{
return;
}
_taskTimer.Change(Timeout.Infinite, Timeout.Infinite);
_performingTasks = true;
}
var elapsedEventArgs = state as ElapsedEventArgs;
try {
Elapsed?.Invoke(this, elapsedEventArgs);
} catch (Exception e) {
Console.WriteLine(e);
} finally {
lock (_taskTimer) {
_performingTasks = false;
if (_running)
{
_taskTimer.Change(Period, Timeout.Infinite);
}
Monitor.Pulse(_taskTimer);
}
}
}
/// <summary>
/// This method is called by _taskTimer.
/// </summary>
/// <param name="state">Not used argument</param>
private void timerCallBack(object state)
{
lock (_lock)
{
if (!_running || _performingTasks)
{
return;
}
_taskTimer.Change(Timeout.Infinite, Timeout.Infinite);
_performingTasks = true;
}
try
{
Elapsed?.Invoke(this, EventArgs.Empty);
}
finally
{
lock (_lock)
{
_performingTasks = false;
if (_running)
{
_taskTimer.Change(Period, Timeout.Infinite);
}
Monitor.Pulse(_taskTimer);
}
}
}
/// <summary>
/// This method is called by _taskTimer.
/// </summary>
/// <param name="state">Not used argument</param>
private void TimerCallBack(object state)
{
_taskTimer.Locking(t =>
{
if (!_isRunning || _performingTasks)
{
return;
}
t.Change(Timeout.Infinite, Timeout.Infinite);
_performingTasks = true;
}
);
try
{
Elapsed.Invoke(this, new EventArgs());
}
catch
{
//do nothing.
}
finally
{
_taskTimer.Locking(t =>
{
_performingTasks = false;
if (_isRunning)
{
t.Change(Period, Timeout.Infinite);
}
Monitor.Pulse(_taskTimer);
});
}
}
private void Callback(object state)
{
lock (this) {
_tickCount++;
Elapsed?.Invoke(this, TimeSpan.FromMilliseconds(_tickCount * Period.TotalMilliseconds));
var elapsed = DateTime.Now - _startAt;
var millisShouldBe = _tickCount * Period.TotalMilliseconds;
var millisIs = elapsed.TotalMilliseconds;
var timeDiff = millisShouldBe - millisIs;
if (timeDiff > Period.TotalMilliseconds)
{
timeDiff = Period.TotalMilliseconds;
}
if (timeDiff < -Period.TotalMilliseconds)
{
timeDiff = -Period.TotalMilliseconds;
}
if (_enabled)
{
_timer.Change(
(int)(Period.TotalMilliseconds + timeDiff),
(int)Period.TotalMilliseconds
);
}
}
}
async void OnElapsed(object context)
{
if (!this.stopGuard.TryLock())
{
return;
}
try
{
await Elapsed.InvokeAsync(this, new TimerElapsedEventArgs(context, CancellationToken.None));
}
finally
{
Interlocked.Increment(ref this.elapsed);
this.stopGuard.Release();
// Try to change one-shot state to 3 (stopping by inside) only if it is 1 (one-shot not fired). If the
// current value is 1 that mean this method have responsibility to clean up resources.
if (Interlocked.CompareExchange(ref this.oneShotState, 3, 1) == 1)
{
Stop();
}
}
}
public Timer()
{
base.Elapsed += (o, e) =>
{
Elapsed?.Invoke(this, EventArgs.Empty);
};
}
private void ThreadLoop()
{
while (_threadLoopEnabled)
{
// If we are not enabled, or we have more than the CoarseSleepThreshold ms left until we need to invoke, sleep for 1 ms
while (_threadLoopEnabled &&
(!_elapsedEventEnabled ||
_stopwatch.ElapsedMilliseconds + CoarseSleepThreshold < _nextInvoke))
{
Thread.Sleep(1);
}
// If we are not yet ready to invoke, then be kind to other threads & let them have some pie, but don't sleep as we are close
while (_threadLoopEnabled && _stopwatch.ElapsedMilliseconds < _nextInvoke)
{
Thread.Sleep(0);
}
if (_threadLoopEnabled && _elapsedEventEnabled)
{
long time = _stopwatch.ElapsedMilliseconds;
this.TimeSinceLastTick = time - _lastTick;
_lastTick = time;
Elapsed?.Invoke(null, null);
_nextInvoke = time + (int)this.Interval;
}
}
}
private void ElapsedThreadProc()
{
while (true)
{
m_waitHandle.WaitOne();
if (m_disposing)
{
return;
}
ElapsedEventArgs eea = new ElapsedEventArgs(DateTime.Now);
if (Elapsed != null)
{
foreach (ElapsedEventHandler eeh in Elapsed.GetInvocationList())
{
// determine if we're supposed to Invoke or not
if (SynchronizingObject == null)
{
eeh(this, eea);
}
else
{
SynchronizingObject.Invoke(eeh, new object[] { this, eea });
}
}
}
}
}
/// <summary>
/// If there are any subscribers - raise the Elapsed event.
/// </summary>
/// <param name="sender">the sender to include within the event's event-args</param>
internal void InvokeElapsed(object sender)
{
if (Elapsed != null)
{
Elapsed.Invoke(sender, m_timerEventArgs);
}
}
public void Update(long deltaTime)
{
// Nothing to do
if (!IsActive)
{
return;
}
// Decrement remaining time
if (Remaining > 0)
{
Remaining -= deltaTime;
}
if (Remaining <= 0)
{
// No more remaining time for this slice
--Value;
Elapsed?.Invoke(this, EventArgs.Empty);
if (Value != 0)
{
// Subtract current remaining time from specified interval because it can be negative
Remaining = Interval - Remaining;
}
else
{
// We're done!
Stopped?.Invoke(this, EventArgs.Empty);
Remaining = 0;
}
}
}
private void AdjustSessions()
{
foreach (var kvp in symbolMap)
{
string symbol = kvp.Key;
SymbolProperties symbolProperties = kvp.Value;
if (symbolProperties.TimeZone == null || symbolProperties.TimeZone.Length == 0)
{
continue;
}
if (symbolProperties.DisplayTimeZone == "Local" ||
symbolProperties.DisplayTimeZone == "UTC")
{
// Convert session times from Exchange to UTC.
SymbolTimeZone timeZone = new SymbolTimeZone(symbolProperties);
timeZone.SetExchangeTimeZone();
int startOffset = (int)timeZone.UtcOffset(new TimeStamp());
int endOffset = (int)timeZone.UtcOffset(new TimeStamp());
Elapsed utcSessionStart = symbolProperties.SessionStart - new Elapsed(0, 0, startOffset);
Elapsed utcSessionEnd = symbolProperties.SessionEnd - new Elapsed(0, 0, endOffset);
// Convert UTCI session times to either Local or UTC as chosen
// by the DisplayTimeZone property.
timeZone = new SymbolTimeZone(symbolProperties);
startOffset = (int)timeZone.UtcOffset(new TimeStamp());
endOffset = (int)timeZone.UtcOffset(new TimeStamp());
symbolProperties.SessionStart = utcSessionStart + new Elapsed(0, 0, startOffset);
symbolProperties.SessionEnd = utcSessionEnd + new Elapsed(0, 0, endOffset);
}
}
}
private void Timer_Elapsed(object sender, ElapsedEventArgs e)
{
Elapsed = Elapsed.Add(TimeSpan.FromSeconds(1));
if (CurrentActivity == Activity.Working && Elapsed.TotalSeconds >= config.Working * 60)
{
AddHistory(Elapsed.TotalMinutes, true);
pomodoros++;
if (pomodoros == config.Pomorodos)
{
ChangeState(Activity.LongBreak);
}
else
{
ChangeState(Activity.ShortBreak);
}
}
if ((CurrentActivity == Activity.ShortBreak && Elapsed.TotalSeconds >= config.ShortBreak * 60) ||
(CurrentActivity == Activity.LongBreak && Elapsed.TotalSeconds >= config.LongBreak * 60))
{
AddHistory(Elapsed.TotalMinutes, false);
ChangeState(Activity.Working);
}
}
/// <summary>
/// Actual deconstructor in accordance with the dispose pattern
/// </summary>
/// <param name="disposing">
/// True if managed and unmanaged resources will be freed
/// (otherwise only unmanaged resources are handled)
/// </param>
protected virtual void Dispose(bool disposing)
{
if (!disposed)
{
disposed = true;
if (disposing)
{
Delegate[] delegateBuffer = null;
monitorTimer.Elapsed -= new ElapsedEventHandler(TimerElapsed);
monitorTimer.Dispose();
delegateBuffer = Elapsed.GetInvocationList();
foreach (ElapsedEventHandler item in delegateBuffer)
{
Elapsed -= item;
}
Elapsed = null;
delegateBuffer = Reactivated.GetInvocationList();
foreach (EventHandler item in delegateBuffer)
{
Reactivated -= item;
}
Reactivated = null;
}
}
}
public override bool OnProcessTick(Tick tick)
{
Elapsed ts = tick.Time - Range5.Time[0];
equity[0] = Performance.Equity.CurrentEquity;
return(true);
}
public unsafe void Start()
{
lock (stateLock)
{
if (!Enabled)
{
if (IsSupportedNatively(Interval))
{
var caps = new TimeCaps();
_ = timeGetDevCaps(ref caps, (uint)sizeof(TimeCaps));
var clampedInterval = Math.Clamp((uint)Interval, caps.wPeriodMin, caps.wPeriodMax);
_ = timeBeginPeriod(clampedInterval);
timerId = timeSetEvent(clampedInterval, 1, callbackDelegate, IntPtr.Zero, EventType.TIME_PERIODIC | EventType.TIME_KILL_SYNCHRONOUS);
Enabled = true;
}
else
{
Log.Write("Timer", "Unsupported interval detected, will use fallback timer. Expect high CPU usage", LogLevel.Warning);
fallbackTimer = new FallbackTimer
{
Interval = Interval
};
fallbackTimer.Elapsed += () => Elapsed?.Invoke();
fallbackTimer.Start();
Enabled = true;
}
}
}
}
private void ExecuteTimer()
{
float nextTrigger = 0f;
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
while (isRunning)
{
nextTrigger += interval;
float elapsed;
while (true)
{
elapsed = ElapsedHiRes(stopwatch);
float diff = nextTrigger - elapsed;
if (diff <= 0f)
{
break;
}
if (diff < 1f)
{
Thread.SpinWait(10);
}
else if (diff < 5f)
{
Thread.SpinWait(100);
}
else if (diff < 15f)
{
Thread.Sleep(1);
}
else
{
Thread.Sleep(10);
}
if (!isRunning)
{
return;
}
}
float delay = elapsed - nextTrigger;
Elapsed?.Invoke(delay);
// restarting the timer in every hour to prevent precision problems
if (stopwatch.Elapsed.TotalHours >= 1d)
{
stopwatch.Restart();
nextTrigger = 0f;
}
}
stopwatch.Stop();
}
private void baseElapsed(object sender, object e)
{
if (!AutoReset)
{
Stop();
}
Elapsed?.Invoke(this, new EventArgs());
}
public void Tick()
{
if ((Time -= GameTime.DeltaTime) <= 0)
{
Time += Interval;
Elapsed.Invoke(this, new TimerElapsedEventArgs());
}
}
public new void Start()
{
Stopped = false;
if (!EnableOverride && Enabled && Elapsed != null)
{
Elapsed.Invoke(this, new EventArgs() as ElapsedEventArgs);
}
}
