Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
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
2016-05-03 00:07:37 +02:00

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);
}
}
}
}