Esempio n. 1
0
        /// <summary>
        /// Event raised when the outbound message comes asynchronously
        /// </summary>
        /// <param name="sender">Object sender</param>
        /// <param name="e">DownloadStringCompletedEventArgs e </param>
        private void OnOutboundDownloadStringCompleted(object sender, DownloadStringCompletedEventArgs e)
        {
            if (e.Error == null)
            {
                // O lock me garante que :
                // 1 -  Nao vai ter duas tasks escrevendo e/ou instanciando o mesmo objeto
                // 2 - Eu saiba quando chega a ultima mensabem para chamar o evento 'OnMessageReceived'
                lock (mutex)
                {
                    _respIda = JsonConvert.DeserializeObject <Door2DoorLegResponse>(e.Result);

                    // se é nulo é porque é a primeira mensagem que chega
                    if (_resp.LegResponse == null)
                    {
                        _resp.LegResponse    = new List <Door2DoorLegResponse>(2);
                        _resp.LegResponse[0] = _respIda;
                    }
                    else // senao ja chegou a outra, pode chamar o evento
                    {
                        _resp.LegResponse[0] = _respIda;
                        OnMessageReceived(_resp);
                    }
                }
            }
            else
            {
                throw new D2DResponseException(e.Error);
            }
        }
Esempio n. 2
0
        /// <summary>
        ///     Downloads the response from the API, according to the request informed.
        /// </summary>
        /// <returns>
        ///     Raw response, before schedules and totals addition.
        /// </returns>
        internal Door2DoorResponse Download()
        {
            List <Task> taskList = new List <Task>();
            string      url      = _req.url;

            //ida
            using (WebClient client = new WebClient())
            {
                try
                {
                    client.QueryString = BuildQueryString(false);
                    taskList.Add(Task.Factory.StartNew(() =>
                    {
                        string r = client.DownloadString(url);
                        _respIda = JsonConvert.DeserializeObject <Door2DoorLegResponse>(r);
                    }));
                }
                catch (Exception e)
                {
                    throw new D2DResponseException(e);
                }
            }

            // volta, se tiver
            if (_req.desiredInboundDate.HasValue)
            {
                using (WebClient clientVolta = new WebClient())
                {
                    try
                    {
                        taskList.Add(Task.Factory.StartNew(() =>
                        {
                            clientVolta.QueryString = BuildQueryString(true);
                            string r   = clientVolta.DownloadString(url);
                            _respVolta = JsonConvert.DeserializeObject <Door2DoorLegResponse>(r);
                        }));
                    }
                    catch (Exception e)
                    {
                        throw new D2DResponseException(e);
                    }
                }
            }

            Task.WaitAll(taskList.ToArray());

            // tem que existir uma resposta para ida e outra para volta pois a ordem em que elas estao na lista '_resp' importa
            // tem que adicionar primeiro a resposta da ida, depois a da volta, se tiver
            _resp.LegResponse = new List <Door2DoorLegResponse>();
            _resp.LegResponse.Add(_respIda);
            if (_respVolta != null)
            {
                _resp.LegResponse.Add(_respVolta);
            }
            return(_resp);
        }