Web service Xamarin

Gabriel,

Eu já desenvolvi uma aplicação que fazia chamado a um serviço REST, que é o mesmo caso que você. Para isso implementei uma classe para facilitar as chamadas dos serviços. Segue abaixo o código da classe WebRequestHelper que eu fiz:

    internal class WebRequestHelper
    {
        internal WebRequestConfig Config { get; set; }

        internal async Task Post(object jsonPost)
        {
            await Post(jsonPost, json => true);
        }

        internal async Task<T> Post<T>(object jsonPost, Func<string, T> fn)
        {
            var request = CriarRequisicao();
            request.Method = "POST";

            using (var webStream = await Task.Factory.FromAsync(request.BeginGetRequestStream, request.EndGetRequestStream, request))
            {
                var json = JsonConvert.SerializeObject(jsonPost, Formatting.None, new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore, ContractResolver = new CamelCasePropertyNamesContractResolver() });
                var bytes = Encoding.UTF8.GetBytes(json);
                webStream.Write(bytes, 0, bytes.Length);

                using (var webReponse = await Task.Factory.FromAsync(request.BeginGetResponse, request.EndGetResponse, request))
                using (var stream = new StreamReader(webReponse.GetResponseStream()))
                {
                    return fn(stream.ReadToEnd());
                }
            }
        }

        internal async Task<T> Get<T>(Func<string, T> fn)
        {
            var request = CriarRequisicao();
            request.Method = "GET";

            using (var webReponse = await Task.Factory.FromAsync(request.BeginGetResponse, request.EndGetResponse, request))
            using (var stream = new StreamReader(webReponse.GetResponseStream()))
            {
                return fn(stream.ReadToEnd());
            }
        }

        private WebRequest CriarRequisicao()
        {
            var request = WebRequest.Create(new Uri(Config.ToString()));
            request.ContentType = "application/json";

            foreach (var header in Config.ParametrosHeader)
                request.Headers[header.Key] = header.Value.ToString();

            return request;
        }
    }

Essa classe possui uma propriedade WebRequestConfig, onde eu fiz a configuração dos parâmetros a serem utilizados na chamada do serviço. Segue abaixo o código da classe WebRequestConfig:

    internal class WebRequestConfig
    {
        private Dictionary<string, JToken> _parametros = new Dictionary<string, JToken>();

        public Dictionary<string, object> ParametrosHeader { get; private set; }
        public string Servidor { get; set; }
        public string EndPoint { get; set; }

        public WebRequestConfig()
        {
            ParametrosHeader = new Dictionary<string, object>();
        }

        public void AddParam(string chave, JToken valor)
        {
            if (chave.Contains("{") || chave.Contains("}"))
                chave = chave.Replace("{", "").Replace("}", "");

            if (_parametros.ContainsKey(chave))
                _parametros[chave] = valor;
            else
                _parametros.Add(chave, valor);
        }

        public void AddHeaderParam(string chave, object valor)
        {
            if (ParametrosHeader.ContainsKey(chave))
                ParametrosHeader[chave] = valor;
            else
                ParametrosHeader.Add(chave, valor);
        }

        private string SubstituirParametros(string endPoint)
        {
            foreach (var param in _parametros)
                endPoint = endPoint.Replace(string.Concat("{", param.Key, "}"), param.Value.ToString());

            return endPoint;
        }

        public override string ToString()
        {
            return string.Concat(Servidor, "/", SubstituirParametros(EndPoint));
        }
    }

Para utilizar esse helper fica assim:

var config = new WebRequestConfig { Servidor = "http://localhost:49562/api", EndPoint = "carrinho/{id}" };
config.AddParam("{id}", "1");

await new WebRequestHelper
{
    Config = config
}
.Get((json) => /* aqui você faz o que quiser com o retorno */);

Espero que essa classe te ajude. Abraço.

Oi Gabriel, tudo bem?

Pesquisei um pouco e, pelo que eu vi, o problema é que essa chamada precisa ser assíncrona. E por isso o GetResponse convencional não está disponível pra você.

Experimenta trocar o seu método atual, que usa o GetResponse, por esses dois usando BeginGetReponse e EndGetResponse?

void ingressarButton_Clicked(object sender, EventArgs e)
{
            HttpWebRequest request = (HttpWebRequest)WebRequest.Create("http://localhost:49562/api/carrinho/1");
            request.Method = "GET";
            request.Accept = "application/json";
            request.BeginGetResponse(new AsyncCallback(FinishRequest), request);
}


private void FinishRequest (IAsyncResult result)
{
            HttpWebResponse response = (result.AsyncState as HttpWebRequest).EndGetResponse(result) as HttpWebResponse;
            using (Stream responseStream = response.GetResponseStream())
            {
                StreamReader reader = new StreamReader(responseStream, Encoding.UTF8);
                String conteudo = reader.ReadToEnd();
                // pode retornar esse conteúdo, imprimir, etc
            }
        }

Veja que, basicamente, o que mudou foi a forma de pegar o response. No lugar de fazer WebResponse response = request.GetResponse(); usamos o request.BeginGetResponse e extraímos o resto para um m;etodo privado de callback.

Não consigo testar esse código agora, então pode ter algo não compilando. Você experimenta e me diz se funcionou? Se não der certo de primeira, me diga qual foi o erro que vamos juntos procurando pela solução. E não deixe de falar caso algo não tenha ficado claro (;