public void StringSplitterTest()
{
StringSplitter stringSplitter = new StringSplitter("\"");
stringSplitter.Delimiter = ",";
ConcurrentQueue <string> input = new ConcurrentQueue <string>();
ConcurrentQueue <object[]> output = new ConcurrentQueue <object[]>();
ManualResetEvent pauseButton = new ManualResetEvent(true);
Progress <int> progress = new Progress <int>();
int numinput = 2000;
for (int i = 0; i < numinput; i++)
{
input.Enqueue("\"Input, number\"," + i);
}
totalrecords = 0;
progress.ProgressChanged += progresshandler;
var action = stringSplitter.GetReportingPausableWorkItem();
List <Task> WorkList = new List <Task>();
for (int i = 0; i < 2; i++)
{
WorkList.Add(Task.Factory.StartNew(() => action(input, output, pauseButton, progress)));
}
while (!input.IsEmpty)
{
Task.Delay(200).Wait();
}
stringSplitter.SignalCompletion();
Task.WaitAll(WorkList.ToArray());
Assert.IsTrue(input.IsEmpty);
Assert.IsTrue(output.Count == numinput);
Assert.IsTrue(output.All(x => x.ElementAt(0).Equals("Input, number")));
var linqtime = output.AsEnumerable();
IEnumerable <int> numbers = linqtime.Select(x => Int32.Parse((string)x.ElementAt(1))); //forgive the weird casting it used to be a string collection
int Sum = numbers.Sum();
IEnumerable <int> checknumbers = Enumerable.Range(0, numinput); //range is non inclusive
int CheckSum = checknumbers.Sum();
Assert.IsTrue(Sum == CheckSum);
}
/// <summary>
/// 分隔符分包
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="source"></param>
/// <param name="separator"></param>
/// <returns></returns>
public static IObservable <T[]> ParsePackage <T>(this IObservable <T> source, T[] separator)
where T : IEquatable <T>
{
var list = new List <T>();
var queue = new ConcurrentQueue <T>();
var len = separator.Length;
return(Observable.Create <T[]>(o =>
{
var dis = source.Subscribe(s =>
{
list.Add(s);
queue.Enqueue(s);
if (queue.Count == len)
{
if (queue.AsEnumerable().SequenceEqual(separator))
{
#if NETSTANDARD2_1
o.OnNext(list.SkipLast(len).ToArray());
queue.Clear();
#else
o.OnNext(list.Take(list.Count - len).ToArray());
while (!queue.IsEmpty)
{
queue.TryDequeue(out _);
}
#endif
list.Clear();
}
else
{
queue.TryDequeue(out _);
}
}
}, o.OnCompleted);
return Disposable.Create(() =>
{
o.OnCompleted();
dis.Dispose();
list = null;
queue = null;
});
}).Where(p => p.Length > 0));
}
/// <summary>
/// Returns a list of all container names found in the underlying storage.
/// </summary>
/// <param name="options">The optional <see cref="ContainerRequestOptions"/> object to use when making a request.</param>
/// <returns>The list containing container names.</returns>
public IEnumerable <string> GetContainers(ContainerRequestOptions options = null)
{
ConcurrentQueue <string> list = new ConcurrentQueue <string>();
Parallel.ForEach <ICloudBlobStorage>(this.storageList, (x) =>
{
var сontainers = x.GetContainers(options);
if (сontainers != null)
{
foreach (var item in сontainers)
{
list.Enqueue(item);
}
}
});
return(list.AsEnumerable <string>());
}
public Task <IEnumerable <ChatMessageModel> > GetAll() => Task.Factory.StartNew(() => _messageQueue.AsEnumerable());
public IEnumerable <T> AsEnumerable()
{
return(_q.AsEnumerable());
}
public IEnumerable <Shelf> List()
{
return(_shelves.AsEnumerable());
}
/// <summary>
/// 包头包尾分包
/// </summary>
/// <param name="source"></param>
/// <param name="bom"></param>
/// <param name="eom"></param>
/// <returns></returns>
public static IObservable <T[]> ParsePackage <T>(this IObservable <T> source, T[] bom, T[] eom)
where T : IEquatable <T>
{
if (bom.Length == 0 || eom.Length == 0)
{
throw new ArgumentException("If bom or eom is empty, use SeparatorMessagePackParser.");
}
var list = new List <T>();
var bQueue = new ConcurrentQueue <T>();
var eQueue = new ConcurrentQueue <T>();
var bl = bom.Length;
var el = eom.Length;
var findHeader = false;
return(Observable.Create <T[]>(o =>
{
var dis = source.Subscribe(s =>
{
if (!findHeader)
{
bQueue.Enqueue(s);
if (bQueue.Count == bl)
{
if (bQueue.AsEnumerable().SequenceEqual(bom))
{
findHeader = true;
}
else
{
bQueue.TryDequeue(out _);
}
}
}
else
{
list.Add(s);
eQueue.Enqueue(s);
if (eQueue.Count == el)
{
if (eQueue.AsEnumerable().SequenceEqual(eom))
{
#if NETSTANDARD2_1
o.OnNext(list.SkipLast(el).ToArray());
bQueue.Clear();
eQueue.Clear();
#else
o.OnNext(list.Take(list.Count - el).ToArray());
while (!bQueue.IsEmpty)
{
bQueue.TryDequeue(out _);
}
while (!eQueue.IsEmpty)
{
eQueue.TryDequeue(out _);
}
#endif
list.Clear();
findHeader = false;
}
else
{
eQueue.TryDequeue(out _);
}
}
}
}, o.OnCompleted);
return Disposable.Create(() =>
{
o.OnCompleted();
dis.Dispose();
list.Clear();
list = null;
bQueue = null;
eQueue = null;
});
}));
}
public IEnumerable <Payload> List()
{
return(_payloads.AsEnumerable());
}
public IActionResult ReadAll()
{
return(Json(_inMemoryRecords.AsEnumerable()));
}
public IEnumerable <BandwidthRecord> GetAllBandwidthRecords()
{
return(Bandwidth.AsEnumerable());
}
