C# 如何在C中使用异步方法将列表返回给调用方方法#

如果有人能帮忙，我如何在异步函数中将列表返回给调用方方法

这是我的代码，我想返回名为

ResultList

public class ResultData
{
    public int Status { get; set; }
    public string Description { get; set; }
    public int BatchId { get; set; }
}

private static List<Data> ResultList = new List<Data>();

public void TSReCalculation(int piGroupId, int piIssuerId, DateTime pdFromDate, DateTime ldToDate, int piFormulaId, int piIsProcessedType, int piIsSeriesReStart, int piIsPLCalculate, int piIsIncludeEditedScoreint)
{
     Common.callSpForTS(piGroupId, piIssuerId, pdFromDate, ldToDate, piFormulaId, piIsProcessedType, piIsSeriesReStart, piIsPLCalculate, piIsIncludeEditedScoreint);
}

public static async void callSpForTS(int piGroupId, int piIssuerId, DateTime pdFromDate, DateTime ldToDate, int piFormulaId, int piIsProcessedType, int piIsSeriesReStart, int piIsPLCalculate, int piIsIncludeEditedScoreint)
{
            await Task.Run(() =>
            {
                    try
                    {
                        sqlCommand.ExecuteNonQuery();
                        dbModel.ResultData item = new dbModel.ResultData();
                        item.Description= "succesfulll"
                        item.Status = 1;
                        item.BatchId = 100;
                        ResultList.Add(item);
                    }
                    catch (Exception ex)
                    {
                        Common.showMessageBox(ex.Message + "InnerException:" + ex.InnerException, MSG_TYP.Error, "Error Occured");
                    }
            });
        }
}

公共类结果数据
{
公共int状态{get；set；}
公共字符串说明{get；set；}
public int BatchId{get；set；}
}
私有静态列表ResultList=新列表（）；
public void TSRecomculation（int piGroupId、int piIssuerId、DateTime pdFromDate、DateTime ldToDate、int piFormulaId、int piIsProcessedType、int piIsSeriesReStart、int PiisPlcalculated、int PiisIncludedDedScoreInt）
{
Common.callSpForTS（PIGROUP ID、piIssuerId、pdFromDate、ldToDate、piFormulaId、piIsProcessedType、PIISSeriesStart、PIISplCalculated、PIISIncludedScoreInt）；
}
public static async void callSpForTS（int piGroupId、int piIssuerId、DateTime pdFromDate、DateTime ldToDate、int piFormulaId、int piIsProcessedType、int piisPeriesRestart、int piisPlcalCalculate、int piisIncludedScoreInt）
{
等待任务。运行（（）=>
{
尝试
{
sqlCommand.ExecuteNonQuery（）；
dbModel.ResultData项=新的dbModel.ResultData（）；
item.Description=“成功”
项目状态=1；
item.BatchId=100；
结果列表.添加（项）；
}
捕获（例外情况除外）
{
Common.showMessageBox（例如Message+“InnerException:+ex.InnerException，MSG_TYP.Error，“发生错误”）；
}
});
}
}

而不是

公共静态异步无效callSpForTS

，也就是说，您应该保留返回类型

公共静态异步列表callSpForTS

，而不是

无效

返回类型，您的代码中不需要公共

静态列表

---

始终异步

异步代码让我想起了一个故事，一个家伙提到世界悬浮在太空中，一位年长的女士立即向他提出挑战，声称世界靠在一只巨型海龟的背上。当那个男人问海龟站在什么地方时，这位女士回答说：“年轻人，你很聪明，但一路下来都是海龟！”当你把同步代码转换成异步代码时，你会发现，如果异步代码一直在调用，并且被其他异步代码调用（或“向上”如果你愿意的话）。其他人也注意到了异步编程的传播行为，称之为“传染性”或将其比作僵尸病毒。不管是乌龟还是僵尸，异步代码确实会促使周围的代码也是异步的。这种行为在所有类型的异步编程中都是固有的，而不仅仅是新的async/await关键字

“始终异步”意味着您不应该在不仔细考虑后果的情况下混合使用同步和异步代码。特别是，通过调用Task.Wait或Task.Result来阻止异步代码通常是个坏主意。对于那些“埋头于”异步编程的程序员来说，这是一个特别常见的问题，他们只转换应用程序的一小部分，并将其包装在同步API中，以便将应用程序的其余部分与更改隔离开来。不幸的是，他们遇到了死锁问题。在MSDN论坛、堆栈溢出和电子邮件上回答了许多与异步相关的问题后，我可以说，这是异步新手在了解基本知识后提出的最多的问题：“为什么我的部分异步代码会死锁？”

请参阅：

除此之外，您还需要在调用函数中执行

async/wait

public async void TSReCalculation(int piGroupId, int piIssuerId, DateTime pdFromDate, DateTime ldToDate, int piFormulaId, int piIsProcessedType, int piIsSeriesReStart, int piIsPLCalculate, int piIsIncludeEditedScoreint)
{
    var returnvalue =await Common.callSpForTS(piGroupId, piIssuerId, pdFromDate, ldToDate, piFormulaId, piIsProcessedType, piIsSeriesReStart, piIsPLCalculate, piIsIncludeEditedScoreint);
}

public static async Task<List<ResultData>> callSpForTS(int piGroupId, int piIssuerId, DateTime pdFromDate, DateTime ldToDate, int piFormulaId, int piIsProcessedType, int piIsSeriesReStart, int piIsPLCalculate, int piIsIncludeEditedScoreint)
{
         return await Task.Run(() =>
            {
                List<ResultData> ResultList = new List<ResultData>();
                    try
                    {
                        sqlCommand.ExecuteNonQuery();
                        dbModel.ResultData item = new dbModel.ResultData();
                        item.Description= "succesfulll"
                        item.Status = 1;
                        item.BatchId = 100;
                        ResultList.Add(item);
                    }
                    catch (Exception ex)
                    {
                        Common.showMessageBox(ex.Message + "InnerException:" + ex.InnerException, MSG_TYP.Error, "Error Occured");
                    }
                 return ResultList;
            });
        }
}

public async void ts重新计算（int piGroupId、int piIssuerId、DateTime pdFromDate、DateTime ldToDate、int piFormulaId、int piIsProcessedType、int piIsSeriesReStart、int piisplcalcalculate、int piisincludeedscoreint）
{
var returnvalue=await Common.callSpForTS（piGroupId、piIssuerId、pdFromDate、ldToDate、piFormulaId、piIsProcessedType、piisSeriesStart、piisPlcalCalculate、piIsIncludeEditedScoreint）；
}
公共静态异步任务调用forts（int piGroupId、int piIssuerId、DateTime pdFromDate、DateTime ldToDate、int piFormulaId、int piIsProcessedType、int piiseriesrestart、int piIsPLCalculate、int piisincludetedscoreint）
{
返回等待任务。运行（（）=>
{
列表结果列表=新列表（）；
尝试
{
sqlCommand.ExecuteNonQuery（）；
dbModel.ResultData项=新的dbModel.ResultData（）；
item.Description=“成功”
项目状态=1；
item.BatchId=100；
结果列表.添加（项）；
}
捕获（例外情况除外）
{
Common.showMessageBox（例如Message+“InnerException:+ex.InnerException，MSG_TYP.Error，“发生错误”）；
}
返回结果列表；
});
}
}

公共异步无效TSRecomulation（int-piGroupId、int-piIssuerId、DateTime pdFromDate、DateTime ldToDate、int-piFormulaId、int-PiisPeriesProcessedType、int-PiisPeriesRestart、int-PiisPlcalCalculated、int-piIsIncludeEditedScoreint）
{
var result=wait Common.callSpForTS（piGroupId、piIssuerId、pdFromDate、ldToDate、piFormulaId、piIsProcessedType、piIsSeriesReStart、piisplcalculated、piisincludeedscoreint）；
}
公共静态异步任务调用forts（int piGroupId、int piIssuerId、DateTime pdFromDate、DateTime ldToDate、int piFormulaId、int piIsProcessedType、int piiseriesrestart、int piIsPLCalculate、int piisincludetedscoreint）
{
        public async void TSReCalculation(int piGroupId, int piIssuerId, DateTime pdFromDate, DateTime ldToDate, int piFormulaId, int piIsProcessedType, int piIsSeriesReStart, int piIsPLCalculate, int piIsIncludeEditedScoreint)
        {
            var result = await Common.callSpForTS(piGroupId, piIssuerId, pdFromDate, ldToDate, piFormulaId, piIsProcessedType, piIsSeriesReStart, piIsPLCalculate, piIsIncludeEditedScoreint);
        }


        public static async Task<List<ResultData>> callSpForTS(int piGroupId, int piIssuerId, DateTime pdFromDate, DateTime ldToDate, int piFormulaId, int piIsProcessedType, int piIsSeriesReStart, int piIsPLCalculate, int piIsIncludeEditedScoreint)
        {
            try
            {
                List<ResultData> myList = new List<ResultData>();
                sqlCommand.ExecuteNonQuery();
                dbModel.ResultData item = new dbModel.ResultData();
                item.Description = "succesfulll";
                item.Status = 1;
                item.BatchId = 100;
                myList.Add(item);
                return await Task.FromResult(myList);
            }
            catch (Exception ex)
            {
                Common.showMessageBox(ex.Message + "InnerException:" + ex.InnerException, MSG_TYP.Error, "Error Occured");
            }
        }