C# c语言中的异步处理#

我有一个服务，它实现了从情绪分析API返回数据的功能。客户端可以从一个或所有引擎请求结果，我希望将所有数据整理在一起。我想异步处理这些数据，并在返回结果集之前等待它们全部完成。我是异步编程新手，我真的不知道如何安排代码以及如何在语法上实现它。下面是我试图实现的一个例子（我知道这不起作用，但你明白了；希望：-）：

private ISEntityResponse ProcessRequest（ISEntityRequest请求，情感引擎服务选择引擎）
{
感伤响应=新感伤响应（）；
List taskList=新列表（）；
foreach（情感引擎服务EngineServices engineService in（情感引擎服务[]）Enum.GetValues（类型（情感引擎服务）））
{
如果（（（int）engineService&（int）selectedEngines）>0）
{
IsEntementEngine=\u engineFactory.GetMotionEngine（engineService，null）；
任务任务=新任务（engine.analysementasync（请求））；
任务列表。添加（任务）；
}
}
如果（taskList.Count>0）
{
IsEntementEngineeResult[]结果=Task.WaitAll（任务列表）；
foreach（结果中的结果）
答复.添加（结果）；
}
返回响应；
}

引擎具有以下engine.AnalysisEntityAsync代码实现：

    public ISentimentEngineResult AnalyseSentiment(ISentimentRequest request)
    {
        try
        {
            MultiLanguageBatchInput sentimentList = SentimentRequestToMicrosoftBatchInput(request, Properties.Settings.Default.DefaultLanguage);
            SentimentBatchResult sentiment = _client.Sentiment(sentimentList);
            KeyPhraseBatchResult keyPhrases = _client.KeyPhrases(sentimentList);
            return MicrosoftBatchResultsToSentimentEngineResult(sentiment, keyPhrases);
        }
        catch (Exception ex)
        {
            _logger.LogMessage(ex,$"{EngineName} threw an unknown exception: ", LoggingLevel.Error);
            throw;
        }
    }
    public async Task<ISentimentEngineResult> AnalyseSentimentAsync(ISentimentRequest request)
    {
        return AnalyseSentiment(request);
    }

public iEntityEngineerResult分析实体（iEntityRequest）
{
尝试
{
MultiLanguageBatchInput感性列表=感性请求到MicrosoftBatchInput（请求、属性、设置、默认值、默认语言）；
感伤BatchResult情绪=_客户情绪（感伤列表）；
KeyPhraseBatchResult关键字短语=_client.keyphases（情感列表）；
将MicrosoftBatchResults返回给EntityEngineeResult（情感、关键短语）；
}
捕获（例外情况除外）
{
_logger.LogMessage（例如，$“{EngineName}引发未知异常：”，LoggingLevel.Error）；
投
}
}
公共异步任务AnalyseSentimentAsync（ISentimentRequest）
{
返回分析实体（请求）；
}

我需要做什么？有没有更好的方法来实现这一点

我到处都找过一个例子，但是我找不到一个能满足我的实现需求的，或者整个方法是完全错误的

谢谢大家

---

Stu.

这是如何将其转换为异步的：

public async Task<ISentimentEngineResult> AnalyseSentimentAsync(ISentimentRequest request)
{
    try
    {
        MultiLanguageBatchInput sentimentList = SentimentRequestToMicrosoftBatchInput(request, Properties.Settings.Default.DefaultLanguage);
        SentimentBatchResult sentiment = await _client.SentimentAsync(sentimentList);
        KeyPhraseBatchResult keyPhrases = await _client.KeyPhrasesAsync(sentimentList);
        return MicrosoftBatchResultsToSentimentEngineResult(sentiment, keyPhrases);
    }
    catch (Exception ex)
    {
        _logger.LogMessage(ex,$"{EngineName} threw an unknown exception: ", LoggingLevel.Error);
        throw;
    }
}

private async Task<ISentimentResponse> ProcessRequestAsync(ISentimentRequest request, SentimentEngineServices selectedEngines)
{
    SentimentResponse response = new SentimentResponse();
    List<Task<ISentimentEngineResult>> taskList = new List<Task<ISentimentEngineResult>>();
    foreach (SentimentEngineServices engineService in (SentimentEngineServices[])Enum.GetValues(typeof(SentimentEngineServices)))
    {
        if (((int)engineService & (int)selectedEngines) > 0)
        {
            ISentimentEngine engine = _engineFactory.GetSentimentEngine(engineService, null);
            Task<ISentimentEngineResult> task = engine.AnalyseSentimentASync(request);
            taskList.Add(task);
        }
    }
    if (taskList.Count > 0)
    {
        ISentimentEngineResult[] results = await Task.WhenAll(taskList);
        foreach (result in results)
            response.Add(results);
    }
    return response;
}

public async Task analysisentimentasync（ISentimentRequest）
{
尝试
{
MultiLanguageBatchInput感性列表=感性请求到MicrosoftBatchInput（请求、属性、设置、默认值、默认语言）；
感伤BatchResult情绪=等待_client.感伤异步（感伤列表）；
KeyphraseBackResult keyPhrases=wait_client.KeyPhrasesAsync（情感列表）；
将MicrosoftBatchResults返回给EntityEngineeResult（情感、关键短语）；
}
捕获（例外情况除外）
{
_logger.LogMessage（例如，$“{EngineName}引发未知异常：”，LoggingLevel.Error）；
投
}
}
专用异步任务流程RequestAsync（IsEntityRequest请求、情感引擎服务selectedEngines）
{
感伤响应=新感伤响应（）；
List taskList=新列表（）；
foreach（情感引擎服务EngineServices engineService in（情感引擎服务[]）Enum.GetValues（类型（情感引擎服务）））
{
如果（（（int）engineService&（int）selectedEngines）>0）
{
IsEntementEngine=\u engineFactory.GetMotionEngine（engineService，null）；
任务任务=引擎.AnalysisEntityAsync（请求）；
任务列表。添加（任务）；
}
}
如果（taskList.Count>0）
{
IsEntementEngineResult[]结果=等待任务.WhenAll（任务列表）；
foreach（结果中的结果）
答复.添加（结果）；
}
返回响应；
}

请记住，您必须从某种事件处理程序调用它。我不知道您使用的是什么框架（wpf、asp.net、windows服务、webapi）。

好的，这里是：

        public ISentimentResponse AnalyseSentiment(ISentimentRequest request, SentimentEngineServices selectedEngines)
        {
            if (selectedEngines == SentimentEngineServices.None) throw new ArgumentException(nameof(selectedEngines));
            ValidateRequest(request);
            return ProcessRequestAsync(request, selectedEngines).Result;
        }
        private async Task<ISentimentResponse> ProcessRequestAsync(ISentimentRequest request, SentimentEngineServices selectedEngines)
        {
            SentimentResponse response = new SentimentResponse();
            List<Task<ISentimentEngineResult>> taskList = new List<Task<ISentimentEngineResult>>();
            foreach (SentimentEngineServices engineService in (SentimentEngineServices[])Enum.GetValues(typeof(SentimentEngineServices)))
            {
                if (((int)engineService & (int)selectedEngines) > 0)
                {
                    ISentimentEngine engine = _engineFactory.GetSentimentEngine(engineService, null);
                    Task<ISentimentEngineResult> task = engine.AnalyseSentimentASync(request);
                    taskList.Add(task);
                }
            }
            if (taskList.Count > 0)
            {
                ISentimentEngineResult[] results = await Task.WhenAll(taskList);
                foreach (var result in results)
                    response.Add(result);
            }
            return response;
        }

public iEntityResponse分析实体（iEntityRequest请求、情感引擎服务选择引擎）
{
如果（selectedEngines==感伤引擎服务.None）抛出新的ArgumentException（nameof（selectedEngines））；
验证请求（请求）；
返回ProcessRequestAsync（请求，selectedEngines）；
}
专用异步任务流程RequestAsync（IsEntityRequest请求、情感引擎服务selectedEngines）
{
感伤响应=新感伤响应（）；
List taskList=新列表（）；
foreach（情感引擎服务EngineServices engineService in（情感引擎服务[]）Enum.GetValues（类型（情感引擎服务）））
{
如果（（（int）engineService&（int）selectedEngines）>0）
{
IsEntementEngine=\u engineFactory.GetMotionEngine（engineService，null）；
任务任务=引擎.AnalysisEntityAsync（请求）；
任务列表。添加（任务）；
}
}
如果（taskList.Count>0）
{
IsEntementEngineResult[]结果=等待任务.WhenAll（任务列表）；
foreach（结果中的var结果）
答复.添加（结果）；
}
返回响应；
}

以及情感界面的实现：

 public async Task<ISentimentEngineResult> AnalyseSentiment(ISentimentRequest request)
        {
            try
            {
                MultiLanguageBatchInput sentimentList = SentimentRequestToMicrosoftBatchInput(request, Properties.Settings.Default.DefaultLanguage);
                SentimentBatchResult sentiment = await _client.SentimentAsync(sentimentList);
                KeyPhraseBatchResult keyPhrases = await _client.KeyPhrasesAsync(sentimentList);
                return MicrosoftBatchResultsToSentimentEngineResult(sentiment, keyPhrases);
            }
            catch (Exception ex)
            {
                _logger.LogMessage(ex,$"{EngineName} threw an unknown exception: ", LoggingLevel.Error);
                throw;
            }
        }

公共异步任务分析实体（IsEntityRequest）
{
尝试
{
MultiLanguageBatchInput感性列表=感性请求到MicrosoftBatchInput（请求，属性.Settin
 public async Task<ISentimentEngineResult> AnalyseSentiment(ISentimentRequest request)
        {
            try
            {
                MultiLanguageBatchInput sentimentList = SentimentRequestToMicrosoftBatchInput(request, Properties.Settings.Default.DefaultLanguage);
                SentimentBatchResult sentiment = await _client.SentimentAsync(sentimentList);
                KeyPhraseBatchResult keyPhrases = await _client.KeyPhrasesAsync(sentimentList);
                return MicrosoftBatchResultsToSentimentEngineResult(sentiment, keyPhrases);
            }
            catch (Exception ex)
            {
                _logger.LogMessage(ex,$"{EngineName} threw an unknown exception: ", LoggingLevel.Error);
                throw;
            }
        }