Асинхронная задача 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; }
    }

        public async Task<TResponse> SendHttpRequest<TResponse, TRequest>(string url, HttpMethod method, TRequest request) where TRequest : class
                                                                                                                           where TResponse : class
        {
            TResponse response = null;
 
            using (var client = new HttpClient())
            {
                var httpRequest = new HttpRequestMessage(method, url);
 
                foreach (var header in _headers)
                {
                    httpRequest.Headers.Add(header.Key, header.Value);
                }
 
                if (request != null && method != HttpMethod.Get)
                {
                    string json = JsonConvert.SerializeObject(request);
                    var content = new StringContent(json);
                    content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
                    httpRequest.Content = content;
                }
 
                var httpResponse = await client.SendAsync(httpRequest);
 
                if (httpResponse.IsSuccessStatusCode)
                {
                    string json = await httpResponse.Content.ReadAsStringAsync();
                    response = JsonConvert.DeserializeObject<TResponse>(json);
                }
            }
 
            return response;
        }

        public TResponse SendWebRequest<TResponse, TRequest>(string url, HttpMethod method, TRequest request) where TRequest : class
                                                                                                              where TResponse : class
        {
            TResponse response = null;
 
            var webRequest = WebRequest.Create(url);
 
            webRequest.Method = method.Method;
 
            foreach (var header in _headers)
            {
                webRequest.Headers.Add(header.Key, header.Value);
            }
 
            if (method != HttpMethod.Get && request != null)
            {
                string json = JsonConvert.SerializeObject(request);
                byte[] bytes = Encoding.ASCII.GetBytes(json);
 
                webRequest.ContentType = "application/json";
                webRequest.ContentLength = bytes.Length;
 
                using (var stream = webRequest.GetRequestStream())
                {
                    stream.Write(bytes, 0, bytes.Length);
                }
            }
            else
            {
                webRequest.ContentLength = 0;
            }
 
            var webResponse = webRequest.GetResponse();
 
            using (var stream = webResponse.GetResponseStream())
            {
                using (var reader = new StreamReader(stream))
                {
                    string line = "";
                    while ((line = reader.ReadLine()) != null)
                    {
                        response = JsonConvert.DeserializeObject<TResponse>(line);
                    }
                }
            }
 
            webResponse.Close();
 
            return response;
        }

        public async Task<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 = await _requestSender.SendHttpRequest<Response<ClientAccount[]>, object>(url, HttpMethod.Get, null);
            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 service.GetClientAccounts(FindedClient.id.ToString());
            RaiseActionBalance(BalanceEnum.TopUp, Convert.ToDecimal(result));
            return result;
        }

        public async Task GetClientByIDAsync(int id, bool isRoot)
        {
            var taskClient = await service.GetClientByID(id.ToString());
 
            //Если ответ в Data больше единицы(каким-то чудом) или приравнивается нулю, значит что-то пошло не так
            if (taskClient.Data.Length > 1 || taskClient.Data.Length == 0)
            {
                FindedClient = null;
                RaiseActionClient(AuthorizationEnum.FailedAuthorization, null);
            }
 
            if (taskClient.Data.Length == 1)
            {
                //При первой авторизации беру данные пользователя
                Client tmpClient = taskClient.Data[0];
                //и тут же собираю список его счетов
                var accounts = await service.GetClientAccounts(tmpClient.id.ToString());
                //и список его активных абонементов
                var abonements = await service.GetClientTickets(tmpClient.id.ToString(), TicketState.Active);
 
                //Тут я ищу из всех его счетов депозитные
                ClientDeposits = new List<ClientAccount>(accounts.Data).FindAll(x => x.kind == 0);
                ClientAbonements = new List<ClientTicket>(abonements.Data);
                if (ClientDeposits.Count > 0)
                    SelectedAccount = ClientDeposits[0];
 
                //событие, что клиент авторизовался, или авторизовался администратор.
                FindedClient = tmpClient;
                if (!isRoot)
                    RaiseActionClient(AuthorizationEnum.Authorizated, tmpClient);
                else
                    RaiseActionClient(AuthorizationEnum.RootAutorizated, tmpClient);
            }
        }

        public IAsyncCommand EnterCommand;
 
        private async Task EnterMethodAsync()
        {
            try
            {
                await model.GetClientByIDAsync(id, false);
            }
            catch
            {
                //запись в лог ошибки
            }
        }
 
        public ViewModel()
        {
            EnterCommand = new AsyncCommand(EnterMethodAsync, EnterCanMethod);
        }

            var taskClient = await service.GetClientByID(id.ToString());
 
            //Если ответ в Data больше единицы(каким-то чудом) или приравнивается нулю, значит что-то пошло не так
            if (taskClient.Data.Length != 1)
            {
                FindedClient = null;
                RaiseActionClient(AuthorizationEnum.FailedAuthorization, null);
                return;
            }
 
            //При первой авторизации беру данные пользователя
            Client tmpClient = taskClient.Data[0];
            ...

        private bool EnterCanMethod()
        {
            if(!IsBusy)
                if (TextBoxValue != "" && TextBoxValue != null)
                    return true; 
            return false;
        }

private IAsyncCommand _enterCommand;
public IAsyncCommand EnterCommand => _enterCommand ?? (_enterCommand = new AsyncCommand(EnterMethodAsync, EnterCanMethod));