Définition de L'en-tête D'autorisation de HttpClient
j'ai un HttpClient que j'utilise pour utiliser une API REST. Cependant, j'ai du mal à configurer l'en-tête D'autorisation. J'ai besoin de mettre l'en-tête sur le jeton que j'ai reçu en faisant ma requête OAuth. J'ai vu un code pour .NET qui suggère ce qui suit,
httpClient.DefaultRequestHeaders.Authorization = new Credential(OAuth.token);
cependant, la catégorie de justificatifs n'existe pas dans WinRT. Quelqu'un a une idée pour définir L'en-tête D'autorisation?
11 réponses
Donc, la façon de le faire est la suivante,
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", "Your Oauth token");
request.DefaultRequestHeaders.Authorization =
new AuthenticationHeaderValue(
"Basic",
Convert.ToBase64String(
System.Text.ASCIIEncoding.ASCII.GetBytes(
string.Format("{0}:{1}", "yourusername", "yourpwd"))));
je cherche une bonne façon de traiter cette question et je suis à la recherche de la même question , espérons que cette réponse peut aider tous ceux qui ont le problème comme moi .
using (var client = new HttpClient())
{
var url = "https://www.theidentityhub.com/{tenant}/api/identity/v1";
client.DefaultRequestHeaders.Add("Authorization", "Bearer " + accessToken);
var response = await client.GetStringAsync(url);
// Parse JSON response.
....
}
référence de https://www.theidentityhub.com/hub/Documentation/CallTheIdentityHubApi
je suis d'accord avec la réponse de Whiterabbit mais si vous avez beaucoup d'appels utilisant HttpClient le code semble un peu répétitif à mon avis.
je pense qu'il y a deux façons d'améliorer un peu la réponse.
créer une classe helper pour créer le client:
public static class ClientHelper
{
// Basic auth
public static HttpClient GetClient(string username,string password)
{
var authValue = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(Encoding.UTF8.GetBytes($"{username}:{password}")));
var client = new HttpClient(){
DefaultRequestHeaders = { Authorization = authValue}
//Set some other client defaults like timeout / BaseAddress
};
return client;
}
// Auth with bearer token
public static HttpClient GetClient(string token)
{
var authValue = new AuthenticationHeaderValue("Bearer", token);
var client = new HttpClient(){
DefaultRequestHeaders = { Authorization = authValue}
//Set some other client defaults like timeout / BaseAddress
};
return client;
}
}
Utilisation:
using(var client = ClientHelper.GetClient(username,password))
{
//Perform some http call
}
using(var client = ClientHelper.GetClient(token))
{
//Perform some http call
}
créer une méthode d'extension:
ne gagne pas une beauté prix mais fonctionne très bien :)
public static class HttpClientExtentions
{
public static AuthenticationHeaderValue ToAuthHeaderValue(this string username, string password)
{
return new AuthenticationHeaderValue("Basic",
Convert.ToBase64String(
System.Text.Encoding.ASCII.GetBytes(
$"{username}:{password}")));
}
}
Utilisation:
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Authorization = _username.ToAuthHeaderValue(_password);
}
encore une fois je pense que 2 options ci-dessus rendent la déclaration du client en utilisant un peu moins répétitif. Gardez à l'esprit que c'est une bonne pratique de réutiliser le HttpClient si vous faites plusieurs appels http, mais je pense que c'est un peu hors de portée pour cette question.
comme c'est une bonne pratique de réutiliser l'instance de HttpClient , pour performance and port exhaustion problems , et parce qu'aucune des réponses ne donne cette solution (et même vous menant vers de mauvaises pratiques :( ), j'ai mis ici un lien vers la réponse que j'ai faite sur une question similaire:
https://stackoverflow.com/a/40707446/717372
quelques sources sur la façon de bien utiliser HttpClient:
C'est comme ça que je l'ai fait:
using (HttpClient httpClient = new HttpClient())
{
Dictionary<string, string> tokenDetails = null;
var messageDetails = new Message { Id = 4, Message1 = des };
HttpClient client = new HttpClient();
client.BaseAddress = new Uri("http://localhost:3774/");
var login = new Dictionary<string, string>
{
{"grant_type", "password"},
{"username", "sa@role.com"},
{"password", "lopzwsx@23"},
};
var response = client.PostAsync("Token", new FormUrlEncodedContent(login)).Result;
if (response.IsSuccessStatusCode)
{
tokenDetails = JsonConvert.DeserializeObject<Dictionary<string, string>>(response.Content.ReadAsStringAsync().Result);
if (tokenDetails != null && tokenDetails.Any())
{
var tokenNo = tokenDetails.FirstOrDefault().Value;
client.DefaultRequestHeaders.Add("Authorization", "Bearer " + tokenNo);
client.PostAsJsonAsync("api/menu", messageDetails)
.ContinueWith((postTask) => postTask.Result.EnsureSuccessStatusCode());
}
}
}
cette vidéo de you-tube m'aide beaucoup. S'il vous plaît vérifier. https://www.youtube.com/watch?v=qCwnU06NV5Q
pour définir l'authentification de base avec C# HttpClient. Le code suivant fonctionne pour moi.
using (var client = new HttpClient())
{
var webUrl ="http://localhost/saleapi/api/";
var uri = "api/sales";
client.BaseAddress = new Uri(webUrl);
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
client.DefaultRequestHeaders.ConnectionClose = true;
//Set Basic Auth
var user = "username";
var password = "password";
var base64String =Convert.ToBase64String( Encoding.ASCII.GetBytes($"{user}:{password}"));
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic",base64String);
var result = await client.PostAsJsonAsync(uri, model);
return result;
}
utilisant AuthenticationHeaderValue
classe de System.Net.Http
assemblage
public AuthenticationHeaderValue(
string scheme,
string parameter
)
nous pouvons définir ou mettre à jour l'en-tête Authorization
existant pour notre httpclient
comme suit:
httpclient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", TokenResponse.AccessToken);
Utiliser Les Paramètres D'Autorisation De Base Et Json.
using (HttpClient client = new HttpClient())
{
var request_json = "your json string";
var content = new StringContent(request_json, Encoding.UTF8, "application/json");
var authenticationBytes = Encoding.ASCII.GetBytes("YourUsername:YourPassword");
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic",
Convert.ToBase64String(authenticationBytes));
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var result = await client.PostAsync("YourURL", content);
var result_string = await result.Content.ReadAsStringAsync();
}
cela peut aider à définir l'en-tête:
WebClient client = new WebClient();
string authInfo = this.credentials.UserName + ":" + this.credentials.Password;
authInfo = Convert.ToBase64String(Encoding.Default.GetBytes(authInfo));
client.Headers["Authorization"] = "Basic " + authInfo;
cela pourrait œuvres, si vous recevez un json ou xml du service et je pense que cela peut vous donner une idée de la façon dont les en-têtes et le type T fonctionne aussi, si vous utilisez la fonction MakeXmlRequest(mettre les résultats dans xmldocumnet) et MakeJsonRequest(mettre le json dans la classe que vous souhaitez qui ont la même structure que la réponse json) de la manière suivante,
/*-------------------------example of use-------------*/
MakeXmlRequest<XmlDocument>("your_uri",result=>your_xmlDocument_variable = result,error=>your_exception_Var = error);
MakeJsonRequest<classwhateveryouwant>("your_uri",result=>your_classwhateveryouwant_variable=result,error=>your_exception_Var=error)
/*-------------------------------------------------------------------------------*/
public class RestService
{
public void MakeXmlRequest<T>(string uri, Action<XmlDocument> successAction, Action<Exception> errorAction)
{
XmlDocument XMLResponse = new XmlDocument();
string wufooAPIKey = ""; /*or username as well*/
string password = "";
StringBuilder url = new StringBuilder();
url.Append(uri);
HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(url.ToString());
string authInfo = wufooAPIKey + ":" + password;
authInfo = Convert.ToBase64String(Encoding.Default.GetBytes(authInfo));
request.Timeout = 30000;
request.KeepAlive = false;
request.Headers["Authorization"] = "Basic " + authInfo;
string documento = "";
MakeRequest(request,response=> documento = response,
(error) =>
{
if (errorAction != null)
{
errorAction(error);
}
}
);
XMLResponse.LoadXml(documento);
successAction(XMLResponse);
}
public void MakeJsonRequest<T>(string uri, Action<T> successAction, Action<Exception> errorAction)
{
string wufooAPIKey = "";
string password = "";
StringBuilder url = new StringBuilder();
url.Append(uri);
HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(url.ToString());
string authInfo = wufooAPIKey + ":" + password;
authInfo = Convert.ToBase64String(Encoding.Default.GetBytes(authInfo));
request.Timeout = 30000;
request.KeepAlive = false;
request.Headers["Authorization"] = "Basic " + authInfo;
// request.Accept = "application/json";
// request.Method = "GET";
MakeRequest(
request,
(response) =>
{
if (successAction != null)
{
T toReturn;
try
{
toReturn = Deserialize<T>(response);
}
catch (Exception ex)
{
errorAction(ex);
return;
}
successAction(toReturn);
}
},
(error) =>
{
if (errorAction != null)
{
errorAction(error);
}
}
);
}
private void MakeRequest(HttpWebRequest request, Action<string> successAction, Action<Exception> errorAction)
{
try{
using (var webResponse = (HttpWebResponse)request.GetResponse())
{
using (var reader = new StreamReader(webResponse.GetResponseStream()))
{
var objText = reader.ReadToEnd();
successAction(objText);
}
}
}catch(HttpException ex){
errorAction(ex);
}
}
private T Deserialize<T>(string responseBody)
{
try
{
var toReturns = JsonConvert.DeserializeObject<T>(responseBody);
return toReturns;
}
catch (Exception ex)
{
string errores;
errores = ex.Message;
}
var toReturn = JsonConvert.DeserializeObject<T>(responseBody);
return toReturn;
}
}
}