C# 处理这两个相互依赖的异步方法的最佳方法是什么？

我使用的是Prism库的最新版本

我的列表页面视图模型-ActivityListPageViewModel.cs下面有类似的内容，它基本上是一个列表，单击/选择后将导航到详细信息页面

public ActivityModel SelectedItem
    {
        get => _selectedActivity;
        set
        {
            SetProperty(ref _selectedActivity, value);
            if (_selectedActivity != null)
                ShowActivityDetails(_selectedActivity);

        }
    }

    async void ShowActivityDetails(ActivityModel selectedActivity)
    {
        var navigationParams = new NavigationParameters();
        navigationParams.Add("activity", selectedActivity);

        await _navigationService.NavigateAsync("ActivityDetailPage", navigationParams);
    }

在我的详细信息页面视图模型中-ActivityDetailPageViewModel.cs

有没有更好的办法

---

谢谢

最简单的解决方案是将覆盖转换为异步，这样您就可以像平常一样调用异步方法了

优点是将正确的上下文传递给异步方法，如果使用Task.Run卸载，则不会发生这种情况

---

注意：由于这是一个异步无效，您需要小心处理异常，因为它们不会被观察到，因此最好捕获它们。

最简单的解决方案是将覆盖转换为异步，这样您就可以像平常一样调用异步方法

优点是将正确的上下文传递给异步方法，如果使用Task.Run卸载，则不会发生这种情况

---

注意：由于这是一个异步无效，您需要小心处理异常，因为它们不会被观察到，所以最好捕获它们。

任务。运行…等待；没有任何意义，您希望它在后台运行TaskRun还是not Wait？Task.run…Wait；没有任何意义，您希望它在后台运行TaskRun还是not Wait？我在'await'操作符上有此错误，只能在异步方法中使用。考虑将此方法标记为“AsiNC”修饰符，并将其返回类型更改为“任务”@ DCopRepublic公共覆盖AutoC空，以注意MyToMin上的异步关键字，以注意异常，您是指NavigatedToNavigationParameters方法上的public override async void吗？@dcpartners是的，最好放一个try-catch来封装该方法的全部内容。并记录结果，或显示用户ect。我在'wait'运算符上有此错误，只能在异步方法中使用。考虑将此方法标记为“AsiNC”修饰符，并将其返回类型更改为“任务”@ DCopRepublic公共覆盖AutoC空，以注意MyToMin上的异步关键字，以注意异常，您是指NavigatedToNavigationParameters方法上的public override async void吗？@dcpartners是的，最好放一个try-catch来封装该方法的全部内容。并记录结果，或向用户显示ect。

public class ActivityDetailPageViewModel : ViewModelBase, IActiveAware, INavigationAware
{
    private readonly IActivityApiService _activityApiService;

    private readonly ICategoryApiService _categoryApiService;

    private readonly INavigationService _navigationService;

    private readonly IPageDialogService _dialogService;

    public DelegateCommand DeleteCommand { get; private set; }

    public DelegateCommand SaveCommand { get; private set; }

    private ActivityModel _activity;

    public ActivityModel Activity
    {
        get { return this._activity; }
        set
        {
            SetProperty(ref this._activity, value);
        }
    }


    private ActivityModelValidator _activityValidator;

    private bool _isActive;

    public bool IsActive
    {
        get { return _isActive; }
        set
        {
            _isActive = value;
            SetProperty(ref _isActive, value, RaiseIsActiveChange);
        }
    }


    private List<CategoryModel> _categoryList;

    public List<CategoryModel> CategoryList
    {
        get => _categoryList;
        set => SetProperty(ref _categoryList, value);
    }

    private CategoryModel _selectedCategory;

    public event EventHandler IsActiveChanged;

    public CategoryModel SelectedCategory
    {
        get => _selectedCategory;
        set => SetProperty(ref _selectedCategory, value);
    }
    //public bool IsActive { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }

    public ActivityDetailPageViewModel(CategoryApiService categoryApiService, ActivityApiService activityApiService, INavigationService navigationService, IPageDialogService dialogService) : base(navigationService)
    {
        _categoryApiService = categoryApiService;
        _activityApiService = activityApiService;
        _navigationService = navigationService;
        _dialogService = dialogService;

        _activityValidator = new ActivityModelValidator();

        Title = "Activity";

        DeleteCommand = new DelegateCommand(DeleteActivity);
        SaveCommand = new DelegateCommand(SaveActivity);
    }

    protected virtual void RaiseIsActiveChange()
    {
        IsActiveChanged?.Invoke(this, EventArgs.Empty);
    }

    public override void OnNavigatedTo(INavigationParameters parameters)
    {
        var activity = parameters["activity"] as ActivityModel;

        Activity = activity ?? new ActivityModel();

        Task.Run(async () => { await FetchCategories(); }).Wait();
        Task.Run(async () => { await FetchActivityDetail(); });
    }

    public async Task FetchActivityDetail()
    {
        if (Activity.Id > 0)
        {
            Activity = await _activityApiService.GetActivity(Activity.Id);
            SelectedCategory = CategoryList.FirstOrDefault(x => x.Id == Activity.CategoryId);
        }
    }

    public async Task FetchCategories()
    {
        CategoryResultModel categoryResult = await _categoryApiService.GetCategories();
        CategoryList = categoryResult.Results;
    }

    async void SaveActivity()
    {
        Activity.CategoryId = SelectedCategory.Id;
        Activity.CategoryName = SelectedCategory.Name;

        var validationResults = _activityValidator.Validate(Activity);

        if (validationResults.IsValid)
        {
            if (Activity.Id != 0)
            {
                bool isUserAccept = await _dialogService.DisplayAlertAsync("Activity", "Update the details", "OK", "Cancel");
                if (isUserAccept)
                {
                    var response = await _activityApiService.UpdateActivity(Activity.Id, Activity);
                    if (!response)
                    {
                        await _dialogService.DisplayAlertAsync("Activity", "Error.", "OK");
                    }
                    else
                    {
                        await _navigationService.NavigateAsync("NavigationPage/ActivityListPage");
                    }
                }
            }
            else
            {
                bool isUserAccept = await _dialogService.DisplayAlertAsync("Activity", "Add a new details", "OK", "Cancel");
                if (isUserAccept)
                {
                    var response = await _activityApiService.AddActivity(Activity);
                    if (!response)
                    {
                        await _dialogService.DisplayAlertAsync("Activity", "Error.", "OK");
                    }
                    else
                    {
                        await _navigationService.NavigateAsync("NavigationPage/ActivityListPage");
                    }
                }
            }
        }
        else
        {
            await _dialogService.DisplayAlertAsync("Activity", validationResults.Errors[0].ErrorMessage, "OK");
        }
    }


    async void DeleteActivity()
    {
        var alert = await _dialogService.DisplayAlertAsync("Activity", "Do you want to delete this item?", "Yes", "Cancel");
        if (alert)
        {
            var response = await _activityApiService.DeleteActivity(Activity.Id);
            if (!response)
            {
                await _dialogService.DisplayAlertAsync("Activity", "Error.", "OK");
            }
            else
            {
                await _navigationService.NavigateAsync("NavigationPage/ActivityListPage");
            }
        }
    }
}

Task.Run(async () => { await FetchCategories(); }).Wait();
Task.Run(async () => { await FetchActivityDetail(); });

Task.Run(async () => { await FetchCategories(); await FetchActivityDetail();  });

public override async void OnNavigatedTo(INavigationParameters parameters)
{
    try
    {
        var activity = parameters["activity"] as ActivityModel;

        Activity = activity ?? new ActivityModel();

        await FetchCategories(); 
        await FetchActivityDetail();
     }
     catch(Exception ex)
     {
         // log or tell the user
     }
}