/// <summary>
/// Executes the asynchronously.
/// </summary>
/// <param name="requestUri">The request URI.</param>
/// <param name="state">The state.</param>
/// <param name="httpMethod">The HTTP method.</param>
/// <returns>A function delegate that returns the future result to be available through the Task.</returns>
public Task <OperationResponse> ExecuteAsync(Uri requestUri, object state, string httpMethod)
{
return(Task.Factory.FromAsync <Uri, string, OperationResponse>(
(u, m, ac, s) => _dataContext.BeginExecute(u, ac, s, m),
(ar) => _dataContext.EndExecute(ar),
requestUri,
httpMethod,
state));
}
/// <summary>Loads the collection asynchronously by loading the results from the request Uri.</summary>
/// <param name="requestUri">The request uri to download results from.</param>
/// <remarks>This method uses the event-based async pattern.
/// The method returns immediately without waiting for the query to complete. Then it calls the handler of the
/// <see cref="LoadCompleted"/> event exactly once on the UI thread. The event will be raised regradless
/// if the query succeeded or not.
/// This class only support one asynchronous operation in flight.</remarks>
public void LoadAsync(Uri requestUri)
{
Util.CheckArgumentNull(requestUri, "requestUri");
if (!this.IsTracking)
{
throw new InvalidOperationException(Strings.DataServiceCollection_OperationForTrackedOnly);
}
if (this.ongoingAsyncOperation != null)
{
throw new InvalidOperationException(Strings.DataServiceCollection_MultipleLoadAsyncOperationsAtTheSameTime);
}
DataServiceContext context = this.observer.Context;
requestUri = UriUtil.CreateUri(context.BaseUri, requestUri);
this.BeginLoadAsyncOperation(
asyncCallback => context.BeginExecute <T>(requestUri, asyncCallback, null),
asyncResult =>
{
QueryOperationResponse <T> response = (QueryOperationResponse <T>)context.EndExecute <T>(asyncResult);
this.Load(response);
return(response);
});
}
internal static IEnumerable <TElement> EndExecute <TElement>(DataServiceContext serviceContext, IAsyncResult asyncResult)
{
IEnumerable <TElement> result;
try
{
IEnumerable <TElement> enumerable = serviceContext.EndExecute <TElement>(asyncResult);
QueryOperationResponse <TElement> queryOperationResponse = enumerable as QueryOperationResponse <TElement>;
if (queryOperationResponse != null && queryOperationResponse.Error != null)
{
throw queryOperationResponse.Error;
}
result = enumerable;
}
catch (DataServiceQueryException)
{
throw;
}
finally
{
if (asyncResult is IDisposable)
{
(asyncResult as IDisposable).Dispose();
}
}
return(result);
}
public void QueryFailureUsingContextExecuteAsync()
{
Uri baseUri = ctx.BaseUri;
Uri requestUri = new Uri(baseUri.OriginalString + "/Customers('VAR1')");
try
{
var q = ctx.EndExecute <northwindClient.Customers>(
ctx.BeginExecute <northwindClient.Customers>(requestUri, null, null));
}
catch (DataServiceQueryException ex)
{
QueryOperationResponse response = ex.Response;
Utils.IsErrorResponse(response, HttpStatusCode.NotFound, false);
Assert.IsTrue(response.Query.RequestUri.Equals(requestUri), "expecting the same request uri");
}
}
private void PollForTestWorkMessages(IAsyncResult asyncResult)
{
Message response = null;
Message message = null;
try
{
DataServiceContext asynchConnector = asyncResult.AsyncState as DataServiceContext;
IEnumerable <Message> messages = asynchConnector.EndExecute <Message>(asyncResult);
message = messages.FirstOrDefault <Message>();
SignalUI("PollingStatus", "Started");
if (null != message && !processedMessages.Any <string>(pm => pm == message.MessageID.ToString()))
{
processedMessages.Add(message.MessageID.ToString());
#region ClaimTest
//If the test is not claimed , then claim it .
//if (message.TestClientID.Length == 0)
//{
// ClaimTest(message);
//}
//if (message.TestClientID.Length > 0 && message.TestClientID == ClientID)
//{
#endregion
SignalUI("MQConnectionStatus", "Pass");
response = new Message();
response.WhoSentMe = "SL";
response.Method = message.Method;
RemoteClient.Dispatch(message, response);
//}
}
}
catch (Exception exception)
{
SignalUI("TestStatus", "Failed : " + exception.StackTrace.ToString());
Message Response = new Message();
Response.Method = message.Method;
Response.WhoSentMe = "SL";
PushResponseToQueue(message, Response);
//DataServiceContext dsc = GetServiceContext();
//Message response2 = new Message();
//response.ReturnValue = exception.ToString();
//response.WhoSentMe = "SL";
//response.Method = message.Method;
//dsc.AddObject("Messages", response2);
//dsc.BeginSaveChanges(PostTestWorkRespose, dsc);
}
finally
{
}
}
/// <summary>
///
/// </summary>
/// <typeparam name="TResult"></typeparam>
/// <param name="context"></param>
/// <param name="requestUri"></param>
/// <returns></returns>
public static async Task <IEnumerable <TResult> > ExecuteAsync <TResult>(this DataServiceContext context, Uri requestUri)
{
return
(await Task.Factory.FromAsync <IEnumerable <TResult> >(context.BeginExecute <TResult>(requestUri, null, null),
executeAsyncResult =>
{
List <TResult> executeResult = context.EndExecute <TResult>(executeAsyncResult).ToList();
return executeResult;
}));
}
/// <summary>
/// Asynchronously requests the next page of data in the results.
/// </summary>
/// <typeparam name="TResult">Entity type of the result of the execution.</typeparam>
/// <param name="context">The <see cref="T:System.Data.Services.Client.DataServiceContext"/> instance on which this extension method is enabled. </param>
/// <param name="requestUri">The URI of the query or operation that returns type <typeparam name="TResult"/>.</param>
/// <param name="queryContinuationToken">A <see cref="T:System.Data.Services.Client.DataServiceQueryContinuation`1"/> token that is used to request the next page of data.</param>
/// <returns>A <see cref="T:System.Threading.Tasks.Task`1"/> that, when completed, returns the results of the execution.</returns>
public static async Task <IEnumerable <TResult> > ExecuteAsync <TResult>(this DataServiceContext context, DataServiceQueryContinuation <TResult> queryContinuationToken)
{
var queryTask = Task.Factory.FromAsync <IEnumerable <TResult> >(context.BeginExecute <TResult>(queryContinuationToken, null, null),
(queryAsyncResult) =>
{
var results = context.EndExecute <TResult>(queryAsyncResult);
return(results);
});
return(await queryTask);
}
/// <summary>
/// Asychronously executes a specific request URI.
/// </summary>
/// <typeparam name="TResult">Entity type of the result of the execution.</typeparam>
/// <param name="context">The <see cref="T:System.Data.Services.Client.DataServiceContext"/> instance on which this extension method is enabled. </param>
/// <param name="requestUri">The URI of the query or operation that returns type <typeparam name="TResult"/>.</param>
/// <param name="operationParameters">An array of <see cref="T:System.Data.Services.Client.OperationParameter"/> objects that are parameters in the request URI.</param>
/// <returns>A <see cref="T:System.Threading.Tasks.Task`1"/> that, when completed, returns the results of the execution.</returns>
public static async Task <IEnumerable <TResult> > ExecuteAsync <TResult>(this DataServiceContext context, Uri requestUri,
params System.Data.Services.Client.OperationParameter[] operationParameters)
{
var queryTask = Task.Factory.FromAsync <IEnumerable <TResult> >(context.BeginExecute <TResult>(requestUri, null, null),
(queryAsyncResult) =>
{
var results = context.EndExecute <TResult>(queryAsyncResult);
return(results);
});
return(await queryTask);
}
public static void ExecuteUri(this DataServiceContext context, IAsyncContinuation continuation, bool async, Uri requestUri, HttpVerb verb, OperationParameter[] inputParameters, Action <OperationResponse> onCompletion)
{
ExceptionUtilities.CheckArgumentNotNull(context, "context");
ExceptionUtilities.CheckArgumentNotNull(continuation, "continuation");
ExceptionUtilities.CheckArgumentNotNull(onCompletion, "onCompletion");
string method = Enum.GetName(typeof(HttpVerb), verb).ToUpperInvariant();
AsyncHelpers.InvokeSyncOrAsyncMethodCall <OperationResponse>(
continuation,
async,
() => context.Execute(requestUri, method, inputParameters),
c => context.BeginExecute(requestUri, c, null, method, inputParameters),
r => context.EndExecute(r),
onCompletion);
}
public void MQCOnnectionCallback(IAsyncResult asynchResult)
{
try
{
DataServiceContext testDataContext = asynchResult.AsyncState as DataServiceContext;
var messages = testDataContext.EndExecute <TestSL.Message>(asynchResult);
if (messages.Count <TestSL.Message>() >= 0)
{
SignalUI("MQConnectionStatus", "Pass");
}
}
catch (Exception exception)
{
SignalUI("MQConnectionStatus", "Fail with " + exception.Message);
}
}
public IEnumerable <T> EndExecute(IAsyncResult asyncResult)
{
Util.CheckArgumentNull(asyncResult, "asyncResult");
return(Context.EndExecute <T>(asyncResult));
}
/// <summary>Called to complete the <see cref="Microsoft.OData.Client.DataServiceActionQuery.BeginExecute(System.AsyncCallback,System.Object)" />.</summary>
/// <returns>The result of the operation.</returns>
/// <param name="asyncResult">An <see cref="System.IAsyncResult" /> that represents the status of the asynchronous operation.</param>
/// <remarks>This method should be used in combination with the BeginExecute overload which
/// expects the request uri to end with an action that returns void.</remarks>
public OperationResponse EndExecute(IAsyncResult asyncResult)
{
return(Context.EndExecute(asyncResult));
}
/// <summary>
/// Extension method to perform sync/async version of DataServiceContext.Execute dynamically
/// </summary>
/// <typeparam name="TElement">The element type of the expression results</typeparam>
/// <param name="context">The context to call execute on</param>
/// <param name="continuation">The asynchronous continuation</param>
/// <param name="async">A value indicating whether or not to use async API</param>
/// <param name="requestUri">The uri to make a request to</param>
/// <param name="onCompletion">A callback for when the call completes</param>
public static void Execute <TElement>(this DataServiceContext context, IAsyncContinuation continuation, bool async, Uri requestUri, Action <IEnumerable <TElement> > onCompletion)
{
ExceptionUtilities.CheckArgumentNotNull(context, "context");
AsyncHelpers.InvokeSyncOrAsyncMethodCall <IEnumerable <TElement> >(continuation, async, () => context.Execute <TElement>(requestUri), c => context.BeginExecute <TElement>(requestUri, c, null), r => context.EndExecute <TElement>(r), onCompletion);
}
public T EndGetValue(IAsyncResult asyncResult)
{
Util.CheckArgumentNull(asyncResult, "asyncResult");
return(context.EndExecute <T>(asyncResult).Single());
}
