当整个操作在同一个线程上执行时，为什么域抛出从不正确的线程访问的域

Question

Task.Factory.StartNew(async () =>
            {
                try
                {
                    ShowCaseInfo existingShowcase = DBService.GetDB().FetchShowcaseInfo();
                    string previousResponse = existingShowcase?.SerializedResponse;
                    Response response = await CloudService.GetCloudService().FetchShowcase();

                    if (response.Status == ResponseStatus.SUCCESS && !string.Equals(previousResponse, response.Data))
                    {
                        ShowCaseInfo showcaseInfo = JsonConvert.DeserializeObject<ShowCaseInfo>(response.Data, _settings);
                        showcaseInfo.SerializedResponse = response.Data;
                        DBService.GetDB().InsertOrUpdateShowcase(showcaseInfo);
                        FetchShowcaseProducts(showcaseInfo.Showcases);
                    }
                    else
                    {
                        List<Showcase> emptyCases = new List<Showcase>();
                            if (existingShowcase != null)
                            {
                                foreach (Showcase showcase in existingShowcase.Showcases)
                                {
                                    if (showcase.Products.Count == 0)
                                    {
                                        emptyCases.Add(showcase);
                                    }
                                }
                            }
                        FetchShowcaseProducts(emptyCases);
                    }
                }
                catch (Exception e)
                {
                    Console.WriteLine(e);
                }
            });

foreach（existingShowcase.showcases中的Showcase Showcase）行引发异常。 类似地，在if条件！string.equals（previousResponse，response.data）中，如果我以existingShowCase.SerializedResponse的身份访问previousResponse，则会引发一些异常，而不是局部变量。 根据文档，我们不应该跨线程传递对象，但在本例中，所有操作都在同一个线程中。

Answer 1

在这种情况下，所有操作都在同一个线程中。

不，他们实际上不是。 这是因为等待的工作方式。

当Await异步操作时，它捕获其当前上下文--SynchronizationContext.current或TaskScheduler.current。 在这种情况下，上下文是线程池上下文。 因此，当方法在Await之后恢复执行时，它可以在任何线程池线程上恢复执行。