C# Etag.CompareTo方法代码示例

        private void SeekMissingEtagsFrom(Etag lastKnownEtag, Etag destinationEtag)
        {
            if (lastKnownEtag.CompareTo(destinationEtag) >= 0) return;

            TransactionalStorage.Batch(accessor =>
            {
                lastKnownEtag = UpdatePerCollectionEtags(
                    accessor.Documents.GetDocumentsAfter(lastKnownEtag, 1000));
            });

            if(lastKnownEtag != null)
                SeekMissingEtagsFrom(lastKnownEtag, destinationEtag);
        }

		private async void WaitForReplicationFromServerAsync(string url, AsyncCountdownEvent countDown, Etag etag, BlockingCollection<Exception> errors)
		{
			try
			{
				while (countDown.Active)
				{
					var etags = await GetReplicatedEtagsFor(url);

					var replicated = etag.CompareTo(etags.DocumentEtag) <= 0 || etag.CompareTo(etags.AttachmentEtag) <= 0;

					if (!replicated)
					{
						if (countDown.Active)
						{
#if NET45
							await Task.Delay(100);
#else
							await TaskEx.Delay(100);
#endif
						}
						continue;
					}
					countDown.Signal();
					return;
				}
			}
			catch (Exception ex)
			{
				errors.Add(ex);
				countDown.Error();
			}
		}

		public void CleanupDocuments(Etag lastIndexedEtag)
		{
			foreach (var docToRemove in documentsToRemove)
			{
				if (docToRemove.Value.All(etag => lastIndexedEtag.CompareTo(etag) > 0) == false)
					continue;

				HashSet<Etag> _;
				documentsToRemove.TryRemove(docToRemove.Key, out _);
			}

			updatedDocumentsLock.EnterWriteLock();
			try
			{
				updatedDocuments.RemoveSmallerOrEqual(lastIndexedEtag);
			}
			finally
			{
				updatedDocumentsLock.ExitWriteLock();
			}

			JsonDocument result;
			while (prefetchingQueue.TryPeek(out result) && lastIndexedEtag.CompareTo(result.Etag) >= 0)
			{
				prefetchingQueue.TryDequeue(out result);
			}
		}

		private bool TryGetDocumentsFromQueue(Etag nextDocEtag, List<JsonDocument> items)
		{
			JsonDocument result;

			nextDocEtag = HandleEtagGapsIfNeeded(nextDocEtag);
			bool hasDocs = false;

			while (items.Count < autoTuner.NumberOfItemsToIndexInSingleBatch && 
				prefetchingQueue.TryPeek(out result) && 
				// we compare to current or _smaller_ so we will remove from the queue old versions
				// of documents that we have already loaded
				nextDocEtag.CompareTo(result.Etag) >= 0)
			{
				// safe to do peek then dequeue because we are the only one doing the dequeues
				// and here we are single threaded, but still, better to check
				if (prefetchingQueue.TryDequeue(out result) == false)
					continue;

                // this shouldn't happen, but... 
                if(result == null)
                    continue;

				if (result.Etag != nextDocEtag)
					continue;

				items.Add(result);
				hasDocs = true;

				nextDocEtag = Abstractions.Util.EtagUtil.Increment(nextDocEtag, 1);
				nextDocEtag = HandleEtagGapsIfNeeded(nextDocEtag);
			}

			return hasDocs;
		}

		public void Update(string collectionName, Etag etag)
		{
			lastCollectionEtags.AddOrUpdate(collectionName, new Entry { Etag = etag, Updated = SystemTime.UtcNow }, (existingEntity, existingEtagEntry) =>
			{
				if (etag.CompareTo(existingEtagEntry.Etag) > 0)
				{
					existingEtagEntry.Etag = etag;
					existingEtagEntry.Updated = SystemTime.UtcNow;
				}

				return existingEtagEntry;
			});
		}

 private void RemoveOutdatedFutureIndexBatches(Etag etag)
 {
     foreach (FutureIndexBatch source in futureIndexBatches.Values.Where(x => etag.CompareTo(x.StartingEtag) > 0))
     {
         ObserveDiscardedTask(source);
         if (source.CancellationTokenSource != null)
             source.CancellationTokenSource.Cancel();
         FutureIndexBatch batch;
         futureIndexBatches.TryRemove(source.StartingEtag, out batch);
     }
 }

        private void HandleCollectingDocumentsAfterCommit(Etag requestedEtag)
        {
            if (ShouldHandleUnusedDocumentsAddedAfterCommit == false)
                return;

            var current = lowestInMemoryDocumentAddedAfterCommit;
            if (DisableCollectingDocumentsAfterCommit)
            {
                if (current != null && requestedEtag.CompareTo(current.Etag) > 0)
                {
                    lowestInMemoryDocumentAddedAfterCommit = null;
                    DisableCollectingDocumentsAfterCommit = false;
                    numberOfTimesIngestRateWasTooHigh = 0;
                }
            }
            else if (current != null)
            {
                var oldestTimeInQueue = SystemTime.UtcNow - current.AddedAt;
                if (
                    // this can happen if we have a very long indexing time, which takes
                    // us a long while to process, so we might as might as well stop keeping
                    // stuff in memory, because we lag
                    oldestTimeInQueue > TimeSpan.FromMinutes(10)
                    )
                {
                    DisableCollectingDocumentsAfterCommit = true;
                    // If we disable in memory collection of data, we need to also remove all the
                    // items in the prefetching queue that are after the last in memory docs
                    // immediately, not wait for them to be indexed. They have already been in 
                    // memory for ten minutes
                    // But not if our time has finally been reached
                    if (requestedEtag.CompareTo(current.Etag) >= 0)
                        prefetchingQueue.RemoveAfter(current.Etag);
                }
            }
        }

		public void Update(string collectionName, Etag etag)
		{
			lastCollectionEtags.AddOrUpdate(collectionName, etag, (existingEntity, existingEtag) => etag.CompareTo(existingEtag) > 0 ? etag : existingEtag);
		}

		public IEnumerable<ListItem> Read(string name, Etag start, Etag end, int take)
		{
			var listsByName = tableStorage.Lists.GetIndex(Tables.Lists.Indices.ByName);

			using (var iterator = listsByName.MultiRead(Snapshot, CreateKey(name)))
			{
				if (!iterator.Seek(start.ToString()))
					yield break;

				int count = 0;

				do
				{
					var etag = Etag.Parse(iterator.CurrentKey.ToString());
					if (start.CompareTo(etag) >= 0)
						continue;

					if (end != null && end.CompareTo(etag) <= 0)
						yield break;

					count++;
					yield return ReadInternal(etag);
				}
				while (iterator.MoveNext() && count < take);
			}
		}

 private void UpdateLastEtagForCollection(string collectionName, Etag etag)
 {
     lastCollectionEtags.AddOrUpdate(collectionName, etag,
         (v, oldEtag) => etag.CompareTo(oldEtag) < 0 ? oldEtag : etag);
 }

 private void RemoveOutdatedFutureIndexBatches(Etag etag)
 {
     foreach (FutureIndexBatch source in futureIndexBatches.Values.Where(x => etag.CompareTo(x.StartingEtag) > 0))
     {
         ObserveDiscardedTask(source);
         var cts = source.CancellationTokenSource;
         if (cts != null)
         {
             try
             {
                 cts.Cancel();
             }
             catch (ObjectDisposedException)
             {
                 // this is expected with a race against the prefetching queue
                 
             }
         }
         FutureIndexBatch batch;
         futureIndexBatches.TryRemove(source.StartingEtag, out batch);
     }
 }

		private void HandleCollectingDocumentsAfterCommit(Etag reqestedEtag)
		{
			if(ShouldHandleUnusedDocumentsAddedAfterCommit == false)
				return;

			if (DisableCollectingDocumentsAfterCommit)
			{
				if (lowestInMemoryDocumentAddedAfterCommit != null && reqestedEtag.CompareTo(lowestInMemoryDocumentAddedAfterCommit.Etag) > 0)
				{
					lowestInMemoryDocumentAddedAfterCommit = null;
					DisableCollectingDocumentsAfterCommit = false;
				}
			}
			else
			{
				if (lowestInMemoryDocumentAddedAfterCommit != null && SystemTime.UtcNow - lowestInMemoryDocumentAddedAfterCommit.AddedAt > TimeSpan.FromMinutes(10))
				{
					DisableCollectingDocumentsAfterCommit = true;
				}
			}
		}

        /// <summary>
        /// Gets the minimum etag from the future batches that is bigger than the startEtag
        /// </summary>
        /// <param name="startEtag">The minimum etag we start to look from</param>
        /// <returns></returns>
        private Etag GetMinimumEtagFromFutureBatches(Etag startEtag)
        {
            Etag minEtag = null;

            foreach (var futureIndexBatch in futureIndexBatches.Values)
            {
                if (startEtag.CompareTo(futureIndexBatch.StartingEtag) < 0 &&
                    (minEtag == null || futureIndexBatch.StartingEtag.CompareTo(minEtag) < 0))
                {
                    minEtag = futureIndexBatch.StartingEtag;
                }
            }

            if (minEtag != null && minEtag != Etag.Empty)
                minEtag = Abstractions.Util.EtagUtil.Increment(minEtag, -1);

            return minEtag;
        }

        public void CleanupDocuments(Etag lastIndexedEtag)
        {
            if (lastIndexedEtag == null)
                return;

            foreach (var docToRemove in documentsToRemove)
            {
                if (docToRemove.Value == null)
                    continue;
                if (docToRemove.Value.All(etag => lastIndexedEtag.CompareTo(etag) > 0) == false)
                    continue;

                HashSet<Etag> _;
                documentsToRemove.TryRemove(docToRemove.Key, out _);
            }

            HandleCleanupOfUnusedDocumentsInQueue();
        }

        private async Task WaitForReplicationFromServerAsync(string url, string sourceUrl, string sourceDbId, Etag etag, ReplicatedEtagInfo[] latestEtags, int index, CancellationToken cancellationToken)
        {
            while (true)
            {
                cancellationToken.ThrowIfCancellationRequested();

                try
                {
                    var etags = await GetReplicatedEtagsFor(url, sourceUrl, sourceDbId);

                    latestEtags[index] = etags;

                    var replicated = etag.CompareTo(etags.DocumentEtag) <= 0;

                    if (replicated)
                        return;
                }
                catch (Exception e)
                {
                    log.DebugException(string.Format("Failed to get replicated etags for '{0}'.", sourceUrl), e);

                    throw;
                }

                await Task.Delay(100, cancellationToken);
            }
        }