private IQueryable <TModel> FormFetchQuery <TModel>(FetchParameters <TModel> fetchParameters) where TModel : class { Check.NotNull(fetchParameters, "fetchParameters"); // !IMPORTANT! Call order DOES matter! // 1 Build Query var queriedItems = Query(fetchParameters); if (fetchParameters.NoTracking) { queriedItems = queriedItems.AsNoTracking(); } // 2 Sorting if (fetchParameters.HasSorting()) { queriedItems = fetchParameters.PerformSorting(queriedItems); } else { // HACK: https://stackoverflow.com/a/14524571/3469518 // this hack required for paging queriedItems = queriedItems.OrderBy(x => 0); } // 3 Filtering return(fetchParameters.PerformFiltering(queriedItems)); }
private void FetchAsynch(Object parameters) { FetchParameters fetchParameters = (FetchParameters)parameters; HttpWebRequest request = (HttpWebRequest)WebRequest.Create(fetchParameters.Uri); request.Method = "GET"; request.AutomaticDecompression = DecompressionMethods.GZip; if (fetchParameters.Headers != null && fetchParameters.Headers.Any()) { foreach (string key in fetchParameters.Headers.Keys) { if (key.ToLower() == "accept") { request.Accept = fetchParameters.Headers[key]; } else if (key.ToLower() == "content-type") { request.ContentType = fetchParameters.Headers[key]; } else if (key.ToLower() == "host") { Exception ex = new ArgumentException("Host header value cannot be set in PCL libraries."); Device.Log.Error(ex); throw ex; } else { request.Headers[key] = fetchParameters.Headers[key]; } } } RequestState state = new RequestState() { Request = request, AbsoluteUri = fetchParameters.Uri, FileName = fetchParameters.FileName, Downloaded = DateTime.UtcNow, StatusCode = HttpStatusCode.RequestTimeout, }; try { // Start the asynchronous request. IAsyncResult result = request.BeginGetResponse(new AsyncCallback(ResponseCallback), state); if (!allDone.WaitOne(fetchParameters.Timeout)) { try { request.Abort(); } catch (Exception) { } // .Abort() always throws exception return; } } catch (Exception exc) { Device.Log.Error("FetcherAsynch.FetchAsynch encountered exception", exc); autoEvent.Set(); } }
public static void FetchOrPull(Repository repository, Remote remote, bool pull) { var affectedReferences = ReferenceType.RemoteBranch | ReferenceType.Tag; if (pull) { affectedReferences |= ReferenceType.LocalBranch; } ReferenceChange[] changes; var state1 = RefsState.Capture(repository, affectedReferences); using (repository.Monitor.BlockNotifications( RepositoryNotifications.BranchChanged, RepositoryNotifications.TagChanged)) { try { if (pull) { var p = new PullParameters(); if (remote != null) { p.Repository = remote.Name; } repository.Accessor.Pull.Invoke(p); } else { var p = new FetchParameters(); if (remote != null) { p.Repository = remote.Name; } repository.Accessor.Fetch.Invoke(p); } } finally { repository.Refs.Refresh(affectedReferences); var state2 = RefsState.Capture(repository, affectedReferences); changes = RefsDiff.Calculate(state1, state2); if (changes != null && changes.Length != 0) { repository.OnUpdated(); } } } if (pull) { repository.Remotes.OnPullCompleted(remote, changes); } else { repository.Remotes.OnFetchCompleted(remote, changes); } }
public static Task FetchOrPullAsync( Repository repository, Remote remote, bool pull, IProgress <OperationProgress> progress, CancellationToken cancellationToken) { var affectedReferences = ReferenceType.RemoteBranch | ReferenceType.Tag; if (pull) { affectedReferences |= ReferenceType.LocalBranch; } var suppressedNotifications = repository.Monitor.BlockNotifications( RepositoryNotifications.BranchChanged, RepositoryNotifications.TagChanged); var state1 = RefsState.Capture(repository, affectedReferences); Task task; if (pull) { var p = new PullParameters(); if (remote != null) { p.Repository = remote.Name; } task = repository.Accessor.Pull.InvokeAsync(p, progress, cancellationToken); } else { var p = new FetchParameters(); if (remote != null) { p.Repository = remote.Name; } task = repository.Accessor.Fetch.InvokeAsync(p, progress, cancellationToken); } return(task.ContinueWith( t => { progress.Report(new OperationProgress(Resources.StrRefreshingReferences.AddEllipsis())); repository.Refs.Refresh(affectedReferences); var state2 = RefsState.Capture(repository, affectedReferences); var changes = RefsDiff.Calculate(state1, state2); suppressedNotifications.Dispose(); if (changes != null && changes.Length != 0) { repository.OnUpdated(); } TaskUtility.PropagateFaultedStates(t); if (pull) { repository.Remotes.OnPullCompleted(remote, changes); } else { repository.Remotes.OnFetchCompleted(remote, changes); } })); }
// this injection is fine since the design hides this behind internal internal PagingFetchBuilder(BasicRepository repository, FetchParameters <TModel> fetchParameters) { if (fetchParameters == null) { throw new System.ArgumentNullException(nameof(fetchParameters)); } this.fetchParameters = new FetchPagingParameters <TModel>(fetchParameters); this.repository = repository; }
internal static IQueryable <TModel> PerformFiltering <TModel>(this FetchParameters <TModel> target, IQueryable <TModel> queriedItems) where TModel : class { if (target.FilteringRules != null) { foreach (var filteringRule in target.FilteringRules.Where(x => x != null)) { queriedItems = queriedItems.Where(filteringRule); } } return(queriedItems); }
protected void lnkbtnGoogleClick(object sender, EventArgs e) { var oAuthRequest = new OAuthRequest { Provider = OAuthRequest.Providers.Google }; var parameters = new FetchParameters(); parameters.OpenidUserInformation.Add(RequestParameters.AxSchemaParams.Contact.email); parameters.OpenidUserInformation.Add(RequestParameters.AxSchemaParams.NamePerson.First); parameters.OpenidUserInformation.Add(RequestParameters.AxSchemaParams.NamePerson.Last); oAuthRequest.CreateRequest(parameters); }
/// <summary> /// Fetch file for created session. /// </summary> /// <param name="sessionId">Session identifier.</param> /// <param name="templateCode">Element's template code.</param> /// <param name="fetchParameters">Fetch parameters.</param> /// <exception cref="InvalidTemplateException">Specified template code does not refer to binary element.</exception> /// <exception cref="InvalidFetchUrlException">Fetch URL is invalid.</exception> /// <exception cref="MissingFilenameException">Filename is not specified.</exception> /// <exception cref="ObjectNotFoundException">Session or template has not been found.</exception> /// <exception cref="SessionExpiredException">Specified session is expired.</exception> /// <exception cref="S3Exception">Error making request to S3.</exception> /// <exception cref="InvalidBinaryException">Binary does not meet template's constraints.</exception> /// <exception cref="FetchFailedException">Fetch request failed.</exception> /// <returns>Fetched file key.</returns> public async Task <string> FetchFile(Guid sessionId, int templateCode, FetchParameters fetchParameters) { if (!TryCreateUri(fetchParameters, out var fetchUri)) { throw new InvalidFetchUrlException( $"Fetch URI must be a valid absolute URI with '{Uri.UriSchemeHttp}' or '{Uri.UriSchemeHttps}' scheme"); } MultipartUploadSession uploadSession = null; var(sessionDescriptor, _, expiresAt) = await _sessionStorageReader.GetSessionDescriptor(sessionId); // Firstly ensure that specified session exists try { var(stream, mediaType) = await _fetchClient.FetchAsync(fetchUri); var fileMetadata = new GenericUploadedFileMetadata(fetchParameters.FileName, mediaType, stream.Length); uploadSession = await InitiateMultipartUploadInternal(sessionId, templateCode, fileMetadata, sessionDescriptor, expiresAt); await UploadFilePart(uploadSession, stream, templateCode); var fetchedFileKey = await CompleteMultipartUpload(uploadSession); return(fetchedFileKey); } catch (FetchResponseTooLargeException ex) { throw new InvalidBinaryException(templateCode, new BinaryTooLargeError(ex.ContentLength)); } catch (FetchRequestException ex) { throw new FetchFailedException($"Fetch request failed with status code {ex.StatusCode} and content: {ex.Message}"); } catch (HttpRequestException ex) { throw new FetchFailedException($"Fetch request failed: {ex.Message}"); } catch (TimeoutRejectedException) { throw new FetchFailedException("Fetch request failed: request timeout exceeded"); } catch (FetchResponseContentTypeInvalidException ex) { throw new FetchFailedException($"Fetch request failed: {ex.Message}"); } finally { if (uploadSession != null) { await AbortMultipartUpload(uploadSession); } } }
internal static IQueryable <TModel> PerformSorting <TModel>(this FetchParameters <TModel> target, IQueryable <TModel> queriedItems) where TModel : class { if (target.HasSorting()) { var rules = target.SortingRules.Where(x => x != null); if (!rules.Any()) { return(queriedItems); // sanity check } foreach (var sortingRule in rules) { queriedItems = queriedItems.OrderBy(sortingRule); } } return(queriedItems); }
public async Task <ActionResult> FetchFile( Guid sessionId, int templateCode, [FromBody] FetchParameters fetchParameters) { if (fetchParameters == null) { return(BadRequest($"Request body with {nameof(fetchParameters)} must be specified")); } try { var fetchedFileKey = await _sessionManagementService.FetchFile(sessionId, templateCode, fetchParameters); return(Created(_cdnOptions.AsRawUri(fetchedFileKey), new FetchedFileValue(fetchedFileKey))); } catch (MissingFilenameException ex) { return(BadRequest(ex.Message)); } catch (InvalidTemplateException ex) { return(BadRequest(ex.Message)); } catch (InvalidFetchUrlException ex) { return(BadRequest(ex.Message)); } catch (ObjectNotFoundException) { return(NotFound()); } catch (SessionExpiredException ex) { return(Gone(ex.ExpiredAt)); } catch (FetchFailedException ex) { return(FailedDependency(ex.Message)); } catch (InvalidBinaryException ex) { return(Unprocessable(GenerateErrorJsonResult(ex))); } }
private void FetchAsynch(Object parameters) { FetchParameters fetchParameters = (FetchParameters)parameters; HttpWebRequest request = (HttpWebRequest)WebRequest.Create(fetchParameters.Uri); request.Method = "GET"; //request.Proxy = null; #if !SILVERLIGHT && !MONO request.AutomaticDecompression = DecompressionMethods.GZip; #endif if (fetchParameters.Headers != null && fetchParameters.Headers.Count() > 0) { foreach (string key in fetchParameters.Headers.Keys) { request.Headers[key] = fetchParameters.Headers[key]; } } RequestState state = new RequestState() { Request = request, AbsoluteUri = fetchParameters.Uri, FileName = fetchParameters.FileName }; // Start the asynchronous request. IAsyncResult result = request.BeginGetResponse(new AsyncCallback(ResponseCallback), state); if (!allDone.WaitOne(DefaultTimeout)) { OnError(state); return; } }
/// <summary> /// Synchronous Wrapper method around FetchAsynch() method /// </summary> /// <param name="cacheIndex"></param> /// <param name="cacheIndexItem"></param> public NetworkResponse Fetch( string uri, string filename, Dictionary<string, string> headers ) { PostNetworkResponse = new NetworkResponse(); FetchParameters fetchParameters = new FetchParameters() { Uri = uri, Headers = headers, FileName = filename }; DateTime dtMetric = DateTime.UtcNow; // set callback and error handler OnDownloadComplete += new NetworkingEventHandler( FetcherAsynch_OnDownloadComplete ); OnError += new NetworkingErrorHandler( FetcherAsynch_OnError ); System.Threading.ThreadPool.QueueUserWorkItem( parameters => { try { FetchAsynch( parameters ); } //catch ( Exception e ) //{ // // You could react or save the exception to an 'outside' variable // // threadExc = e; //} finally { autoEvent.Set(); // if you're firing and not forgetting ;) } }, fetchParameters ); // WaitOne returns true if autoEvent were signaled (i.e. process completed before timeout expired) // WaitOne returns false it the timeout expired before the process completed. if ( !autoEvent.WaitOne( DefaultTimeout ) ) { string message = "FetcherAsynch call to FetchAsynch timed out. uri " + fetchParameters.Uri; MXDevice.Log.Error( message ); MXDevice.Log.Debug( string.Format( "FetchAsynch timed out: Uri: {0} Time: {1} milliseconds ", uri, DateTime.UtcNow.Subtract( dtMetric ).TotalMilliseconds ) ); NetworkResponse networkResponse = new NetworkResponse() { Message = message, URI = fetchParameters.Uri, StatusCode = HttpStatusCode.RequestTimeout, ResponseString = string.Empty, Expiration = DateTime.MinValue.ToUniversalTime(), }; MXDevice.PostNetworkResponse( networkResponse ); return networkResponse; } //if ( threadExc != null ) //{ // throw threadExc; //} MXDevice.Log.Debug( string.Format( "FetchAsynch Completed: Uri: {0} Time: {1} milliseconds Size: {2} ", uri, DateTime.UtcNow.Subtract( dtMetric ).TotalMilliseconds, ( PostNetworkResponse.ResponseBytes != null ? PostNetworkResponse.ResponseBytes.Length : -1 ) ) ); return PostNetworkResponse; }
internal static bool HasSorting <TModel>(this FetchParameters <TModel> target) where TModel : class { return(target.SortingRules != null && target.SortingRules.Any(x => x != null)); }
/// <summary> /// Fetches the specified URI. /// </summary> /// <param name="uri">The URI of the resource to fetch.</param> /// <param name="filename">The name of the file to be fetched.</param> /// <param name="headers">The headers to be added to the request.</param> /// <param name="timeout">The request timeout value in milliseconds.</param> public NetworkResponse Fetch(string uri, string filename, IDictionary <string, string> headers, int timeout) { PostNetworkResponse = new NetworkResponse(); FetchParameters fetchParameters = new FetchParameters() { Uri = uri, Headers = headers, FileName = filename, Timeout = timeout }; DateTime dtMetric = DateTime.UtcNow; // set callback and error handler OnDownloadComplete -= FetcherAsynch_OnDownloadComplete; OnDownloadComplete += FetcherAsynch_OnDownloadComplete; OnError -= FetcherAsynch_OnError; OnError += FetcherAsynch_OnError; Exception threadExc = null; Device.Thread.QueueWorker(parameters => { try { FetchAsynch(parameters); } catch (Exception e) { Device.Log.Info("This exception occurred in FetchingAsynch:", e); // You could react or save the exception to an 'outside' variable 6` threadExc = e; } finally { autoEvent.Set(); // if you're firing and not forgetting ;) } }, fetchParameters); // WaitOne returns true if autoEvent were signaled (i.e. process completed before timeout expired) // WaitOne returns false it the timeout expired before the process completed. if (!autoEvent.WaitOne(timeout)) { string message = "FetcherAsynch call to FetchAsynch timed out. uri " + fetchParameters.Uri; Device.Log.Metric("FetchAsynch timed out: Uri: {0} Time: {1:F0} milliseconds ", uri, DateTime.UtcNow.Subtract(dtMetric).TotalMilliseconds); NetworkResponse networkResponse = new NetworkResponse() { Message = message, URI = fetchParameters.Uri, StatusCode = HttpStatusCode.RequestTimeout, WebExceptionStatusCode = WebExceptionStatus.Timeout, ResponseString = string.Empty, Expiration = DateTime.MinValue.ToUniversalTime(), AttemptToRefresh = DateTime.MinValue.ToUniversalTime(), Downloaded = DateTime.UtcNow, Exception = threadExc }; Device.PostNetworkResponse(networkResponse); return(networkResponse); } else if (threadExc != null) { PostNetworkResponse.Exception = threadExc; PostNetworkResponse.Message = "FetchAsync threw an exception"; PostNetworkResponse.StatusCode = (HttpStatusCode)(-1); } Device.Log.Metric(string.Format("FetchAsynch Completed: Uri: {0} Time: {1:F0} milliseconds Size: {2} ", uri, DateTime.UtcNow.Subtract(dtMetric).TotalMilliseconds, (PostNetworkResponse.ResponseBytes != null ? PostNetworkResponse.ResponseBytes.Length : -1))); return(PostNetworkResponse); }
public FetchOneParameters(FetchParameters <TModel> fetchParameters) : base(fetchParameters) { NoTracking = false; }
private static bool TryCreateUri(FetchParameters fetchParameters, out Uri fetchUri) => Uri.TryCreate(fetchParameters.Url, UriKind.Absolute, out fetchUri) && fetchUri.IsWellFormedOriginalString() && (fetchUri.Scheme == Uri.UriSchemeHttp || fetchUri.Scheme == Uri.UriSchemeHttps);
/// <summary> /// Fetches the specified cache index item from the cache index. /// </summary> /// <param name="cacheIndex">Index of the cache.</param> /// <param name="cacheIndexItem">The cache index item.</param> /// <param name="args">NetworkResourceArguments for the request</param> /// <returns></returns> public NetworkResponse Fetch(CacheIndex cacheIndex, CacheIndexItem cacheIndexItem, NetworkResourceArguments args) //IDictionary<string, string> headers, int timeoutMilliseconds) { PostNetworkResponse = new NetworkResponse(); var fetchParameters = new FetchParameters { CacheIndex = cacheIndex, CacheIndexItem = cacheIndexItem, Headers = args.Headers, DefaultExpiration = args.Expiration, }; int timeoutMilliseconds = args.TimeoutMilliseconds; DateTime dtMetric = DateTime.UtcNow; // set callback and error handler OnDownloadComplete += CacheFetcher_OnDownloadComplete; OnError += CacheFetcher_OnError; Exception threadExc = null; Device.Thread.QueueWorker(parameters => { try { FetchAsynch(parameters, timeoutMilliseconds); } catch (Exception e) { // You could react or save the exception to an 'outside' variable threadExc = e; } finally { _autoEvent.Set(); // if you're firing and not forgetting ;) } }, fetchParameters); // WaitOne returns true if autoEvent were signaled (i.e. process completed before timeout expired) // WaitOne returns false it the timeout expired before the process completed. if (!_autoEvent.WaitOne(timeoutMilliseconds)) { string message = "CacheFetcher call to FetchAsynch timed out. uri " + fetchParameters.CacheIndexItem.RelativeUri; Device.Log.Metric(string.Format("CacheFetcher timed out: Uri: {0} Time: {1:F0} milliseconds ", fetchParameters.CacheIndexItem.RelativeUri, DateTime.UtcNow.Subtract(dtMetric).TotalMilliseconds)); var networkResponse = new NetworkResponse { Message = message, URI = fetchParameters.CacheIndex.GetAbsouteUri(fetchParameters.CacheIndexItem), StatusCode = HttpStatusCode.RequestTimeout, WebExceptionStatusCode = WebExceptionStatus.RequestCanceled, // not using ConnectFailure because connection may have succeeded ResponseString = string.Empty, Expiration = DateTime.MinValue.ToUniversalTime(), Downloaded = DateTime.MinValue.ToUniversalTime(), AttemptToRefresh = DateTime.MinValue.ToUniversalTime(), Exception = threadExc, }; return(networkResponse); } else if (threadExc != null) { PostNetworkResponse.Exception = threadExc; PostNetworkResponse.Message = "CacheFetcher.FetchAsync threw an exception"; PostNetworkResponse.StatusCode = (HttpStatusCode)(-1); } Device.Log.Metric(string.Format("CacheFetcher Completed: Uri: {0} Time: {1:F0} milliseconds ", PostNetworkResponse.URI, DateTime.UtcNow.Subtract(dtMetric).TotalMilliseconds)); return(PostNetworkResponse); }
internal Task <List <TModel> > FetchAsync <TModel>(FetchParameters <TModel> fetchParameters) where TModel : class { return(FormFetchQuery(fetchParameters).ToListAsync()); }
internal List <TModel> Fetch <TModel>(FetchParameters <TModel> fetchParameters) where TModel : class { return(FormFetchQuery(fetchParameters).ToList()); }
/// <summary> /// Synchronous Wrapper method around FetchAsynch() method /// </summary> /// <param name="cacheIndex"></param> /// <param name="cacheIndexItem"></param> public NetworkResponse Fetch(string uri, string filename, Dictionary <string, string> headers) { PostNetworkResponse = new NetworkResponse(); FetchParameters fetchParameters = new FetchParameters() { Uri = uri, Headers = headers, FileName = filename }; DateTime dtMetric = DateTime.UtcNow; // set callback and error handler OnDownloadComplete += new NetworkingEventHandler(FetcherAsynch_OnDownloadComplete); OnError += new NetworkingErrorHandler(FetcherAsynch_OnError); System.Threading.ThreadPool.QueueUserWorkItem(parameters => { try { FetchAsynch(parameters); } //catch ( Exception e ) //{ // // You could react or save the exception to an 'outside' variable // // threadExc = e; //} finally { autoEvent.Set(); // if you're firing and not forgetting ;) } }, fetchParameters); // WaitOne returns true if autoEvent were signaled (i.e. process completed before timeout expired) // WaitOne returns false it the timeout expired before the process completed. if (!autoEvent.WaitOne(DefaultTimeout)) { string message = "FetcherAsynch call to FetchAsynch timed out. uri " + fetchParameters.Uri; MXDevice.Log.Error(message); MXDevice.Log.Debug(string.Format("FetchAsynch timed out: Uri: {0} Time: {1} milliseconds ", uri, DateTime.UtcNow.Subtract(dtMetric).TotalMilliseconds)); NetworkResponse networkResponse = new NetworkResponse() { Message = message, URI = fetchParameters.Uri, StatusCode = HttpStatusCode.RequestTimeout, ResponseString = string.Empty, Expiration = DateTime.MinValue.ToUniversalTime(), }; MXDevice.PostNetworkResponse(networkResponse); return(networkResponse); } //if ( threadExc != null ) //{ // throw threadExc; //} MXDevice.Log.Debug(string.Format("FetchAsynch Completed: Uri: {0} Time: {1} milliseconds Size: {2} ", uri, DateTime.UtcNow.Subtract(dtMetric).TotalMilliseconds, (PostNetworkResponse.ResponseBytes != null ? PostNetworkResponse.ResponseBytes.Length : -1))); return(PostNetworkResponse); }
private static void InsertFetchParameters(FetchParameters parameters, IList<ICommandArgument> args) { if(parameters.All) { args.Add(FetchCommand.All()); } if(parameters.Append) { args.Add(FetchCommand.Append()); } if(parameters.Prune) { args.Add(FetchCommand.Prune()); } if(parameters.Depth != 0) { args.Add(FetchCommand.Depth(parameters.Depth)); } switch(parameters.TagFetchMode) { case TagFetchMode.Default: break; case TagFetchMode.AllTags: args.Add(FetchCommand.Tags()); break; case TagFetchMode.NoTags: args.Add(FetchCommand.NoTags()); break; } if(parameters.KeepDownloadedPack) { args.Add(FetchCommand.Keep()); } if(parameters.Force) { args.Add(FetchCommand.Force()); } if(!string.IsNullOrWhiteSpace(parameters.UploadPack)) { args.Add(FetchCommand.UploadPack(parameters.UploadPack)); } if(!string.IsNullOrWhiteSpace(parameters.Repository)) { args.Add(new CommandParameter(parameters.Repository)); } }
public Command GetFetchCommand(FetchParameters parameters, bool isAsync) { Assert.IsNotNull(parameters); var args = new List<ICommandArgument>(10); InsertFetchParameters(parameters, args); if(isAsync && GitFeatures.ProgressFlag.IsAvailableFor(_gitCLI)) { args.Add(FetchCommand.Progress()); } return new FetchCommand(args); }
private void FetchAsynch(Object parameters) { FetchParameters fetchParameters = (FetchParameters)parameters; HttpWebRequest request = (HttpWebRequest)WebRequest.Create(fetchParameters.Uri); request.Method = "GET"; if (fetchParameters.Headers != null && fetchParameters.Headers.Any()) { foreach (string key in fetchParameters.Headers.Keys) { var keyValue = key.ToLower(); if (keyValue == "accept") { request.Accept = fetchParameters.Headers[key]; } else if (keyValue == "content-type") { request.ContentType = fetchParameters.Headers[key]; } else if (keyValue == "host") { request.Host = fetchParameters.Headers[key]; } else if (keyValue == "accept-encoding") { string encodingValue = fetchParameters.Headers[key]; if (encodingValue.ToLower().Contains("gzip")) { request.AutomaticDecompression = DecompressionMethods.GZip; } } else { request.Headers[key] = fetchParameters.Headers[key]; } } } FetcherAsynch.RequestState state = new FetcherAsynch.RequestState() { Request = request, AbsoluteUri = fetchParameters.Uri, FileName = fetchParameters.FileName, Downloaded = DateTime.UtcNow }; try { // Start the asynchronous request. IAsyncResult result = request.BeginGetResponse(new AsyncCallback(ResponseCallback), state); #if NETCF if (!allDone.WaitOne(fetchParameters.Timeout, false)) #else if (!allDone.WaitOne(fetchParameters.Timeout)) #endif { try { request.Abort(); } catch (Exception) { } // .Abort() always throws exception return; } } catch (Exception exc) { Device.Log.Error("FetcherAsynch.FetchAsynch encountered exception", exc); autoEvent.Set(); } }