Festlegen des Autorisierungsheaders von HttpClient

483

Ich habe einen HttpClient, den ich für eine REST-API verwende. Ich habe jedoch Probleme beim Einrichten des Autorisierungsheaders. Ich muss den Header auf das Token setzen, das ich von meiner OAuth-Anfrage erhalten habe. Ich habe Code für .NET gesehen, der Folgendes vorschlägt:

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

Die Credential-Klasse ist in WinRT jedoch nicht vorhanden. Hat jemand eine Idee, wie man den Autorisierungsheader setzt?

Stephen Hynes
quelle
1
Zu welchem ​​Namespace gehört die Credential-Klasse?
Kampsj
@kampsj Ich weiß nicht, da es ein .NET-Namespace ist, der in WinRT nicht existiert
Stephen Hynes
1
Warum nicht anfordern.Headers.Add ("Authorization", Token);
Ahll

Antworten:

816

Der Weg, dies zu tun, ist der folgende:

httpClient.DefaultRequestHeaders.Authorization =
    new AuthenticationHeaderValue("Bearer", "Your Oauth token");
Stephen Hynes
quelle
15
Wie bekommst du "Dein Oauth-Token"?
Geheimes Eichhörnchen
3
Was ich verwendet habe, ist: client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", "encrypted user/pwd");Entschlüsselte Benutzer / pwd von der Chrome-Erweiterung des Advanced Rest Client nehmen.
Red
6
@Red fyi, der zweite Parameter ist der base64-codierte Benutzer: password (nicht verschlüsselt).
n00b
5
Meine Anwendung nutzte dies seit Ewigkeiten, und aus heiterem Himmel bekam ich eine RuntimeBinderException. Ich musste zu httpClient.DefaultRequestHeaders.Add wechseln ("Authorization", "Bearer", "Your Oauth Token"); um es wieder in Gang zu bringen.
Kraeg
8
@kraeg, der von Ihnen aufgelistete Code wird nicht kompiliert. Wollten Sie die letzten beiden Zeichenfolgen wie folgt verketten: 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}")));
TheWhiteRabbit
quelle
27
@MickyDuncan HttpClient verfügt über eine DefaultRequestHeaders.Authorization. Und diese Antwort hat gerade meinen Tag gerettet. Vielen Dank an WhiteRabbit.
Joey Schluchter
3
Dies funktioniert nicht, wenn Sie überprüfen, ob der Auhtorization-Header nur eine Zeichenfolge Basic enthält.
Raffaeu
1
Kann jemand erklären, warum es wichtig ist, den Benutzernamen und das Passwort in eine base64-Zeichenfolge zu konvertieren? Es bietet keine echte Verschlüsselung. Warum ist das wichtig?
Jonathan Wood
3
@JonathanWood Weil es so definiert ist, verwendet zu werden. Basic bietet keine Verschlüsselung, nur genug Codierung, um Probleme bei der Auswahl der Kennwortzeichen in einem Header zu vermeiden.
Richard
4
Gibt es einen bestimmten Grund, warum Sie hier die ASCII-Codierung verwendet haben? Ich gehe davon aus, dass es kein Problem mit der Verwendung der UTF8-Codierung gibt, da wir sie sowieso mit Base64 codieren. Ich frage mich wohl, ob die Standardauthentifizierungsspezifikation besagt, dass die Kombination aus Benutzername und Kennwort nur in ASCII enthalten sein sollte.
Crush
82

Ich suche nach einem guten Weg, um mit diesem Problem umzugehen, und ich sehe die gleiche Frage. Hoffentlich hilft diese Antwort jedem, der das gleiche Problem hat, wie ich.

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

Referenz von https://www.theidentityhub.com/hub/Documentation/CallTheIdentityHubApi

Willie Cheng
quelle
1
Ich mache genau das Gleiche @willie und bekomme immer noch einen 401 von meiner API
SomethingOn
2
Hallo @SomethingOn Ich denke, Sie haben keinen korrekten Token-Schlüssel erhalten, so dass Sie 401 erhalten haben. Ich werde meinen Weg auf meiner persönlichen "Frage stellen" teilen, hoffentlich kann es Ihnen helfen, Ihr Problem zu lösen. PS wartet auf einen Moment
Willie Cheng
14
Sie sollten keinen HttpClient in einen usingBlock einfügen . (Ja, ich weiß, es klingt rückwärts, aber Sie werden Verbindungen verlieren, wenn Sie verwenden, usinganstatt nur den HttpClient zu recyceln.)
Jonathan Allen
42

Da es eine gute Praxis ist, die HttpClient-Instanz für Leistungs- und Port-Erschöpfungsprobleme wiederzuverwenden , und weil keine der Antworten diese Lösung bietet (und Sie sogar zu schlechten Praktiken führt :(), habe ich hier einen Link zu der Antwort eingefügt, die ich gegeben habe zu einer ähnlichen Frage:

https://stackoverflow.com/a/40707446/717372

Einige Quellen zur richtigen Verwendung von HttpClient:

Philippe
quelle
5
Das Problem der Hafenerschöpfung ist kein Scherz. Es passiert fast nie in der Qualitätssicherung, wird aber jedes stark genutzte Projekt in der Produktion treffen.
Jonathan Allen
In meinem Beitrag finden Sie ein konkretes Beispiel für stackoverflow.com/a/59052193/790635
emp
41

Ich stimme der Antwort von TheWhiteRabbit zu, aber wenn Sie viele Anrufe mit HttpClient haben, scheint sich der Code meiner Meinung nach etwas zu wiederholen.

Ich denke, es gibt zwei Möglichkeiten, die Antwort ein wenig zu verbessern.

Erstellen Sie eine Hilfsklasse, um den Client zu erstellen:

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

Verwendungszweck:

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

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

Erstellen Sie eine Erweiterungsmethode:

Gewinnt keinen Schönheitspreis, funktioniert aber großartig :)

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

Verwendungszweck:

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

Wiederum denke ich, dass 2 der oben genannten Optionen den Client mit der Anweisung etwas weniger repetitiv machen. Denken Sie daran, dass es empfehlenswert ist, den HttpClient wiederzuverwenden, wenn Sie mehrere http-Aufrufe tätigen, aber ich denke, dass dies für diese Frage etwas unumgänglich ist.

Florian Schaal
quelle
20
ich sehen kann Ihre Antwort upvoted ist , aber ich würde diesen Ansatz TL nicht empfehlen, DR seine schlicht falsch , weil Buchse Erschöpfung, hier ist die Erklärung Link
lacripta
2
@lacripta, Dies ist wahr, aber wenn Sie die letzten 2 Sätze lesen, sage ich, dass es die beste Vorgehensweise ist, HttpClient aus genau diesem Grund wiederzuverwenden, aber ich denke, dass dies für diese Frage nicht möglich ist.
Florian Schaal
1
Ich kann Ihren Standpunkt sehen, aber Sie machen einen Vorschlag, der besagt, dass sich der Code wiederholt. Dies könnte zu einem Missbrauch dieser Factory-Methode führen. Es wäre gut, in den ersten Zeilen darauf hinzuweisen, dass dies in Zukunft zu Problemen bei der Ressourcennutzung führen wird dieser Fall. und nicht nur eine Warnung, die die meisten nicht lesen.
Lacripta
1
Die Verwendung der HttpClientFactory ist viel besser, um das Problem der Socket-Erschöpfung zu vermeiden.
RyanOC
21

Ich habe den Inhaber-Token gesetzt

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

Es funktionierte an einem Endpunkt, aber nicht an einem anderen. Das Problem war , dass ich kleingeschrieben hatte bauf "bearer". Nach dem Wechsel funktioniert es jetzt für beide APIs, die ich treffe. So leicht zu übersehen, wenn Sie es nicht einmal als einen der Heuhaufen betrachten, um nach der Nadel zu suchen.

Stellen Sie sicher, dass Sie "Bearer"- mit Kapital haben.

Alan Ball
quelle
18

Ich schlage Ihnen vor:

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

Und dann können Sie es so verwenden:

var response = await client.GetAsync(url);
if (response.IsSuccessStatusCode)
{
    responseMessage = await response.Content.ReadAsAsync<ResponseMessage>();
}
Amankhani MohammadJavad
quelle
Wenn Ihr Token beispielsweise alle 1 Stunde abläuft, müssen Sie den HttpClient mit dieser Lösung aktualisieren. Ich würde vorschlagen, zu überprüfen, ob Ihr Token noch gültig ist, es anderweitig zu aktualisieren und es der HttpRequestMessage
Johan Franzén
13

So legen Sie die Basisauthentifizierung mit C # HttpClient fest Der folgende Code funktioniert für mich.

   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;
        }
LENG UNG
quelle
Genau das, was ich brauchte, danke.
15.
9

So habe ich es gemacht:

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", "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());
      }
   }
}

Dieses You-Tube-Video hilft mir sehr. Bitte probieren Sie es aus. https://www.youtube.com/watch?v=qCwnU06NV5Q

Dayan
quelle
9

Verwenden Sie grundlegende Autorisierungs- und Json-Parameter.

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();
                    }
MohammadSoori
quelle
2
In einem Beispiel wie diesem sollten Sie keinen Code einschließen, um die Überprüfung von SSL-Zertifikaten zu deaktivieren. Menschen können Ihren Code blind kopieren, ohne zu wissen, was er tut. Ich habe diese Zeilen für Sie entfernt.
John
9

Wenn Sie das wiederverwenden möchten HttpClient, wird empfohlen, das nicht zu verwenden, DefaultRequestHeadersda es zum Senden bei jeder Anfrage verwendet wird.

Sie könnten dies versuchen:

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);
emp
quelle
8

6 Jahre später, aber dies hinzufügen, falls es jemandem hilft.

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);
  }
}
MPJ567
quelle
Hat für mich gearbeitet. Im Gegensatz zu Willie Chengs Antwort, die bei mir nicht funktionierte.
user890332
5

UTF8-Option

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

Mit AuthenticationHeaderValueKlasse von System.Net.HttpMontage

public AuthenticationHeaderValue(
    string scheme,
    string parameter
)

Wir können den vorhandenen AuthorizationHeader httpclientso einstellen oder aktualisieren :

httpclient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", TokenResponse.AccessToken);
Verschmelzung
quelle
1
Willkommen auf SO, aber bitte fügen Sie etwas mehr Kontext hinzu.
JP Hellemons
Die Antwort ist genau richtig, aber es würde nicht schaden, wenn ein Einzeiler erklärt, was sein Code tun soll. Ich sage nur.
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}";
    }
}
Joel Wiklund
quelle
1

Wenn Sie eine HttpClientAnfrage mit Bearer Token senden möchten , kann dieser Code eine gute Lösung sein:

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);
Jourmand
quelle
0

In net .core können Sie verwenden

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

oder

var client = new HttpClient();
client.SetBearerToken(token);
Thom Kiesewetter
quelle
1
Das erste Beispiel funktioniert nicht, da SetBasicAuthentication()es standardmäßig nicht verfügbar ist. Es muss sich also um eine Erweiterungsmethode handeln. Wo ist es definiert?
ViRuSTriNiTy
0

Es ist möglicherweise einfacher, eine vorhandene Bibliothek zu verwenden.

Die folgenden Erweiterungsmethoden werden beispielsweise mit Identity Server 4 https://www.nuget.org/packages/IdentityModel/ hinzugefügt.

 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);
Lee Smith
quelle
0

Der Prozessablauf ist komplex und es gibt immer Platz für den einen oder anderen Fehler. Mein Vorschlag wird sein, immer den Boilerplate-Code und eine Reihe von Bibliotheken für den OAuth-Authentifizierungsfluss zu verwenden. Dies erleichtert Ihnen das Leben.

Hier ist der Link für die Bibliothek. OAuth-Bibliotheken für .Net

Khurram Jamil
quelle
-1

Dies könnte funktionieren, wenn Sie einen JSON oder eine XML vom Dienst erhalten und ich denke, dies kann Ihnen eine Vorstellung davon geben, wie die Header und der T-Typ auch funktionieren, wenn Sie die Funktionen MakeXmlRequest (Ergebnisse in xmldocumnet setzen) und MakeJsonRequest verwenden (Setzen Sie den JSON in die gewünschte Klasse, die dieselbe Struktur wie die JSON-Antwort hat.)

/*-------------------------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;
    }
}
}
Jesus Cañedo
quelle
-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);
        }
    }
Saurabh Seth
quelle
Willkommen beim Stackoverflow. Zusätzlich zu der Antwort, die Sie gegeben haben, sollten Sie eine kurze Erklärung darüber geben, warum und wie dies das Problem behebt.
19.
-2

Dies kann beim Einstellen des Headers hilfreich sein:

WebClient client = new WebClient();

string authInfo = this.credentials.UserName + ":" + this.credentials.Password;
authInfo = Convert.ToBase64String(Encoding.Default.GetBytes(authInfo));
client.Headers["Authorization"] = "Basic " + authInfo;
Codehilfe
quelle
9
Er benutzt HttpClientnicht WebClient.
Jean Hominal