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