C# 使用委托调用异步方法

我正在调用一个

async

api来获取详细信息。 目标

api

端点可以更改，并希望将其作为动态函数传递

由于所有API的详细信息分页都是相同的，我们如何使其成为具有

异步返回值的
委托
函数？

private async Task<List<Items>> GetItemsAsync(HttpClient client, string arg1)
{
    var totalResults = new List<Items>();
    int skip = 0, resultsCount = 1;

    while (resultsCount != 0)
    {
        var results = await GetItems(client, arg1, skip);
        if (results != null)
        {
            totalResults.AddRange(results);
            resultsCount = results.Count;
            skip += resultsCount;
        }
        else
        {
            resultsCount = 0;
        }
    }

    return totalResults;
}

private async Task<List<Users>> GetUsersAsync(HttpClient client, string arg1)
{
    var totalResults = new List<Users>();
    int skip = 0, resultsCount = 1;

    while (resultsCount != 0)
    {
        var results = await GetUsers(client, arg1, skip);
        if (results != null)
        {
            totalResults.AddRange(results);
            resultsCount = results.Count;
            skip += resultsCount;
        }
        else
        {
            resultsCount = 0;
        }
    }

    return totalResults;
}

专用异步任务GetItemsAsync（HttpClient客户端，字符串arg1）
{
var totalResults=新列表（）；
int skip=0，resultcount=1；
while（结果计数！=0）
{
var结果=等待获取项目（客户端、arg1、跳过）；
如果（结果！=null）
{
totalResults.AddRange（结果）；
结果计数=结果计数；
跳过+=结果计数；
}
其他的
{
结果计数=0；
}
}
返回结果；
}
专用异步任务GetUsersAsync（HttpClient客户端，字符串arg1）
{
var totalResults=新列表（）；
int skip=0，resultcount=1；
while（结果计数！=0）
{
var results=await GetUsers（客户端，arg1，跳过）；
如果（结果！=null）
{
totalResults.AddRange（结果）；
结果计数=结果计数；
跳过+=结果计数；
}
其他的
{
结果计数=0；
}
}
返回结果；
}

类似于以下内容：

private async Task<List<T>> Get<T>(Func<Task<int, int, List<T>>> factory, int skip, int take)
{
    var totalResults = new List<T>();
    var resultsCount = 1;

    while (resultsCount != 0)
    {
        var results = await factory(skip, take);
        if (results != null)
        {
            totalResults.AddRange(results);
            resultsCount = results.Count;
            skip += resultsCount;
        }
        else
        {
            resultsCount = 0;
        }
    }

    return totalResults;
}

public Task<List<User>> GetUsersAsync(HttpClient httpClient, string arg1)
{
    return Get<User>((skip, take) => GetUsers(httpClient, arg1, skip, take), 0, 10);
}

public Task<List<Item>> GetItemsAsync(HttpClient httpClient, string arg1)
{
    return Get<Item>((skip, take) => GetItems(httpClient, arg1, skip, take), 10, 10);
}

private async Task Get（Func factory、int skip、int take）
{
var totalResults=新列表（）；
var ResultCount=1；
while（结果计数！=0）
{
var结果=等待工厂（跳过、接受）；
如果（结果！=null）
{
totalResults.AddRange（结果）；
结果计数=结果计数；
跳过+=结果计数；
}
其他的
{
结果计数=0；
}
}
返回结果；
}
公共任务GetUsersAsync（HttpClient HttpClient，字符串arg1）
{
返回Get（（skip，take）=>GetUsers（httpClient，arg1，skip，take），0，10；
}
公共任务GetItemsAsSync（HttpClient HttpClient，字符串arg1）
{
返回Get（（skip，take）=>GetItems（httpClient，arg1，skip，take），10，10；
}

在某些情况下，以下内容可能也足够了，但在您的情况下显然不够，因为您似乎需要对skip参数做更多的操作：

private async Task<List<T>> Get<T>(Func<Task<List<T>>> factory)
{
    ...
}

public Task<List<User>> GetUsersAsync(HttpClient httpClient, string arg1)
{
    return Get<User>(() => GetUsers(httpClient, arg1, 0, 10));
}

public Task<List<Item>> GetItemsAsync(HttpClient httpClient, string arg1)
{
    return Get<Item>(() => GetItems(httpClient, arg1, 10, 10));
}

私有异步任务获取（Func工厂）
{
...
}
公共任务GetUsersAsync（HttpClient HttpClient，字符串arg1）
{
返回Get（（）=>GetUsers（httpClient，arg1，0，10））；
}
公共任务GetItemsAsSync（HttpClient HttpClient，字符串arg1）
{
返回Get（（）=>GetItems（httpClient，arg1，10，10））；
}

遗漏了小细节。我需要从委托传递

skip

参数，这正是我努力的地方