public IProducerConsumerPattern ProducerConsumer <T>(Func <T> producerFunc, byte producerCount, Action <T> consumerAction, byte consumerCount)
{
IConcurrentQueue <T> queue = new SynchronizedQueue <T>();
IProducerConsumerPattern pattern = new ProducerConsumerPattern <T>(this, queue, producerFunc, producerCount, consumerAction, consumerCount);
return(pattern);
}
public Byte[] Decompress()
{
var zipOperation = new ZipDecompressor();
var readerQueue = new SynchronizedQueue <Chunk>(4);
var writerQueue = new SynchronizedQueue <Chunk>(4);
zipOperation.Cancel += readerQueue.Close;
zipOperation.Cancel += writerQueue.Close;
var reader = new Thread(() => zipOperation.Reader(MID_OUTPUT_FILE, ref readerQueue));
var proces = new Thread(() => zipOperation.Process(ref readerQueue, ref writerQueue));
var writer = new Thread(() => zipOperation.Writer(OUTPUT_FILE, ref writerQueue));
reader.Start();
proces.Start();
writer.Start();
reader.Join();
proces.Join();
writer.Join();
zipOperation.Cancel -= readerQueue.Close;
zipOperation.Cancel -= writerQueue.Close;
return(File.ReadAllBytes("test_input_res.txt"));
}
public VirtualCashBox(ManualCashBox cashBox)
{
responseQueue = new SynchronizedQueue <Packet>();
device = cashBox;
commandCounter = 0;
}
public SberBank(SberBankMode mode)
{
this.mode = mode;
runErrors = false;
failedExtensions = new List <string>();
events = new Dictionary <Type, Delegate>();
device = new BankingDevice((byte)(Settings.Default.CashBoxID & 0xFF));
device.Message += (s, e) => { logger.Write(e ? LogLevel.Error : LogLevel.Verbose, s); };
device.StateChanged += (s, i) => { logger.Write(LogLevel.Debug, String.Format("{0}\r\n{1}", s, i)); };
device.TransactionCompleted += OnTransactionCompleted;
receivedPacket = null;
networkEvent = new ManualResetEvent(false);
networkProtocol = null;
networkThread = new ThreadHost(NetworkThread, false, true, true);
networkThread.Name = "Network Dispatcher";
queue = new SynchronizedQueue <Packet>();
logger = null;
pathManager = null;
monitorObjects = new List <IMonitoringObject>();
startupProgress = null;
extensionsFiltered = 0;
}
/// <summary>
/// Initializes a new instance of the <see cref="DVRPTRio"/> class.
/// </summary>
/// <param name="stream">Stream.</param>
/// <param name="streamOwner">If set to <c>true</c> this instance is the stream owner. The stream will disposed when this instance is disposed</param>
/// <param name="syncContext">When specified the PacketReceived event is fired on this context. Otherwise it is fired on a worker thread</para>
protected DVRPTRio(Stream stream, bool streamOwner, SynchronizationContext syncContext)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
if (!stream.CanWrite)
{
throw new ArgumentException("stream is not writable");
}
if (!stream.CanRead)
{
throw new ArgumentException("stream is not readable");
}
_run = false;
_disposed = false;
_modemStreamReader = new BinaryReader(stream);
_readModemThread = null;
_readModemQueue = new SynchronizedQueue <byte[]>();
_modemStreamWriter = new BinaryWriter(stream);
_writeModemThread = null;
_writeModemQueue = new SynchronizedQueue <byte[]>();
_streamOwner = streamOwner;
_syncContext = syncContext;
}
public static void Main(string[] args)
{
Console.WriteLine("Hello, world!");
// This using block defines the lifetime of the queue and therefore the lifetime of all producers and consumers
using (SynchronizedQueue<string> qs = new SynchronizedQueue<string>(true))
{
// Now we're creating several producers and consumers
AbstractQueueProducer<string> producer1 = new DummyProducer(qs);
AbstractQueueProducer<string> producer2 = new DummyProducer(qs);
AbstractQueueProducer<string> producer3 = new DummyProducer(qs);
AbstractQueueProducer<string> producer4 = new DummyProducer(qs);
AbstractQueueConsumer<string> consumer1 = new DummyConsumer(qs);
AbstractQueueConsumer<string> consumer2 = new DummyConsumer(qs);
AbstractQueueConsumer<string> consumer3 = new DummyConsumer(qs);
AbstractQueueConsumer<string> consumer4 = new DummyConsumer(qs);
AbstractQueueConsumer<string> consumer5 = new DummyConsumer(qs);
// All consumers/producers have been created. Now let's have the main thread rest for a while.
Thread.Sleep(5000);
// Alright, enough sleeping for the main thread! Let's get out of this using block and therefore kill all consumers/workers and the queue itself!
}
Console.WriteLine("Goodbye, world! (press enter)");
Console.Read();
}
public void Compress(Byte[] b)
{
File.WriteAllBytes(INPUT_FILE, b);
var zipOperation = new ZipCompressor();
var readerQueue = new SynchronizedQueue <Chunk>(4);
var writerQueue = new SynchronizedQueue <Chunk>(4);
zipOperation.Cancel += readerQueue.Close;
zipOperation.Cancel += writerQueue.Close;
var reader = new Thread(() => zipOperation.Reader(INPUT_FILE, ref readerQueue));
var proces = new Thread(() => zipOperation.Process(ref readerQueue, ref writerQueue));
var writer = new Thread(() => zipOperation.Writer(MID_OUTPUT_FILE, ref writerQueue));
reader.Start();
proces.Start();
writer.Start();
reader.Join();
proces.Join();
writer.Join();
zipOperation.Cancel -= readerQueue.Close;
zipOperation.Cancel -= writerQueue.Close;
}
/// <summary>
/// Initializes the members of the Scheduler class and starts the execution timer.
/// </summary>
static Scheduler()
{
SchedulingSectionHandler config = (SchedulingSectionHandler) ConfigurationManager.GetSection("sharpCore/scheduling");
jobs = config.Jobs;
interval = config.Interval;
queue = new SynchronizedQueue<JobBase>();
}
public BarPersistence(IFelixHttpClient client)
{
Queue = new SynchronizedQueue();
LoaderThread = new Thread(Loader);
Client = client;
DoneEvent = new ManualResetEvent(false);
}
internal static void Init()
{
lock (lockObject) {
// Crittercism.Init calling APM.Init should effectively make
// lock lockObject here pointless, but no real harm doing so.
SettingsChange();
Filters = new HashSet <CRFilter>();
EndpointsQueue = new SynchronizedQueue <Endpoint>(new Queue <Endpoint>());
}
}
public TimeComeRule(IConnector connector, IEnumerable <DateTimeOffset> times)
: base(connector)
{
if (times == null)
{
throw new ArgumentNullException(nameof(times));
}
var currentTime = connector.CurrentTime;
var intervals = new SynchronizedQueue <TimeSpan>();
var timesList = new SynchronizedList <DateTimeOffset>();
foreach (var time in times)
{
var interval = time - currentTime;
if (interval <= TimeSpan.Zero)
{
continue;
}
intervals.Enqueue(interval);
currentTime = time;
timesList.Add(time);
}
// все даты устарели
if (timesList.IsEmpty())
{
return;
}
Name = LocalizedStrings.Str1055;
var index = 0;
_timer = new MarketTimer(connector, () =>
{
var activateTime = timesList[index++];
Activate(activateTime);
if (index == timesList.Count)
{
_timer.Stop();
}
else
{
_timer.Interval(intervals.Dequeue());
}
})
.Interval(intervals.Dequeue())
.Start();
}
internal ChunkingReader(Message startMessage, int maxBufferedChunks, TimeoutHelper receiveTimeout)
{
//set innerReader
this.innerReader = startMessage.GetReaderAtBodyContents();
this.lockobject = new object();
this.messageId = ChunkingUtils.GetMessageHeader <Guid>(startMessage,
ChunkingUtils.MessageIdHeader, ChunkingUtils.ChunkNs);
this.bufferedChunks = new SynchronizedQueue <Message>(maxBufferedChunks);
this.receiveTimeout = receiveTimeout;
this.nextChunkNum = 1;
}
internal ChunkingReader(Message startMessage, int maxBufferedChunks, TimeoutHelper receiveTimeout)
{
//set innerReader
this.innerReader = startMessage.GetReaderAtBodyContents();
this.lockobject = new object();
this.messageId = ChunkingUtils.GetMessageHeader<Guid>(startMessage,
ChunkingUtils.MessageIdHeader, ChunkingUtils.ChunkNs);
this.bufferedChunks = new SynchronizedQueue<Message>(maxBufferedChunks);
this.receiveTimeout = receiveTimeout;
this.nextChunkNum = 1;
}
/// <summary>
/// The setup is called before any actions are executed.
/// It will never be called from the device file editor, but only from the experiment runner.
/// </summary>
public override void Setup()
{
// create and setup the XY Table
//xyTableModule = new Communication_RS232();
//xyTableModule.Open(Config.xyTableComport.PortName, Config.xyTableComport.BaudRate);
// create and setup the Microscope
//MicroscopeModule = new Communication_RS232();
//MicroscopeModule.Open(Config.MicroscopeComport.PortName, Config.MicroscopeComport.BaudRate);
//MicroscopeModule.PortRecievedMessageEvent += new PortRecievedMessageEventHandler(MessageRecievedEvent);
// create a queue to handle the temperature data of the incubator
IncubatorResultQueue = new SynchronizedQueue <IncubatorResult>();
}
/*
* Constructor - Makes stream with no filter by default
* and no IPC message queue
*
* To use with a message queue for IPC, call SetUseQueue(true)
*
*/
public TwitterStream(string user, string pass, bool isEncrypted)
{
if (isEncrypted) {
password = Common.Decrypt (pass);
} else {
password = pass;
}
username = user;
password = pass;
jsonQueue = new SynchronizedQueue<string> ();
SetFiltered(false);
}
static void RunJob(IEnumerator job, SynchronizedQueue <IEnumerator> queue)
{
try
{
while (job.MoveNext())
{
if (job.Current == null)
{
break;
}
else if (job.Current == JobYields.SwitchToMain && queue != _MainThreadQueue)
{
EnqueueJob(job, _MainThreadQueue);
break;
}
else if (job.Current == JobYields.SwitchToWorker && queue == _MainThreadQueue)
{
EnqueueJobOnMostFree(job);
break;
}
else if (job.Current == JobYields.Yield)
{
EnqueueJob(job, queue);
break;
}
else if (job.Current is JobYields.BaseJobYield)
{
var yield = job.Current as JobYields.BaseJobYield;
if (yield.ShouldYield())
{
var obj = new SleepingJob();
obj.yieldFunc = yield;
obj.job = job;
_SleepingJobs.Enqueue(obj);
break;
}
}
}
}
catch (System.Exception ex)
{
Debug.LogError(ex);
Debug.Break();
}
}
public BonePosePreCalculator(BonePoseCalculatorWorker worker, MmdPose pose, Poser poser, BulletPyhsicsReactor physicsReactor, float stepLength, float startTimePos, int frameCacheSize, bool autoStepLength)
{
_poseMode = true;
_poser = poser;
_physicsReactor = physicsReactor;
_stepLength = stepLength;
_bonePoseImagesStore = new SynchronizedQueue <BonePoseFrame>();
_timePos = startTimePos;
_autoStepLength = autoStepLength;
_frameCacheSize = frameCacheSize;
poser.ResetPosing();
SetPoseToPoser(pose, _poser);
_poser.PrePhysicsPosing();
_physicsReactor.Reset();
_poser.PostPhysicsPosing();
var image = GetBonePoseImage(_poser);
_bonePoseImagesStore.Enqueue(new BonePoseFrame(startTimePos, image));
_worker = worker;
}
public void TestQueueDequeue()
{
// ReSharper disable once ConvertToConstant.Local
int numberOfObjectsToEnqueue = 100;
SynchronizedQueue <object> queue = new SynchronizedQueue <object>();
//This will produce data into the queue
ThreadStart producerProc = () =>
{
Thread.Sleep(300);
for (int i = 0; i < numberOfObjectsToEnqueue; i++)
{
queue.Enqueue(new Object());
Thread.Sleep(100);
}
};
Thread producer = new Thread(producerProc);
producer.Start();
//this one (the main thread) will consume the data inside the main thread of the unittest
object item;
int itemcount = 0;
do
{
item = queue.Dequeue(1000);
itemcount++;
Console.WriteLine("Dequeued {0} items", itemcount);
}while(item != null);
Assert.AreEqual(numberOfObjectsToEnqueue + 1, itemcount, "Dequeued count mismatch");
Assert.IsNull(item, "Last dequeued item should be null");
Assert.AreEqual(0, queue.Count, "Queue should be empty");
}
protected NetworkStatistics()
{
this.m_consumerTimer = new TimerEntry(new Action <int>(this.ConsumerCallback));
this.m_queuedStats = new SynchronizedQueue <PacketInfo>();
}
public static void EnqueueJob(IEnumerator coroutine, SynchronizedQueue <IEnumerator> list)
{
list.Enqueue(coroutine);
work_cvar.Set();
}
public SynchronizedQueue(SynchronizedQueue <T> queue)
{
m_Queue = new Queue <T>(queue.m_Queue);
m_lock = new object();
}
public abstract void Reader(string source, ref SynchronizedQueue <T> readerQueue);
public abstract void Process(ref SynchronizedQueue <T> readerTaskPool, ref SynchronizedQueue <T> writerQueue);
protected NetworkStatistics()
{
m_consumerTimer = new TimerEntry(ConsumerCallback);
m_queuedStats = new SynchronizedQueue <PacketInfo>();
}
private void Initialize(IPEndPoint endPoint)
{
listener = new TcpListener(endPoint);
clientQueue = new SynchronizedQueue<TcpClient>();
listenThread = new Thread(new ThreadStart(Listen));
listenThread.IsBackground = true;
listenThread.Start();
}
public void TestSynchronizedQueue()
{
SynchronizedQueue<string> queue = new SynchronizedQueue<string>();
queue.Enqueue("one");
queue.Enqueue("two");
Assert.IsTrue(queue.Count == 2);
foreach (string name in queue)
{
Assert.IsTrue(queue.Contains(name));
}
if (queue.Peek() == "one")
{
queue.Dequeue();
queue.Enqueue("one");
}
Assert.IsTrue(queue.Count == 2);
Assert.IsTrue(queue.Peek() == "two");
queue.Clear();
Assert.IsTrue(queue.Count == 0);
}
public CommandQueueMonitoringObject(SynchronizedQueue <Packet> queue)
: base("Очередь команд", (int)MonitoringObjectCategory.Commands)
{
_queue = queue;
Refresh();
}
protected NetworkStatistics()
{
m_consumerTimer = new TimerEntry(0f, 0f, ConsumerCallback);
m_queuedStats = new SynchronizedQueue<PacketInfo>();
}
static void Main(string[] args)
{
ParseArgs options;
Result result = new Result();
try
{
options = new ParseArgs(args);
}
catch (Exception e)
{
result.Error();
Console.WriteLine(e.Message);
return;
}
if (options.Command == Operation.Compress)
{
ZipOperation = new ZipCompressor();
}
else
{
ZipOperation = new ZipDecompressor();
}
_readerQueue = new SynchronizedQueue <Chunk>(_cores);
_writerQueue = new SynchronizedQueue <Chunk>(_cores);
ZipOperation.Cancel += _readerQueue.Close;
ZipOperation.Cancel += _writerQueue.Close;
ZipOperation.Error += result.Error;
_reader = new Thread(() => ZipOperation.Reader(options.Source, ref _readerQueue));
for (int i = 0; i < _cores; i++)
{
_process[i] = new Thread(() => ZipOperation.Process(ref _readerQueue, ref _writerQueue));
}
_writer = new Thread(() => ZipOperation.Writer(options.Sink, ref _writerQueue));
_reader.Start();
foreach (Thread proces in _process)
{
proces.Start();
}
_writer.Start();
_reader.Join();
foreach (Thread proces in _process)
{
proces.Join();
}
_writer.Join();
result.Ok();
ZipOperation.Cancel -= _writerQueue.Close;
ZipOperation.Cancel -= _readerQueue.Close;
ZipOperation.Error -= result.Error;
}
public abstract void Writer(string sink, ref SynchronizedQueue <T> writerQueue);
