Particle.ParticleCloud.RefreshTokenAsync C# (CSharp) Méthode

		public Task<Result> RefreshTokenAsync()
		{
			if (authResults == null)
			{
				throw new ParticleAuthenticationExeption(RH.C.GetString("YouMustLoginBeforeRefreshingToken"));
			}

			return LoginWithUserAsync(authResults.Username, authResults.Password, authResults.ExpiresIn);
			/* The ideal way below does not currently appear to be currently supported.
			client.DefaultRequestHeaders.Clear();
			client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", Convert.ToBase64String(Encoding.UTF8.GetBytes("particle:particle")));

			var data = new Dictionary<String, String>();
			data["refresh_token"] = authResults.RefreshToken;
			data["grant_type"] = "refresh_token";
			var postResults = await client.PostAsync("/oauth/token", new FormUrlEncodedContent(data));
			if (postResults.StatusCode == System.Net.HttpStatusCode.OK)
			{
				var results = await postResults.Content.ReadAsStringAsync();
				var ret = await Task.Run(() => JsonConvert.DeserializeObject<AuthenticationResults>(results));
				if (ret != null)
				{
					if (!String.IsNullOrWhiteSpace(ret.AccessToken))
					{
						authResults = ret;
						return new Result
						{
							Success = true
						};
					}
				}
			}
			else if (postResults.StatusCode == System.Net.HttpStatusCode.BadRequest)
			{
				var results = await postResults.Content.ReadAsStringAsync();
				var ret = await Task.Run(() => JsonConvert.DeserializeObject<Result>(results));
				if (ret != null)
				{
					ret.Success = false;
					return ret;
				}
			}

			return new Result
			{
				Success = false,
				Error = postResults.StatusCode.ToString()
			};*/
		}

        /// <summary>
        /// Gets the variable value asynchronous for the provided <paramref name="variable"/>.
        /// </summary>
        /// <param name="variable">The variable.</param>
        /// <returns></returns>
        public async Task <Result <Variable> > GetVariableValueAsync(Variable variable)
        {
            if (variable == null)
            {
                throw new ArgumentNullException(nameof(variable));
            }

            if (String.IsNullOrWhiteSpace(variable.Name))
            {
                throw new ArgumentException(RH.C.GetString("PassedVariableMustHaveAName"), nameof(variable));
            }

            var svariable = await Task.Run(() => variables.FirstOrDefault(i => i == variable));

            if (svariable == null)
            {
                ParticleCloud.SyncContext.InvokeIfRequired(() =>
                {
                    variables.Add(variable);
                });
            }
            try
            {
                var response = await cloud.MakeGetRequestAsync($"devices/{Id}/{Uri.EscapeDataString(variable.Name)}");

                if (response.StatusCode == System.Net.HttpStatusCode.Unauthorized)
                {
                    await cloud.RefreshTokenAsync();

                    response = await cloud.MakeGetRequestAsync($"devices/{Id}/{Uri.EscapeDataString(variable.Name)}");

                    if (response.StatusCode == System.Net.HttpStatusCode.Unauthorized)
                    {
                        return(response.AsResult <Variable>());
                    }
                }

                if (response.StatusCode == System.Net.HttpStatusCode.OK)
                {
                    var tresult = response.Response.SelectToken("result");
                    variable.Value = tresult.Value <Object>().ToString();

                    /*
                     * "name": "temperature",
                     * "result": 46,
                     * "coreInfo": {
                     * "name": "weatherman",
                     * "deviceID": "0123456789abcdef01234567",
                     * "connected": true,
                     * "last_handshake_at": "2015-07-17T22:28:40.907Z",
                     * "last_app": ""
                     * }*/

                    return(new Result <Variable>
                    {
                        Success = true,
                        Data = variable
                    });
                }
                else
                {
                    return(response.AsResult <Variable>());
                }
            }
            catch (HttpRequestException re)
            {
                return(new Result <Variable>
                {
                    Success = false,
                    Error = re.Message,
                    Exception = re
                });
            }
        }