mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
211 lines
6.7 KiB
C#
211 lines
6.7 KiB
C#
//----------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//----------------------------------------------------------------
|
|
|
|
namespace System.ServiceModel.Discovery
|
|
{
|
|
using System.Runtime;
|
|
using System.Threading;
|
|
using System.Collections.Generic;
|
|
|
|
abstract class RandomDelayQueuedSendsAsyncResult<TItem> :
|
|
IteratorAsyncResult<RandomDelayQueuedSendsAsyncResult<TItem>>
|
|
where TItem : class
|
|
{
|
|
readonly InputQueue<TItem> itemQueue;
|
|
readonly Random random;
|
|
readonly double maxRandomDelayInMillis;
|
|
readonly int[] preCalculatedDelays;
|
|
readonly bool doDelay;
|
|
|
|
static AsyncStep dequeueStep;
|
|
static AsyncStep delayStep;
|
|
static AsyncStep sendItemStep;
|
|
|
|
TItem currentItem;
|
|
int currentDelayIndex;
|
|
|
|
public RandomDelayQueuedSendsAsyncResult(
|
|
TimeSpan maxRandomDelay,
|
|
InputQueue<TItem> itemQueue,
|
|
AsyncCallback callback,
|
|
object state)
|
|
: base(callback, state)
|
|
{
|
|
Fx.Assert(maxRandomDelay >= TimeSpan.Zero, "The maxRandomDelay parameter must be non negative.");
|
|
Fx.Assert(itemQueue != null, "The itemQueue parameter must be non null.");
|
|
|
|
this.itemQueue = itemQueue;
|
|
|
|
this.doDelay = maxRandomDelay > TimeSpan.Zero;
|
|
if (this.doDelay)
|
|
{
|
|
this.random = new Random();
|
|
this.maxRandomDelayInMillis = maxRandomDelay.TotalMilliseconds;
|
|
|
|
if (this.itemQueue.PendingCount > 0)
|
|
{
|
|
this.preCalculatedDelays = new int[this.itemQueue.PendingCount];
|
|
this.PreCalculateSendDelays();
|
|
}
|
|
}
|
|
}
|
|
|
|
public IAsyncResult BeginDelay(AsyncCallback callback, object state)
|
|
{
|
|
return new DelayAsyncResult(this, callback, state);
|
|
}
|
|
|
|
public void EndDelay(IAsyncResult result)
|
|
{
|
|
DelayAsyncResult.End(result);
|
|
}
|
|
|
|
protected override IEnumerator<AsyncStep> GetAsyncSteps()
|
|
{
|
|
while (true)
|
|
{
|
|
yield return RandomDelayQueuedSendsAsyncResult<TItem>.GetDequeueStep();
|
|
|
|
if (this.currentItem == null)
|
|
{
|
|
yield break;
|
|
}
|
|
|
|
if (this.doDelay)
|
|
{
|
|
yield return RandomDelayQueuedSendsAsyncResult<TItem>.GetDelayStep();
|
|
}
|
|
|
|
yield return RandomDelayQueuedSendsAsyncResult<TItem>.GetSendItemStep();
|
|
}
|
|
}
|
|
|
|
protected void Start(TimeSpan timeout)
|
|
{
|
|
this.Start(this, timeout);
|
|
}
|
|
|
|
protected abstract IAsyncResult OnBeginSendItem(
|
|
TItem item,
|
|
TimeSpan timeout,
|
|
AsyncCallback callback,
|
|
object state);
|
|
|
|
protected abstract void OnEndSendItem(IAsyncResult result);
|
|
|
|
static AsyncStep GetDequeueStep()
|
|
{
|
|
if (dequeueStep == null)
|
|
{
|
|
dequeueStep = RandomDelayQueuedSendsAsyncResult<TItem>.CallAsync(
|
|
(thisPtr, t, c, s) => thisPtr.itemQueue.BeginDequeue(TimeSpan.MaxValue, c, s),
|
|
(thisPtr, r) => thisPtr.currentItem = thisPtr.itemQueue.EndDequeue(r));
|
|
}
|
|
|
|
return dequeueStep;
|
|
}
|
|
|
|
static AsyncStep GetDelayStep()
|
|
{
|
|
if (delayStep == null)
|
|
{
|
|
delayStep = RandomDelayQueuedSendsAsyncResult<TItem>.CallAsync(
|
|
(thisPtr, t, c, s) => thisPtr.BeginDelay(c, s),
|
|
(thisPtr, r) => thisPtr.EndDelay(r));
|
|
}
|
|
|
|
return delayStep;
|
|
}
|
|
|
|
static AsyncStep GetSendItemStep()
|
|
{
|
|
if (sendItemStep == null)
|
|
{
|
|
sendItemStep = RandomDelayQueuedSendsAsyncResult<TItem>.CallParallel(
|
|
(thisPtr, t, c, s) => thisPtr.OnBeginSendItem(thisPtr.currentItem, t, c, s),
|
|
(thisPtr, r) => thisPtr.OnEndSendItem(r));
|
|
}
|
|
|
|
return sendItemStep;
|
|
}
|
|
|
|
void PreCalculateSendDelays()
|
|
{
|
|
this.currentDelayIndex = 0;
|
|
for (int i = 0; i < this.preCalculatedDelays.Length; i++)
|
|
{
|
|
this.preCalculatedDelays[i] = (int)(this.random.NextDouble() * this.maxRandomDelayInMillis);
|
|
}
|
|
|
|
Array.Sort<int>(this.preCalculatedDelays);
|
|
}
|
|
|
|
int GetNextDelay()
|
|
{
|
|
int delay = 0;
|
|
|
|
if ((this.preCalculatedDelays == null) || (this.preCalculatedDelays.Length == 0))
|
|
{
|
|
delay = (int)(this.maxRandomDelayInMillis * this.random.NextDouble());
|
|
}
|
|
else
|
|
{
|
|
if (this.preCalculatedDelays.Length == 1 || this.currentDelayIndex == 0)
|
|
{
|
|
delay = this.preCalculatedDelays[0];
|
|
}
|
|
else
|
|
{
|
|
this.currentDelayIndex++;
|
|
if (currentDelayIndex == this.preCalculatedDelays.Length)
|
|
{
|
|
this.currentDelayIndex = 1;
|
|
}
|
|
|
|
delay = this.preCalculatedDelays[this.currentDelayIndex] -
|
|
this.preCalculatedDelays[this.currentDelayIndex - 1];
|
|
}
|
|
}
|
|
|
|
return delay;
|
|
}
|
|
|
|
class DelayAsyncResult : AsyncResult
|
|
{
|
|
readonly IOThreadTimer delayTimer;
|
|
static Action<object> onDelayCompletedCallback = new Action<object>(OnDelayCompleted);
|
|
|
|
public DelayAsyncResult(
|
|
RandomDelayQueuedSendsAsyncResult<TItem> parent,
|
|
AsyncCallback callback,
|
|
object state)
|
|
: base(callback, state)
|
|
{
|
|
int delay = parent.GetNextDelay();
|
|
if (delay != 0)
|
|
{
|
|
this.delayTimer = new IOThreadTimer(onDelayCompletedCallback, this, true);
|
|
this.delayTimer.Set(delay);
|
|
}
|
|
else
|
|
{
|
|
this.Complete(true);
|
|
}
|
|
}
|
|
|
|
public static void End(IAsyncResult result)
|
|
{
|
|
AsyncResult.End<DelayAsyncResult>(result);
|
|
}
|
|
|
|
static void OnDelayCompleted(object state)
|
|
{
|
|
DelayAsyncResult thisPtr = (DelayAsyncResult)state;
|
|
thisPtr.delayTimer.Cancel();
|
|
thisPtr.Complete(false);
|
|
}
|
|
}
|
|
}
|
|
}
|