it-swarm.com.de

Festlegen des Berechtigungsheaders von HttpClient

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

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

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

313
Stephen Hynes

Der Weg, dies zu tun, ist der folgende:

httpClient.DefaultRequestHeaders.Authorization =
    new AuthenticationHeaderValue("Bearer", "Your Oauth token");
583
Stephen Hynes
request.DefaultRequestHeaders.Authorization = 
    new AuthenticationHeaderValue(
        "Basic", 
        Convert.ToBase64String(
            System.Text.ASCIIEncoding.ASCII.GetBytes(
                string.Format("{0}:{1}", "yourusername", "yourpwd"))));
228
TheWhiteRabbit

Ich suche einen guten Weg, um mit diesem Problem umzugehen, und ich schaue mir die gleiche Frage an. Hoffentlich hilft mir diese Antwort allen, die das gleiche Problem haben, 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

61
Willie Cheng

Ich stimme der Antwort von TheWhiteRabbit zu, aber wenn Sie viele Anrufe mit HttpClient tätigen, scheint der Code meiner Meinung nach etwas repetitiv zu sein. 

Ich denke, es gibt zwei Möglichkeiten, um die Antwort etwas 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); 
}

Ich denke wieder, dass die beiden obigen Optionen den Client mit der Anweisung etwas weniger repetitiv machen. Denken Sie daran, dass es die beste Vorgehensweise ist, den HttpClient wiederzuverwenden, wenn Sie mehrere http-Aufrufe durchführen, aber ich denke, das ist für diese Frage ein wenig zu weit.

33
Florian Schaal

Es ist eine gute Praxis, die HttpClient-Instanz für Leistungs- und Port-Erschöpfungsprobleme erneut zu verwenden, und weil keine der Antworten diese Lösung bietet (und Sie sogar zu schlechten Praktiken führt: Ich habe hier einen Link zu meiner Antwort auf eine ähnliche Frage gesetzt:

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

Einige Quellen zur Verwendung von HttpClient:

25
Philippe

So legen Sie die grundlegende Authentifizierung 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;
        }
9
LENG UNG

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

Dieses You-Tube-Video hilft mir sehr. Bitte schau es dir an . https://www.youtube.com/watch?v=qCwnU06NV5Q

7
Dayan

Verwenden Sie grundlegende Berechtigungs- 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();
                    }
5
MohammadSoori

UTF8-Option

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

AuthenticationHeaderValue-Klasse von System.Net.Http Assembly verwenden

public AuthenticationHeaderValue(
    string scheme,
    string parameter
)

wir können vorhandene Authorization-Header für unsere httpclient setzen oder aktualisieren:

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

6 Jahre später, aber dies hinzugefügt, 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);
  }
}
1
MPJ567

dies könnte funktionieren, wenn Sie einen JSON- oder XML-Code 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 (put results in xmldocumnet) und MakeJsonRequest verwenden (Setzen Sie den JSON in die Klasse, die dieselbe Struktur haben soll wie die JSON-Antwort)

/*-------------------------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;
    }
}
}
0
Jesus Cañedo

Ich habe das Trägertoken gesetzt httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue ("Bearer", Token);

Es arbeitete an einem Endpunkt, aber nicht an einem anderen. Das Problem war, dass ich Kleinbuchstabe "b" für "Träger" hatte. Nach dem Wechsel funktioniert es jetzt für beide Apis, die ich treffe. Eine solche Sache, die man leicht übersehen kann, wenn man sie gar nicht als einen der Heuhaufen betrachtet, um nach der Nadel zu suchen.

Stellen Sie sicher, dass Sie "Träger" haben - mit Kapital.

0
Alan Ball