如何使用“async”和“await”正确地使应用程序异步？

Question

class Website
{
    public Website(string link)
    {
        _linkToWeb = new RestClient(link);
    }
    public async Task<string> DownloadAsync(string path)
    {
        var request = new RestRequest(path, Method.GET);
        var response = _linkToWeb.ExecuteAsync(request);
        return response.Result.Content;
    }
    public RestClient _linkToWeb { get; set; }
}

class Program
{
    public static Website API = new Website("https://api.collegefootballdata.com");
    public static async Task<string> _downloadTeamsFromAPI()
    {
        return API.Download("/teams/fbs");
    }
    public static async Task<string> _downloadAdvancedInfoFromAPI()
    {
        return API.Download("/stats/season/advanced?year=2010");
    }
    public static async Task<Teams> _addTeamToDB(Teams item)
    {
        var tmp = new Teams
        {
            School = item.School,
            Abbreviation = item.Abbreviation,
            Conference = item.Conference,
            Divison = item.Divison,
            Color = item.Color,
            Alt_Color = item.Alt_Color,
            Team = await _getAdvancedInfoFromAPI(item.Conference)
        };
        return tmp;
    }
    public static async Task<string> _getAdvancedInfoFromAPI(string _conferenceName)
    {
        List<Advanced> advancedDataList = new List<Advanced>();
        var advancedData = await _downloadAdvancedInfoFromAPI();
        var advancedDataDeserialized = JsonSerializer.Deserialize<Advanced[]>(advancedData, new JsonSerializerOptions()
        {
            PropertyNameCaseInsensitive = true
        });

        foreach (var item in advancedDataDeserialized)
        {
            advancedDataList.Add(new Advanced
            {
                Team =                  item.Team,
                //Conference =            item.Conference,
                Year =                  item.Year,
                excludeGarbageTime =    item.excludeGarbageTime,
                startWeek =             item.startWeek,
                endWeek =               item.endWeek
            });
        }
        return await _lookForMatch(_conferenceName, advancedDataList);
    }
    public static async Task<string> _lookForMatch(string _Confa, List<Advanced> lista)
    {
        return lista
                        .Where(x => x.Conference == _Confa)
                        .Select(x => x.Team)
                        .FirstOrDefault();
    }
    public static async Task Main()
    {
        Console.WriteLine("Odpaliłem program!\n");
        using var db = new Context();
        db.Database.EnsureCreated();
        Console.WriteLine("Stworzylem baze!\n");
        var teams = await _downloadTeamsFromAPI();

        var deserializer = JsonSerializer.Deserialize<Teams[]>(teams, new JsonSerializerOptions()
        {
            PropertyNameCaseInsensitive = true
        });
        Console.WriteLine("Zdeserializowalem dane!\n");
        foreach (var item in deserializer)
        {
            db.Teams.Add(await _addTeamToDB(item));
            Console.WriteLine(DateTime.Now.ToString("HH:mm:ss"));
            Console.WriteLine("Dodalem element do bazy...\n");
        };
        db.SaveChanges();
        Console.WriteLine("Zapisalem dane do bazy!");
    }
} 

我知道这是一个菜鸟问题，但我不知道如何让它发挥作用：/

我想让它变得有点异步，因为 async 和 await 这两个词并没有完全让它变得更加异步，但我不知道如何制作它无论如何都是异步的。

应用程序首先从 API 下载信息，将其反序列化并存储到 var 类型变量中。然后它从 API 下载高级信息并通过“会议”项目加入。 （这是故意的，即使它不是最佳的）。

有很多 async 和 await 但我认为它无论如何都不会运行异步。我应该改变什么才能使这个应用真正异步？

Answer 1

感谢您编写异步代码以使您的应用程序更具可扩展性的动机。 不过看完贴出的示例代码，恐怕你需要更多地学习异步编程的概念，而不是跳进控制台，尝试编写一些看起来像异步代码的代码。

慢慢开始，尝试了解Task库的用途，何时使用它。 await 在幕后做了什么。何时使用Task 包装返回类型以及何时将方法标记为async。这些是您在异步代码中遇到的一些主要关键字，并且很好地理解这些是编写/理解异步代码的必要条件。

网上有很多资源可以用来掌握这些概念。对于初学者，您可以开始研究Microsoft Documentation

话虽如此，内联是对示例代码的重写，并正确使用了async/await。 请仅将其用于参考目的。除非您对概念有很好的理解，否则不要尝试将一些生产代码放入其中。

提供了必要的 cmets 来解释所做的一些关键更改。

class Website
{
    public Website(string link)
    {
        _linkToWeb = new RestClient(link);
    }

    public async Task<string> DownloadAsync(string path)
    {
        var request = new RestRequest(path, Method.GET);
        var response = await _linkToWeb.ExecuteAsync(request); //await an asynchronous call.
        return response.Content; //No need to call response.Result. response content can be fetched after successful completion of asynchronous call.
    }
    public RestClient _linkToWeb { get; set; }
}

class Program
{
    public static Website API = new Website("https://api.collegefootballdata.com");

    public static async Task<string> _downloadTeamsFromAPI()
    {
        return await API.DownloadAsync("/teams/fbs");
    }

    public static async Task<string> _downloadAdvancedInfoFromAPI()
    {
        return await API.DownloadAsync("/stats/season/advanced?year=2010");
    }

    public static async Task<Teams> _addTeamToDB(Teams item)
    {
        var tmp = new Teams
        {
            School = item.School,
            Abbreviation = item.Abbreviation,
            Conference = item.Conference,
            Divison = item.Divison,
            Color = item.Color,
            Alt_Color = item.Alt_Color,
            Team = await _getAdvancedInfoFromAPI(item.Conference)
        };
        return tmp;
    }

    //Return type has to be Task<Teams> rather than Task<string> because the return object is Teams.
    public static async Task<Teams> _getAdvancedInfoFromAPI(string _conferenceName)
    {
        List<Advanced> advancedDataList = new List<Advanced>();
        var advancedData = await _downloadAdvancedInfoFromAPI();
        var advancedDataDeserialized = JsonSerializer.Deserialize<Advanced[]>(advancedData, new JsonSerializerOptions()
        {
            PropertyNameCaseInsensitive = true
        });

        foreach (var item in advancedDataDeserialized)
        {
            advancedDataList.Add(new Advanced
            {
                Team = item.Team,
                //Conference =            item.Conference,
                Year = item.Year,
                excludeGarbageTime = item.excludeGarbageTime,
                startWeek = item.startWeek,
                endWeek = item.endWeek
            });
        }
        return _lookForMatch(_conferenceName, advancedDataList);
    }

    //Return type is Teams and not string. 
    //Moreover Task<string> not required because we are not awaiting method call in this method.
    public static Teams _lookForMatch(string _Confa, List<Advanced> lista) 
    {
        return lista.Where(x => x.Conference == _Confa)
                        .Select(x => x.Team)
                        .FirstOrDefault();
    }

    public static async Task Main()
    {
        Console.WriteLine("Odpaliłem program!\n");
        using var db = new Context();
        db.Database.EnsureCreated();
        Console.WriteLine("Stworzylem baze!\n");
        var teams = await _downloadTeamsFromAPI();

        var deserializer = JsonSerializer.Deserialize<Teams[]>(teams, new JsonSerializerOptions()
        {
            PropertyNameCaseInsensitive = true
        });
        Console.WriteLine("Zdeserializowalem dane!\n");
        foreach (var item in deserializer)
        {
            db.Teams.Add(await _addTeamToDB(item));
            Console.WriteLine(DateTime.Now.ToString("HH:mm:ss"));
            Console.WriteLine("Dodalem element do bazy...\n");
        };
        db.SaveChanges();
        Console.WriteLine("Zapisalem dane do bazy!");
    }
}