public void Start(IRequestObject requestObject) { if (requestObject == null) return; if (IsBusy) return; _cancellationTokenSource = new CancellationTokenSource(); _isBusy = true; this._requestObject = requestObject; var token = _cancellationTokenSource.Token; Task.Run(() => { while (!token.IsCancellationRequested) { var now = DateTime.Now; if (this._requestObject.CanCreateRequst && now >= NextRequestTme) { NextRequestTme = now.AddSeconds(IntervalSeconds); HandleRequestAsync(); } System.Threading.Thread.Sleep(500); } _isBusy = false; }, _cancellationTokenSource.Token); }
public Task <TResponse> QueryAsync <TResponse>(IRequestObject <TKey> request) { CheckNull(request); IMessenger <TKey> messenger = GetMessenger(request.Receiver); return(messenger.ReceiveQueryAsync <TResponse>(request)); }
public virtual TResult ReceiveQuery <TResult>(IRequestObject <TKey> request) { RequestResultContainer _iRequest = requests.Keys.FirstOrDefault(x => x.HasRequestedTypeAndExpectedResult(request.GetType(), typeof(TResult))); if (_iRequest == null) { throw new KeyNotFoundException(); } return((TResult)requests[_iRequest].InvokeRequest(request)); }
private async Task <bool> Set(IRequestObject requestObject, string url, CancellationToken cancellationToken = default) { var stringContent = GetStringContent(requestObject); var httpResponseMessage = await HttpClient.PostAsync(url, stringContent, cancellationToken); if (httpResponseMessage.IsSuccessStatusCode) { return(true); } throw new ArgumentException($"Request failed: {httpResponseMessage.ReasonPhrase}"); }
public async Task <TResult> ReceiveQueryAsync <TResult>(IRequestObject <TKey> request) { var _iRequest = requests.Keys.FirstOrDefault(x => x.HasRequestedTypeAndExpectedResult(request.GetType(), typeof(TResult))); if (_iRequest == null) { throw new KeyNotFoundException(); } object o = await asyncRequests[_iRequest].InvokeRequestAsync(request); return((TResult)o); }
public static bool TryInvokeRequest <TKey, TResult>(this IRequestObject <TKey> requestObject, Type expectedRequest, Func <TResult> func, out TResult result) { ThrowOnNotAssignable(typeof(IRequestObject <TKey>), expectedRequest); bool isSuccess = false; result = default(TResult); Type rqtType = requestObject.GetType(); if (rqtType == expectedRequest) { result = func(); isSuccess = true; } return(isSuccess); }
public IStandardReply <IEnumerable <T> > GetEnumerable <T>(IRequestObject request) { logger.LogInformation("{0} started.", MethodBase.GetCurrentMethod().Name); IStandardReply <IEnumerable <T> > reply = StandardReply <IEnumerable <T> > .CreateInstance("Get successful."); try { if (conn.State != ConnectionState.Open) { conn.Close(); conn.Open(); } reply.Response = conn.Query <T>(request.SqlStatement, request.Data, request.Transaction, request.Buffered, request.Timeout, request.CommandType); } catch (Exception exc) { reply.ProcessException(exc, request, logger, MethodBase.GetCurrentMethod().Name); } logger.LogInformation("{0} finished.", MethodBase.GetCurrentMethod().Name); return(reply); }
public static bool TryInvokeRequest <TKey, TResult, TExpectedRequest>(this IRequestObject <TKey> requestObject, Func <TResult> func, out TResult result) where TExpectedRequest : IRequestObject <TKey> { return(requestObject.TryInvokeRequest(typeof(TExpectedRequest), func, out result)); }
IMyAsyncEnumerable <string> UnpackArchive(string filename, string folder, IRequestObject request);
object UnpackArchive(string filename, string folder, IRequestObject request);
// Queues a new work item, passing a state object to the callback method // Returns false if the request queue is filled, meaning that the request was and will not be processed at the moment public bool QueueWorkItem(IRequestObject requestObject) { if (m_numWorkerThreads < m_capacity) { if (!m_stopFlag) { Thread t = new Thread(WorkerThread); requestObject.ThreadInfo = new ProcessorThreadInfo(); requestObject.ThreadInfo.Thread = t; requestObject.ThreadInfo.ThreadID = m_idCounter; m_idCounter++; requestObject.ThreadInfo.Handle = new ManualResetEvent(false); // Passes a two-tuple of the object state and the thread info. // The callback method must set the waithandle once execution has completed. t.Start(requestObject); m_requestQueue.Enqueue(requestObject); // Give the thread some time to get started. Thread.Sleep(200); m_pool.Release(); if (m_numWorkerThreads == 0) m_continueWork.Set(); Interlocked.Increment(ref m_numWorkerThreads); return true; } return false; } return false; }
public Task <TResponse> QueryAsync <TResponse>(IRequestObject <string> request) { SentQuery = request; return(Task.FromResult((TResponse)Result)); }
public TResponse Query <TResponse>(IRequestObject <string> request) { SentQuery = request; return((TResponse)Result); }
public async Task <IStandardReply <IEnumerable <T> > > GetEnumerableAsync <T>(IRequestObject request) { return(await repo.GetEnumerableAsync <T>(request)); }