问.net - api调用阻塞了其他api调用。

EN

       public async Task<ActionResult> GrantAccesstoUsers()
      {
         // other operations
         var grantResult = await 
         this._workSpaceProvider.GrantUserAccessAsync(this.CurrentUser.Id).ConfigureAwait(false);

         return this.Ok(result);
     }

        public async Task<List<WorkspaceDetail>> GrantUserAccessAsync(string currentUser)
        {
            var responselist = new List<WorkspaceDetail>();

            try
            {
                // calling these prematurely to be reused once threads are created
// none expensive calls
                var properlyNamedWorkSpaces = await this._helper.GetProperlyNamedWorkspacesAsync(true).ConfigureAwait(false);
                var dbGroups = await this._reportCatalogProvider.GetWorkspaceFromCatalog().ConfigureAwait(false);
                var catalogInfo = await this._clientServiceHelper.GetDatabaseConfigurationAsync("our-service").ConfigureAwait(false);

                if (properlyNamedWorkSpaces != null && properlyNamedWorkSpaces.Count > 0)
                {
// these methods returns tasks for parallel processing
                    var grantUserContributorAccessTaskList = await this.GrantUserContributorAccessTaskList(properlyNamedWorkSpaces, currentUser, dbGroups, catalogInfo).ConfigureAwait(false);
                    var grantUserAdminAccessTaskList = await this.GrantUserAdminAccessTaskList(properlyNamedWorkSpaces, currentUser, dbGroups, catalogInfo).ConfigureAwait(false);
                    var removeInvalidUserAndSPNTaskList = await this.RemoveAccessRightsToWorkspaceTaskList(properlyNamedWorkSpaces, dbGroups, currentUser, catalogInfo).ConfigureAwait(false);

                    var tasklist = new List<Task<WorkspaceDetail>>();
                    tasklist.AddRange(grantUserContributorAccessTaskList);
                    tasklist.AddRange(grantUserAdminAccessTaskList);
                    tasklist.AddRange(removeInvalidUserAndSPNTaskList);

                    // Start running Parallel Task
                    Parallel.ForEach(tasklist, task =>
                    {
                        Task.Delay(this._config.CurrentValue.PacingDelay);
                        task.Start();
                    });

                    // Get All Client Worspace Processing Results
                    var clientWorkspaceProcessingResult = await Task.WhenAll(tasklist).ConfigureAwait(false);

                    // Populate result
                    responselist.AddRange(clientWorkspaceProcessingResult.ToList());
                }
            }
            catch (Exception)
            {
                throw;
            }

            return responselist;
        }

private async Task<List<Task<WorkspaceDetail>>> GrantUserContributorAccessTaskList(List<Group> workspaces, string currentUser, List<WorkspaceManagement> dbGroups, DatabaseConfig catalogInfo)
        {
            var tasklist = new List<Task<WorkspaceDetail>>();

            foreach (var workspace in workspaces)
            {
                tasklist.Add(new Task<WorkspaceDetail>(() =>
                this.GrantContributorAccessToUsers(workspace, currentUser, dbGroups, catalogInfo).Result));
                // i added a delay here because we encountered an issue before in production and this seems to solve the problem. this is set to 4ms.
                Task.Delay(this._config.CurrentValue.DelayInMiliseconds);
            }

            return tasklist;
        }

private async Task<WorkspaceDetail> GrantContributorAccessToUsers(Group workspace, string currentUser, List<Data.ReportCatalogDB.WorkspaceManagement> dbGroups, DatabaseConfig catalogInfo)
        {
            // This prevents other thread or task to start and prevents exceeding the number of threads allowed
            await this._batchProcessor.WaitAsync().ConfigureAwait(false);

            var result = new WorkspaceDetail();

            try
            {
                
                var contributorAccessresult = await this.helper.GrantContributorAccessToUsersAsync(workspace, this._powerBIConfig.CurrentValue.SPNUsers).ConfigureAwait(false);

                if (contributorAccessresult != null 
                    && contributorAccessresult.Count > 0)
                {
                    // do something
                }
                else
                {
                    // do something
                }

// this is done to reuse the call that is being executed in the helper above. it's an expensive call from an external endpoint so we opted to reuse what was used in the initial call, instead of calling it again for this process
                var syncWorkspaceAccessToDb = await this.SyncWorkspaceAccessAsync(currentUser, workspace.Id, contributorAccessresult, dbGroups, catalogInfo).ConfigureAwait(false);

                foreach (var dbResponse in syncWorkspaceAccessToDb) {

                    result.ResponseMessage += dbResponse.ResponseMessage;
                }
            }
            catch (Exception ex)
            {
                this._loghelper.LogEvent(this._logger, logEvent, OperationType.GrantContributorAccessToWorkspaceManager, LogEventStatus.FAIL);

            }
            finally
            {
                this._batchProcessor.Release();
            }

            return result;
        }

private async Task<List<WorkspaceDetail>> SyncWorkspaceAccessAsync(string currentUser,
            Guid workspaceId,
            List<GroupUser> groupUsers,
            List<WorkspaceManagement> dbGroups,
            DatabaseConfig catalogInfo) {

            var result = new List<WorkspaceDetail>();

            var tasklist = new List<Task<WorkspaceDetail>>();

            // get active workspace details from the db
            var workspace = dbGroups.Where(x => x.PowerBIGroupId == workspaceId).FirstOrDefault();

            try
            {
                // to auto dispose the provider, we are creating this for each instance because 
                // having only one instance creates an error when the other task starts running
                using (var contextProvider = this._contextFactory.GetReportCatalogProvider(
                        catalogInfo.Server,
                        catalogInfo.Database,
                        catalogInfo.Username,
                        catalogInfo.Password,
                        this._dbPolicy))
                {
                    if (workspace != null)
                    {
                        // get current group users in the db from the workspace object
                        var currentDbGroupUsers = workspace.WorkspaceAccess.Where(w => w.Id == workspace.Id
                                                                                && w.IsDeleted == false).ToList();
                        #region identify to process

                        #region users to add
                        // identify users to add
                        var usersToAdd = groupUsers.Where(g => !currentDbGroupUsers.Any(w => w.Id == workspace.Id ))
                                                                    .Select(g => new WorkspaceAccess
                                                                    {

                                                                        // class properties

                                                                    }).ToList();
                        #endregion

                        var addTasks = await this.AddWorkspaceAccessToDbTask(catalogProvider, usersToAdd, workspace.PowerBIGroupId, workspace.WorkspaceName).ConfigureAwait(false);
                        
                        tasklist.AddRange(addTasks);

                        // this is a potential fix that i did, hoping adding another parallel thread can solve the problem
                        Parallel.ForEach(tasklist, new ParallelOptions { MaxDegreeOfParallelism = this._config.CurrentValue.MaxDegreeOfParallelism }, task =>
                        {
                            Task.Delay(this._config.CurrentValue.PacingDelay);
                            task.Start();
                        });

                        var processResult = await Task.WhenAll(tasklist).ConfigureAwait(false);

                        // Populate result
                        result.AddRange(processResult.ToList());

                    } 
                }

            }
            catch (Exception ex)
            {
                // handle error
            }

            return result;
        }

Task.Delay(this._config.CurrentValue.DelayInMiliseconds);