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?

275
demandé sur Stephen Hynes 2013-01-31 17:52:45
la source

11 ответов

Donc, la façon de le faire est la suivante,

httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", "Your Oauth token");
509
répondu Stephen Hynes 2014-10-17 03:17:43
la source
request.DefaultRequestHeaders.Authorization = 
    new AuthenticationHeaderValue(
        "Basic", 
        Convert.ToBase64String(
            System.Text.ASCIIEncoding.ASCII.GetBytes(
                string.Format("{0}:{1}", "yourusername", "yourpwd"))));
202
répondu TheWhiteRabbit 2015-03-03 19:55:51
la source

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

49
répondu Willie Cheng 2015-09-21 12:31:23
la source

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.

33
répondu Florian Schaal 2018-03-10 13:59:11
la source

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:

17
répondu Philippe 2018-06-07 11:02:24
la source

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", "[email protected]"},
           {"password", "[email protected]"},
       };
   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

5
répondu Dayan 2017-12-23 09:33:04
la source

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;
        }
4
répondu LENG UNG 2018-03-19 06:53:26
la source

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);
3
répondu Fusion 2017-07-25 19:25:34
la source

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();
                    }
2
répondu MohammadSoori 2018-04-13 10:00:15
la source

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;
-2
répondu Codehelp 2014-05-13 13:01:14
la source

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;
    }
}
}
-2
répondu Jesus Cañedo 2014-08-01 20:35:11
la source

Autres questions sur c# rest windows-runtime oauth