Définition de l'en-tête d'autorisation de HttpClient


483

J'ai un HttpClient que j'utilise pour une API REST. Cependant, j'ai du mal à configurer l'en-tête d'autorisation. Je dois définir l'en-tête sur le jeton que j'ai reçu en faisant ma demande OAuth. J'ai vu du code pour .NET qui suggère ce qui suit,

httpClient.DefaultRequestHeaders.Authorization = new Credential(OAuth.token);

Cependant, la classe Credential n'existe pas dans WinRT. Quelqu'un a-t-il des idées sur la façon de définir l'en-tête d'autorisation?


1
À quel espace de noms appartient la classe Credential?
kampsj

@kampsj Je ne sais pas car c'est un espace de noms .NET qui n'existe pas dans WinRT
Stephen Hynes

1
Pourquoi ne pas request.Headers.Add ("Authorization", token);
ahll

Réponses:


817

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

httpClient.DefaultRequestHeaders.Authorization =
    new AuthenticationHeaderValue("Bearer", "Your Oauth token");

16
comment obtenir "votre jeton Oauth"?
Secret Squirrel

3
Ce que j'ai utilisé est: client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", "encrypted user/pwd");Prendre l'utilisateur / pwd crypté de l'extension chrome Advanced Rest Client.
Red

6
@Ry fyi, le deuxième paramètre est l'utilisateur encodé en base64: mot de passe (ce n'est pas crypté).
n00b

5
Mon application l'utilisait avec bonheur depuis des lustres, puis à l'improviste j'ai commencé à obtenir une RuntimeBinderException. J'ai dû passer à httpClient.DefaultRequestHeaders.Add ("Autorisation", "Porteur", "Votre jeton Oauth"); pour le faire recommencer.
kraeg

8
@kraeg, le code que vous avez répertorié ne se compile pas, vouliez-vous concaténer les 2 dernières chaînes comme ceci: client.DefaultRequestHeaders.Add ("Authorization", "Bearer" + "Your Oauth token");
TroySteven

354
request.DefaultRequestHeaders.Authorization = 
    new AuthenticationHeaderValue(
        "Basic", Convert.ToBase64String(
            System.Text.ASCIIEncoding.ASCII.GetBytes(
               $"{yourusername}:{yourpwd}")));

27
@MickyDuncan HttpClient a une DefaultRequestHeaders.Authorization. Et cette réponse vient de sauver ma journée. Merci beaucoup à WhiteRabbit.
Joey Schluchter

3
Cela ne fonctionne pas, si vous inspectez l'en-tête Auhtorization, il ne contient rien de plus qu'une chaîne Basic.
Raffaeu

1
Quelqu'un peut-il expliquer pourquoi il est important de convertir le nom d'utilisateur et le mot de passe en une chaîne base64? Il n'offre pas de véritable cryptage, alors pourquoi est-ce important?
Jonathan Wood

3
@JonathanWood Parce que c'est ainsi qu'il est défini pour être utilisé. Basic n'offre aucun cryptage, juste assez de codage pour éviter les problèmes de choix des caractères de mot de passe dans un en-tête.
Richard

4
Y a-t-il une raison particulière pour laquelle vous avez utilisé le codage ASCII ici? Je suppose qu'il n'y a aucun problème à utiliser l'encodage UTF8 puisque nous l'encodons en Base64 de toute façon. Je suppose que je me demande si la spécification d'authentification de base indique que la combinaison nom d'utilisateur: mot de passe doit être uniquement en ASCII?
écraser le

82

Je cherche un bon moyen de régler ce problème et je regarde la même question. J'espère que cette réponse aidera tous ceux qui ont le même problème à m'aimer.

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


1
Je fais exactement la même chose @willie et je reçois toujours un 401 de mon API
SomethingOn

2
Salut @SomethingOn Je pense que vous n'avez pas obtenu une clé de jeton correcte, de sorte que vous avez obtenu 401, je vais partager mon chemin sur ma "Poser une question" personnelle, j'espère que cela peut vous aider à résoudre votre problème.PS attend un moment
Willie Cheng

14
Vous ne devez pas mettre un HttpClient dans un usingbloc. (Oui, je sais que cela sonne à l'envers, mais vous fuirez les connexions si vous utilisez usingau lieu de simplement recycler le HttpClient.)
Jonathan Allen

42

Comme c'est une bonne pratique de réutiliser l'instance HttpClient , pour des problèmes de performances et d'épuisement de port , et parce qu'aucune des réponses ne donne cette solution (et même vous menant vers de mauvaises pratiques :(), je mets 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 d'utiliser HttpClient de la bonne façon:


5
Le problème d'épuisement du port n'est pas une blague. Cela n'arrive presque jamais en QA, mais frappera tout projet fortement utilisé en production.
Jonathan Allen

Voir mon article pour un exemple concret stackoverflow.com/a/59052193/790635
emp

41

Je suis d'accord avec la réponse de TheWhiteRabbit mais si vous avez beaucoup d'appels en utilisant HttpClient, le code semble un peu répétitif à mon avis.

Je pense qu'il y a 2 façons d'améliorer un peu la réponse.

Créez une classe d'assistance 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;
    }
}

Usage:

using(var client = ClientHelper.GetClient(username,password))
{
    //Perform some http call
}

using(var client = ClientHelper.GetClient(token))
{
    //Perform some http call
}

Créez une méthode d'extension:

Ne gagne pas de prix de beauté 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}")));
        }
    }

Usage:

using (var client = new HttpClient())
{
    client.DefaultRequestHeaders.Authorization = _username.ToAuthHeaderValue(_password); 
}

Encore une fois, je pense que 2 options ci-dessus rendent le client utilisant l'instruction un peu moins répétitif. Gardez à l'esprit qu'il est préférable de réutiliser le HttpClient si vous effectuez plusieurs appels http, mais je pense que c'est un peu hors de portée pour cette question.


20
je peux voir que votre réponse est votée mais je ne recommanderais pas cette approche TL; DR son tout simplement faux parce que l'épuisement de la prise, voici le lien d'
lacripta

2
@lacripta, C'est vrai, mais si vous lisez les 2 dernières phrases, je dis sa meilleure pratique pour réutiliser HttpClient pour exactement cette raison, mais je pense que c'est hors de portée pour cette question.
Florian Schaal

1
je peux voir votre point mais vous faites une suggestion disant que le code est répétitif, cela pourrait conduire à une mauvaise utilisation de cette méthode d'usine, il serait bon de signaler dans les premières lignes qu'il entraînera des problèmes d'utilisation des ressources à l'avenir spécialement pour ce cas. et pas seulement un avertissement que la plupart ne liront pas.
lacripta

1
Il serait préférable d'utiliser HttpClientFactory pour éviter le problème d'épuisement du socket.
RyanOC

21

Je mettais le jeton du porteur

httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);

Cela fonctionnait dans un point final, mais pas dans un autre. La question était que j'avais minuscule bsur "bearer". Après le changement, cela fonctionne pour les deux API que je frappe. Une chose si facile à manquer si vous ne la considérez même pas comme l'une des meules de foin pour chercher l'aiguille.

Assurez-vous d'avoir "Bearer"- avec du capital.


18

Je vous propose:

HttpClient.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");

Et puis vous pouvez l'utiliser comme ça:

var response = await client.GetAsync(url);
if (response.IsSuccessStatusCode)
{
    responseMessage = await response.Content.ReadAsAsync<ResponseMessage>();
}

Si votre jeton expire toutes les 1h par exemple, vous devez mettre à jour le HttpClient avec cette solution. Je suggère de vérifier que votre jeton est toujours valide et de le rafraîchir autrement et de l'ajouter au HttpRequestMessage
Johan Franzén

13

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;
        }

Exactement ce dont j'avais besoin, merci.
rchrd

10

Voici comment 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 sur YouTube m'aide beaucoup. Vérifie s'il te plaît. https://www.youtube.com/watch?v=qCwnU06NV5Q


9

Utilisez l'autorisation de base et les paramètres 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
Vous ne devez pas inclure de code pour désactiver la vérification des certificats SSL dans un exemple comme celui-ci. Les gens peuvent copier aveuglément votre code sans réaliser ce qu'il fait. J'ai supprimé ces lignes pour vous.
John

9

Si vous souhaitez réutiliser le HttpClient , il est conseillé de ne pas utiliser leDefaultRequestHeaders comme ils sont utilisés pour envoyer avec chaque demande.

Vous pouvez essayer ceci:

var requestMessage = new HttpRequestMessage
    {
        Method = HttpMethod.Post,
        Content = new StringContent("...", Encoding.UTF8, "application/json"),
        RequestUri = new Uri("...")
    };

requestMessage.Headers.Authorization = new AuthenticationHeaderValue("Basic", 
    Convert.ToBase64String(System.Text.ASCIIEncoding.ASCII.GetBytes($"{user}:{password}")));

var response = await _httpClient.SendAsync(requestMessage);

8

6 ans plus tard, mais en ajoutant cela au cas où cela aiderait quelqu'un.

https://www.codeproject.com/Tips/996401/Authenticate-WebAPIs-with-Basic-and-Windows-Authen

var authenticationBytes = Encoding.ASCII.GetBytes("<username>:<password>");
using (HttpClient confClient = new HttpClient())
{
  confClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", 
         Convert.ToBase64String(authenticationBytes));
  confClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(Constants.MediaType));  
  HttpResponseMessage message = confClient.GetAsync("<service URI>").Result;
  if (message.IsSuccessStatusCode)
  {
    var inter = message.Content.ReadAsStringAsync();
    List<string> result = JsonConvert.DeserializeObject<List<string>>(inter.Result);
  }
}

A travaillé pour moi. Contrairement à la réponse de Willie Cheng qui n'a pas fonctionné pour moi.
user890332

5

Option UTF8

request.DefaultRequestHeaders.Authorization = 
new AuthenticationHeaderValue(
    "Basic", Convert.ToBase64String(
        System.Text.Encoding.UTF8.GetBytes(
           $"{yourusername}:{yourpwd}")));

3

Utilisation de la AuthenticationHeaderValueclasse d' System.Net.Httpassemblage

public AuthenticationHeaderValue(
    string scheme,
    string parameter
)

nous pouvons définir ou mettre à jour l'en- Authorizationtête existant pour notre httpclientcomme ceci:

httpclient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", TokenResponse.AccessToken);

1
Bienvenue sur SO, mais veuillez ajouter un peu plus de contexte.
JP Hellemons

La réponse est parfaite, mais cela ne ferait pas de mal d'avoir une seule ligne expliquant ce que son code est censé faire. Je dis juste.
iiminov

2

BaseWebApi.cs

public abstract class BaseWebApi
{
    //Inject HttpClient from Ninject
    private readonly HttpClient _httpClient;
    public BaseWebApi(HttpClient httpclient)
    {
        _httpClient = httpClient;
    }

    public async Task<TOut> PostAsync<TOut>(string method, object param, Dictionary<string, string> headers, HttpMethod httpMethod)
    {
        //Set url

        HttpResponseMessage response;
        using (var request = new HttpRequestMessage(httpMethod, url))
        {
            AddBody(param, request);
            AddHeaders(request, headers);
            response = await _httpClient.SendAsync(request, cancellationToken);
        }

        if(response.IsSuccessStatusCode)
        {
             return await response.Content.ReadAsAsync<TOut>();
        }
        //Exception handling
    }

    private void AddHeaders(HttpRequestMessage request, Dictionary<string, string> headers)
    {
        request.Headers.Accept.Clear();
        request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));

        if (headers == null) return;

        foreach (var header in headers)
        {
            request.Headers.Add(header.Key, header.Value);
        }
    }

    private static void AddBody(object param, HttpRequestMessage request)
    {
        if (param != null)
        {
            var content = JsonConvert.SerializeObject(param);
            request.Content = new StringContent(content);
            request.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
        }
    }

SubWebApi.cs

public sealed class SubWebApi : BaseWebApi
{
    public SubWebApi(HttpClient httpClient) : base(httpClient) {}

    public async Task<StuffResponse> GetStuffAsync(int cvr)
    {
        var method = "get/stuff";
        var request = new StuffRequest 
        {
            query = "GiveMeStuff"
        }
        return await PostAsync<StuffResponse>(method, request, GetHeaders(), HttpMethod.Post);
    }
    private Dictionary<string, string> GetHeaders()
    {
        var headers = new Dictionary<string, string>();
        var basicAuth = GetBasicAuth();
        headers.Add("Authorization", basicAuth);
        return headers;
    }

    private string GetBasicAuth()
    {
        var byteArray = Encoding.ASCII.GetBytes($"{SystemSettings.Username}:{SystemSettings.Password}");
        var authString = Convert.ToBase64String(byteArray);
        return $"Basic {authString}";
    }
}

1

Dans le cas où vous souhaitez envoyer une HttpClientdemande avec Bearer Token, ce code peut être une bonne solution:

var requestMessage = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    Content = new StringContent(".....", Encoding.UTF8, "application/json"),
    RequestUri = new Uri(".....")
};

requestMessage.Headers.Authorization = new AuthenticationHeaderValue("Bearer", "Your token");

var response = await _httpClient.SendAsync(requestMessage);

0

Dans net .core, vous pouvez utiliser

var client = new HttpClient();
client.SetBasicAuthentication(userName, password);

ou

var client = new HttpClient();
client.SetBearerToken(token);

1
Le premier exemple ne fonctionne pas car il SetBasicAuthentication()n'est pas disponible par défaut, il doit donc s'agir d'une méthode d'extension. Où est-il défini?
ViRuSTriNiTy

0

Il peut être plus facile d'utiliser une bibliothèque existante.

Par exemple, les méthodes d'extension ci-dessous sont ajoutées avec Identity Server 4 https://www.nuget.org/packages/IdentityModel/

 public static void SetBasicAuthentication(this HttpClient client, string userName, string password);
    //
    // Summary:
    //     Sets a basic authentication header.
    //
    // Parameters:
    //   request:
    //     The HTTP request message.
    //
    //   userName:
    //     Name of the user.
    //
    //   password:
    //     The password.
    public static void SetBasicAuthentication(this HttpRequestMessage request, string userName, string password);
    //
    // Summary:
    //     Sets a basic authentication header for RFC6749 client authentication.
    //
    // Parameters:
    //   client:
    //     The client.
    //
    //   userName:
    //     Name of the user.
    //
    //   password:
    //     The password.
    public static void SetBasicAuthenticationOAuth(this HttpClient client, string userName, string password);
    //
    // Summary:
    //     Sets a basic authentication header for RFC6749 client authentication.
    //
    // Parameters:
    //   request:
    //     The HTTP request message.
    //
    //   userName:
    //     Name of the user.
    //
    //   password:
    //     The password.
    public static void SetBasicAuthenticationOAuth(this HttpRequestMessage request, string userName, string password);
    //
    // Summary:
    //     Sets an authorization header with a bearer token.
    //
    // Parameters:
    //   client:
    //     The client.
    //
    //   token:
    //     The token.
    public static void SetBearerToken(this HttpClient client, string token);
    //
    // Summary:
    //     Sets an authorization header with a bearer token.
    //
    // Parameters:
    //   request:
    //     The HTTP request message.
    //
    //   token:
    //     The token.
    public static void SetBearerToken(this HttpRequestMessage request, string token);
    //
    // Summary:
    //     Sets an authorization header with a given scheme and value.
    //
    // Parameters:
    //   client:
    //     The client.
    //
    //   scheme:
    //     The scheme.
    //
    //   token:
    //     The token.
    public static void SetToken(this HttpClient client, string scheme, string token);
    //
    // Summary:
    //     Sets an authorization header with a given scheme and value.
    //
    // Parameters:
    //   request:
    //     The HTTP request message.
    //
    //   scheme:
    //     The scheme.
    //
    //   token:
    //     The token.
    public static void SetToken(this HttpRequestMessage request, string scheme, string token);

0

Le flux de processus Oauth est complexe et il y a toujours de la place pour une erreur ou une autre. Ma suggestion sera de toujours utiliser le code passe-partout et un ensemble de bibliothèques pour le flux d'authentification OAuth, cela vous facilitera la vie.

Voici le lien pour l'ensemble des bibliothèques. Bibliothèques OAuth pour .Net


-1

cela pourrait fonctionner, si vous recevez un json ou un 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 fonctionnent aussi, si vous utilisez la fonction MakeXmlRequest (mettez les résultats dans xmldocumnet) et MakeJsonRequest (mettez le json dans la classe que vous souhaitez qui a 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;
    }
}
}

-1
static async Task<AccessToken> GetToken()
{
        string clientId = "XXX";
        string clientSecret = "YYY";
        string credentials = String.Format("{0}:{1}", clientId, clientSecret);

        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(Encoding.UTF8.GetBytes(credentials)));
            List<KeyValuePair<string, string>> requestData = new List<KeyValuePair<string, string>>();
            requestData.Add(new KeyValuePair<string, string>("grant_type", "client_credentials"));
            FormUrlEncodedContent requestBody = new FormUrlEncodedContent(requestData);
            var request = await client.PostAsync("https://accounts.spotify.com/api/token", requestBody);
            var response = await request.Content.ReadAsStringAsync();
            return JsonConvert.DeserializeObject<AccessToken>(response);
        }
    }

Bienvenue sur stackoverflow. En plus de la réponse que vous avez fournie, veuillez envisager de fournir une brève explication de la raison et de la manière dont cela résout le problème.
jtate

-2

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;

9
Il utilise HttpClient, non WebClient.
Jean Hominal
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.