Асинхронная задача Result = "{Not yet completed}"

        private string BalanseNow()
        {
            Response<ClientAccount[]> response;
            try
            {
                response = service.GetClientAccounts(FindedClient.id.ToString()); //точка останова тут
            }
            catch (Exception ex)
            {
                throw new ArgumentException(ex.Message);
            }
            //в return возвращается баланс из всей кучи не нужной для метода информации. 
            return (new List<ClientAccount>(response.Data).Find(x => x.account_id == SelectedAccount.account_id)).summ;
        }
        public async Task<string> BalanseNowAsync() => await Task.Factory.StartNew(BalanseNow);

        public Response<ClientAccount[]> GetClientAccounts(string clientID) 
        {
            //не важная информация
            return response;
        }

    public class Response<T>
    {
        public bool Success { get; set; }
        public string Error { get; set; }
        public bool SessionExpired { get; set; }
        public T Data { get; set; }
        public long Total { get; set; }
    }

        private string BalanseNow()
        {
            Response<ClientAccount[]> response;
            try
            {
                response = service.GetClientAccounts(FindedClient.id.ToString()); //точка останова тут
            }
            catch (Exception ex)
            {
                throw new ArgumentException(ex.Message);
            }
            //в return возвращается баланс из всей кучи не нужной для метода информации. 
            return (new List<ClientAccount>(response.Data).Find(x => x.account_id == SelectedAccount.account_id)).summ;
        }
        public async Task<string> BalanseNowAsync()
        {
            var result = await Task.Run(() => BalanseNow());
            RaiseBalanceAction(BalanceStateEnum.Changed, result);//событие изменения баланса.
            retunt result ;
        }
 
 
        private decimal DepositPay(decimal newSumm){ /*  ...  */  }
 
        public async Task<bool> DepositPayAsync(decimal newSumm)
        {
            bool result = false;
            try
            {
                result  = await Task.Run(() => DepositPay(newSumm));
            }
            catch(Exception ex)
            {
                throw new ArgumentAxception(ex.Message);
            }
        }

private async void DepositPay()
{
    // оплата депозита
    decimal newSumm = 5m;
    await moldel.DepositPayAsync(newSumm);
    await moldel.BalanseNowAsync();
    //Выдать чек
}

        public async Task<Response<ClientAccount[]>> GetClientAccountsAsync(string clientID)
        {
            var jObject = new JObject
            {
                ["client_id"] = clientID
            };
 
            string json = JsonConvert.SerializeObject(jObject);
 
            json = HttpUtility.UrlEncode(json);
 
            string url = $"{_url}/client_accounts?params={json}";
 
            var response = await _requestSender.SendWebRequestAsync<Response<ClientAccount[]>, object>(url, HttpMethod.Get, null);
            return response;
        }

        // Это, как я понял часть Модели?
 
        // Члены экземпляра не используются - поэтому статический метод.
        public static async Task<Response<ClientAccount[]>> GetClientAccountsAsync(object clientID)
        {
            var jObject = new JObject
            {
                ["client_id"] = clientID.ToString();
            };
 
            string json = JsonConvert.SerializeObject(jObject);
 
            string urlEncode = HttpUtility.UrlEncode(json);
 
            string url = $"{_url}/client_accounts?params={urlEncode}";
 
            var response = await _requestSender.SendWebRequestAsync<Response<ClientAccount[]>, object>(url, HttpMethod.Get, null);
            return response; // Во время отладки здесь можно поставить точку останова и проверить response
        }

        // А это, наверное, VM ?
 
        public static async Task<string> BalanseNowAsync()
        {
            Response<ClientAccount[]> response = await Task.Factory.StartNew(service.GetClientAccountsAsync, FindedClient.id); 
 
            var result = response.Data.Find(x => x.account_id == SelectedAccount.account_id)).summ;
 
            RaiseBalanceAction(BalanceStateEnum.Changed, result); //событие изменения баланса.
 
            retunt result ;
        }

private async void DepositPay()
{
    // оплата депозита
    decimal newSumm = 5m;
 
    var taskDeposit = moldel.DepositPayAsync(newSumm);
    await taskDeposit;
    // Проверка состояния завершения taskDeposit 
    if(taskDeposit.Status == ...)
    {
         --------------
     }
 
    var taskBalanse = moldel.BalanseNowAsync();
    await taskBalanse;
    // Проверка состояния завершения taskBalanse
    if(taskBalanse.Status == ...)
    {
         --------------
     }
 
    //Выдать чек
}

            var response = _requestSender.SendWebRequest<Response<ClientAccount[]>, object>(url, HttpMethod.Get, null);
            return response;

public bool IsInCorrect {get; private set;}
public string MessageErrror {get; private set;}
public RelayCommand MyCommand {get;} = new RelayCommand(MyMethodAsync);
 
// Этот метод может быть только void.
private async void MyMethodAsync()
{
     var task = model.MethodAsync();
 
     await task;
 
     if (task.Status ==TaskStatus.Faulted)
    {
          IsInCorrect = true;
          MessageErrror = "MethodAsync завершился исключением";
     }
}

        public Response<ClientAccount[]> GetClientAccounts(string clientID) 
        {
            var jObject = new JObject
            {
                ["client_id"] = clientID
            };
 
            string json = JsonConvert.SerializeObject(jObject);
 
            json = HttpUtility.UrlEncode(json);
 
            string url = $"{_url}/client_accounts?params={json}";
 
            var response = _requestSender.SendWebRequest<Response<ClientAccount[]>, object>(url, HttpMethod.Get, null);
            return response;
        }

         public TResponse SendWebRequest<TResponse, TRequest>(string url, HttpMethod method, TRequest request) where TRequest : class
                                                                                                              where TResponse : class
        {
        }

        public async Task<TResponse> SendHttpRequest<TResponse, TRequest>(string url, HttpMethod method, TRequest request) where TRequest : class
                                                                                                                           where TResponse : class
        {
            //..
                var httpResponse = await client.SendAsync(httpRequest);
                if (httpResponse.IsSuccessStatusCode)
                {
                    string json = await httpResponse.Content.ReadAsStringAsync();
                    response = JsonConvert.DeserializeObject<TResponse>(json);
                }
            //..
        }

        public Response<Transaction[]> PayDepositReplenishment(Transaction transaction)
        {
            //..
            var response = _requestSender.SendHttpRequest<Response<Transaction[]>, Transaction>($"{_url}/transactions", HttpMethod.Post, transaction).Result;
            return response;
        }

        private string BalanseNow()
        {
            Response<ClientAccount[]> response;
            try
            {
                response = service.GetClientAccounts(FindedClient.id.ToString());
            }
            catch (Exception ex)
            {
                throw new ArgumentException(ex.Message);
            }
 
            return (new List<ClientAccount>(response.Data).Find(x => x.account_id == SelectedAccount.account_id)).summ;
        }
        public async Task<string> BalanseNowAsync()
        {
            var result = await Task.Run(() => BalanseNow());
                RaiseActionBalance(BalanceEnum.TopUp, Convert.ToDecimal(result));
            return result;
        }

        private async void CurrentPageChanged(/*    */)
        {
        //..
            await model.BalanseNowAsync();
        //..
        }

        private void ModelActionCurrentBalance(object sender, BalanceEnum action, decimal item)
        {
            switch (action)
            {
                case BalanceEnum.TopUp:
                    CurrentBalance = item.ToString();
                    break;
            }
        }

return response.Data.First(x => x.account_id == SelectedAccount.account_id).summ;

return (new List<ClientAccount>(response.Data).Find(x => x.account_id == SelectedAccount.account_id)).summ;