C# Data.JsonDocument类代码示例

        public override bool TryResolve(
            string id,
            RavenJObject metadata,
            RavenJObject document,
            JsonDocument existingDoc)
        {
            if (id.StartsWith("Raven/", StringComparison.OrdinalIgnoreCase) &&
                !id.StartsWith("Raven/Hilo/", StringComparison.OrdinalIgnoreCase))
            {
                return false;
            }

            try
            {
                this.ResolveConflict(id, metadata, document, existingDoc);
            }
            catch (Exception exception)
            {
                this.log.ErrorException(
                    string.Format(
                        "An exception occured while attempting to resolve a replication conflict for document '{0}'. The incoming document will be saved.",
                        id),
                    exception);
            }

            return true;
        }

        private void HandleConflictedDocument(JsonDocument document, TransactionInformation transactionInformation)
        {
            var conflicts = document.DataAsJson.Value<RavenJArray>("Conflicts");
            var currentSource = Database.TransactionalStorage.Id.ToString();
            var historySet = false;

            foreach (var c in conflicts)
            {
                RavenJObject conflict;
                if (Database.Documents.Delete(c.Value<string>(), null, transactionInformation, out conflict) == false)
                    continue;

                if (historySet)
                    continue;

                var conflictSource = conflict.Value<RavenJValue>(Constants.RavenReplicationSource).Value<string>();

                if (conflictSource != currentSource)
                    continue;

                deletedHistory.Value = new RavenJArray
                {
                    new RavenJObject
                    {
                        { Constants.RavenReplicationVersion, conflict[Constants.RavenReplicationVersion] },
                        { Constants.RavenReplicationSource, conflict[Constants.RavenReplicationSource] }
                    }
                };

                historySet = true;
            }
        }

        protected void AddToContext(string key, JsonDocument document)
        {
			if(string.IsNullOrEmpty(key) || key.EndsWith("/"))
				incompleteDocumentKeyContext.Add(document);
			else
				documentKeyContext[key] = document;
        }

		private bool CanBeConsideredAsDuplicate(JsonDocument document)
		{
			if (document.Metadata[Constants.RavenReplicationConflict] != null)
				return false;

			return true;
		}

		public void Add(JsonDocument value)
		{
            Debug.Assert(slim.IsWriteLockHeld);
		    var index = CalculateEtagIndex(value.Etag);
		    innerList.Insert(index, value);
		    loadedSize += value.SerializedSizeOnDisk;
		}

			public bool TryResolveConflict(string key, JsonDocument[] conflictedDocs, out JsonDocument resolvedDocument)
			{
				var maxDate = conflictedDocs.Max(x => x.LastModified);
				resolvedDocument = conflictedDocs.FirstOrDefault(x => x.LastModified == maxDate);

				return resolvedDocument != null;
			}

			public bool TryResolveConflict(string key, JsonDocument[] conflictedDocs, out JsonDocument resolvedDocument)
			{
				if (conflictedDocs == null || !conflictedDocs.Any())
				{
					resolvedDocument = null;
					return false;
				}

				if (key.StartsWith("Raven/"))
				{
					resolvedDocument = null;
					return false;
				}

				var maxDate = conflictedDocs.Max(x => x.Metadata.Value<DateTimeOffset>(Constants.RavenLastModified));

				resolvedDocument =
					conflictedDocs.FirstOrDefault(x => x.Metadata.Value<DateTimeOffset>(Constants.RavenLastModified) == maxDate);
				if (resolvedDocument != null)
				{
					// Do the logging before we override the metadata
					resolvedDocument.Metadata.Remove("@id");
					resolvedDocument.Metadata.Remove("@etag");
					resolvedDocument.Metadata.Remove(Constants.RavenReplicationConflict);
					resolvedDocument.Metadata.Remove(Constants.RavenReplicationConflictDocument);
				}

				return resolvedDocument != null;
			}

		private void HandleConflictedDocument(JsonDocument document, TransactionInformation transactionInformation)
		{
			var conflicts = document.DataAsJson.Value<RavenJArray>("Conflicts");
			var currentSource = Database.TransactionalStorage.Id.ToString();

			foreach (var c in conflicts)
			{
				var conflict = Database.Get(c.Value<string>(), transactionInformation);
				var conflictSource = conflict.Metadata.Value<RavenJValue>(Constants.RavenReplicationSource).Value<string>();

				if (conflictSource != currentSource)
					continue;

				this.deletedHistory.Value = new RavenJArray
				{
					new RavenJObject
					{
						{ Constants.RavenReplicationVersion, conflict.Metadata[Constants.RavenReplicationVersion] },
						{ Constants.RavenReplicationSource, conflict.Metadata[Constants.RavenReplicationSource] }
					}
				};

				return;
			}
		}

		public void AfterStorageCommitBeforeWorkNotifications(PrefetchingUser user, JsonDocument[] documents)
		{
			PrefetchingBehavior value;
			if (prefetchingBehaviors.TryGetValue(user, out value) == false)
				return;
			value.AfterStorageCommitBeforeWorkNotifications(documents);
		}

        private IList<ColumnDefinition> PickLikelyColumns(JsonDocument[] sampleDocuments, string context, IList<PriorityColumn> priorityColumns)
        {
            if (priorityColumns == null || priorityColumns.Count == 0)
            {
                priorityColumns = DefaultPriorityColumns;
            }

            // only consider nested properties if any of the priority columns refers to a nested property
            var includeNestedProperties = priorityColumns.Any(c => c.PropertyNamePattern.Contains("\\."));

			var columns = DocumentHelpers.GetPropertiesFromDocuments(sampleDocuments, includeNestedProperties)
				.GroupBy(p => p)
				.Select(g => new { Property = g.Key, Occurence = g.Count() / (double)sampleDocuments.Length })
				.Select(p => new { p.Property, Importance = p.Occurence + ImportanceBoost(p.Property, context, priorityColumns) })
				.OrderByDescending(p => p.Importance)
				.ThenBy(p => p.Property)
				.Select(p => new ColumnDefinition
								 {
									 Binding = p.Property,
									 Header = p.Property,
									 DefaultWidth = GetDefaultColumnWidth(p.Property, priorityColumns)
								 })
				.Take(6)
				.ToList();

            return columns;
        }

		public void AfterStorageCommitBeforeWorkNotifications(PrefetchingUser user, JsonDocument[] documents)
		{
			foreach (var prefetcher in prefetchingBehaviors.Where(x => x.PrefetchingUser == user))
			{
				prefetcher.AfterStorageCommitBeforeWorkNotifications(documents);
			}
		}

		public override bool TryResolve(string id, RavenJObject metadata, RavenJObject document, JsonDocument existingDoc,
		                                Func<string, JsonDocument> getDocument, out RavenJObject metadataToSave,
		                                out RavenJObject documentToSave)
		{
			var existingDocumentIsInConflict = existingDoc.Metadata[Constants.RavenReplicationConflict] != null;
			var existingDocumentIsDeleted = existingDoc.Metadata[Constants.RavenDeleteMarker] != null
			                                && existingDoc.Metadata[Constants.RavenDeleteMarker].Value<bool>();

			metadataToSave = null;
			documentToSave = null;

			if (existingDocumentIsInConflict && existingDocumentIsDeleted == false)
			{
				var conflictIds =
					existingDoc.DataAsJson.Value<RavenJArray>("Conflicts")
					           .Select(x => x.Value<string>())
					           .ToArray();

				if (conflictIds.Length == 0) return false;

				if (conflictIds
					    .Select(getDocument)
					    .Where(x => x != null)
					    .All(doc => Historian.IsDirectChildOfCurrent(metadata, doc.Metadata)) == false)
					return false;

				metadataToSave = metadata;
				documentToSave = document;

				return true;
			}

			return false;
		}

        public void Add(JsonDocument value)
        {
            Debug.Assert(slim.IsWriteLockHeld);

            innerList[value.Etag] = value;

            loadedSize += value.SerializedSizeOnDisk;
        }

		protected override bool TryResolve(string id, RavenJObject metadata, RavenJObject document, JsonDocument existingDoc,
		                                Func<string, JsonDocument> getDocument, out RavenJObject metadataToSave,
		                                out RavenJObject documentToSave)
		{
			metadataToSave = metadata;
			documentToSave = document;

			return true;
		}

 private IList<string> CreateSuggestedBindingsFromDocuments(JsonDocument[] jsonDocuments)
 {
     var bindings = DocumentHelpers.GetPropertiesFromDocuments(jsonDocuments, true).Distinct()
         .Concat(DocumentHelpers.GetMetadataFromDocuments(jsonDocuments, true).Distinct().Select(b => "$Meta:" + b))
         .Concat(new[] {"$JsonDocument:Etag", "$JsonDocument:LastModified", "$Temp:Score"})
         .ToArray();
     
     return bindings;
 }