C# Indexes.AbstractIndexCreationTask类代码示例

        /// <summary>
        /// Build a single index asynchronously
        /// </summary>
        /// <param name="indexInstance">An activated AbstractIndexCreationTask instance</param>
        /// <param name="progressCallBack">A callback we can use to report on the progress of a batch job; default is null</param>
        /// <returns>A task containing an IndexBuildResult report for this specific index</returns>
        public Task<IndexBuildResult> BuildIndexAsync(AbstractIndexCreationTask indexInstance, Action<IndexBuildResult> progressCallBack = null)
        {
            return Task.Factory.StartNew(() => indexInstance.Execute(_documentStore))
                .ContinueWith(result =>
                                  {
                                      var indexBuildResult = new IndexBuildResult()
                                                                 {IndexName = indexInstance.IndexName, ConnectionString = _documentStore.Identifier};

                                      if (result.IsCompleted && result.Exception == null)
                                      {
                                          indexBuildResult.Result = BuildResult.Created;
                                      }
                                      else if (result.IsCanceled)
                                      {
                                          indexBuildResult.Result = BuildResult.Cancelled;
                                      }
                                      else
                                      {
                                          indexBuildResult.Result = BuildResult.Failed;
                                          indexBuildResult.BuildException = result.Exception != null ? result.Exception.Flatten() : null;
                                      }

                                      if (progressCallBack != null)
                                      {
                                          progressCallBack.Invoke(indexBuildResult);
                                      }

                                      return indexBuildResult;
                                  });
        }

        /// <summary>
        /// Build a single index synchronously
        /// </summary>
        /// <param name="indexInstance">An activated AbstractIndexCreationTask instance</param>
        /// <returns>An IndexBuildResult report for this specific index</returns>
        public IndexBuildResult BuildIndex(AbstractIndexCreationTask indexInstance)
        {
            var buildIndexTask = BuildIndexAsync(indexInstance, null);

            buildIndexTask.Wait();

            return buildIndexTask.Result;
        }

        public void PutIndex(AbstractIndexCreationTask index)
        {
            var response = httpClient
                .PutAsync(databaseUrl + "/indexes/" + Uri.EscapeUriString(index.IndexName), new JsonContent(RavenJObject.FromObject(index.CreateIndexDefinition())))
                .ResultUnwrap();

            if (response.IsSuccessStatusCode == false)
                throw new InvalidOperationException(string.Format("PUT failed on '{0}'. Code: {1}.", index.IndexName, response.StatusCode));
        }

 /// <summary>
 /// Safely add the index to the RavenDB database, protect against possible failures caused by documented
 /// and undocumented possibilities of failure.
 /// Will throw iff index registration failed and index doesn't exist or it exists but with a non-current definition.
 /// </summary>
 /// <param name="store"></param>
 /// <param name="index"></param>
 internal static void SafelyCreateIndex(IDocumentStore store, AbstractIndexCreationTask index)
 {
     try
     {
         index.Execute(store);
     }
     catch (Exception) // Apparently ArgumentException can be thrown as well as a WebException; not taking any chances
     {
         var existingIndex = store.DatabaseCommands.GetIndex(index.IndexName);
         if (existingIndex == null || !index.CreateIndexDefinition().Equals(existingIndex))
             throw;
     }
 }

	    public void SideBySideExecuteIndex(AbstractIndexCreationTask indexCreationTask, Etag minimumEtagBeforeReplace = null, DateTime? replaceTimeUtc = null)
	    {
			Inner.SideBySideExecuteIndex(indexCreationTask, minimumEtagBeforeReplace, replaceTimeUtc);
	    }

	    /// <summary>
        ///     Executes the index creation.
        /// </summary>
        /// <param name="indexCreationTask"></param>
        public Task ExecuteIndexAsync(AbstractIndexCreationTask indexCreationTask)
        {
            return server.DocumentStore.ExecuteIndexAsync(indexCreationTask);
        }

 /// <summary>
 ///     Executes the index creation.
 /// </summary>
 public void ExecuteIndex(AbstractIndexCreationTask indexCreationTask)
 {
     server.DocumentStore.ExecuteIndex(indexCreationTask);
 }

		public override Task SideBySideExecuteIndexAsync(AbstractIndexCreationTask indexCreationTask, Etag minimumEtagBeforeReplace = null, DateTime? replaceTimeUtc = null)
		{
			var list = ShardStrategy.Shards.Values.Select(x => x.AsyncDatabaseCommands).ToList();
			return ShardStrategy.ShardAccessStrategy.ApplyAsync(list, new ShardRequestData(), (commands, i) =>
			{
				var tcs = new TaskCompletionSource<bool>();

				try
				{
					indexCreationTask.SideBySideExecuteAsync(commands, Conventions, minimumEtagBeforeReplace, replaceTimeUtc)
									 .ContinueWith(t => tcs.SetResult(true));
				}
				catch (Exception e)
				{
					tcs.SetException(e);
				}

				return tcs.Task;
			});
		}

 public void ExecuteIndex(AbstractIndexCreationTask indexCreationTask)
 {
     this.ThrowIfNotInitialized();
     this.innerStore.ExecuteIndex(indexCreationTask);
 }

 public Task ExecuteIndexAsync(AbstractIndexCreationTask indexCreationTask)
 {
     return Inner.ExecuteIndexAsync(indexCreationTask);
 }

		/// <summary>
		/// Executes the index creation against each of the shards.
		/// </summary>
		public override void ExecuteIndex(AbstractIndexCreationTask indexCreationTask)
		{
			var list = ShardStrategy.Shards.Values.Select(x => x.DatabaseCommands).ToList();
			ShardStrategy.ShardAccessStrategy.Apply(list,
															new ShardRequestData()
															, (commands, i) =>
															{
																indexCreationTask.Execute(commands, Conventions);
																return (object)null;
															});
		}

	    public virtual Task ExecuteIndexAsync(AbstractIndexCreationTask indexCreationTask)
	    {
	        return indexCreationTask.ExecuteAsync(AsyncDatabaseCommands, Conventions);
	    }

		/// <summary>
		/// Executes the index creation in side-by-side mode.
		/// </summary>
		public virtual Task SideBySideExecuteIndexAsync(AbstractIndexCreationTask indexCreationTask, Etag minimumEtagBeforeReplace = null, DateTime? replaceTimeUtc = null)
		{
			return indexCreationTask.SideBySideExecuteAsync(AsyncDatabaseCommands, Conventions, minimumEtagBeforeReplace, replaceTimeUtc);
		}

		/// <summary>
		/// Executes the index creation in side-by-side mode.
		/// </summary>
		public virtual void SideBySideExecuteIndex(AbstractIndexCreationTask indexCreationTask, Etag minimumEtagBeforeReplace = null, DateTime? replaceTimeUtc = null)
		{
			indexCreationTask.SideBySideExecute(DatabaseCommands, Conventions, minimumEtagBeforeReplace, replaceTimeUtc);
		}

	    public Task SideBySideExecuteIndexAsync(AbstractIndexCreationTask indexCreationTask, Etag minimumEtagBeforeReplace = null, DateTime? replaceTimeUtc = null)
	    {
		    return Inner.SideBySideExecuteIndexAsync(indexCreationTask, minimumEtagBeforeReplace, replaceTimeUtc);
	    }