HttpClient Yetkilendirme Üstbilgisini Ayarlama


483

Bir REST API için kullanıyorum bir HttpClient var. Ancak Yetkilendirme başlığını ayarlamakta sorun yaşıyorum. Başlığı, OAuth isteğimi yaptığım jetona ayarlamam gerekiyor. .NET için aşağıdakileri öneren bazı kodlar gördüm,

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

Ancak Credential sınıfı WinRT'de yoktur. Yetkilendirme üstbilgisini nasıl ayarlayacağınız hakkında bir fikri olan var mı?


1
Credential sınıfı hangi ad alanına aittir?
kampsj

@kampsj WinRT'de olmayan bir .NET ad alanı olduğu için bilmiyorum
Stephen Hynes

1
Neden request.Headers.Add ("Yetkilendirme", belirteç);
AhII

Yanıtlar:


816

Yani bunu yapmanın yolu şudur,

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

15
"Oauth jetonunu" nasıl alabilirsin?
Gizli Sincap

3
Ne kullandım: client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", "encrypted user/pwd");Gelişmiş Rest Client krom uzantısından şifreli kullanıcı / pwd almak.
Kırmızı

6
@ Kırmızı fyi, ikinci parametre base64 şifreli kullanıcı: şifre (şifrelenmemiş).
n00b

5
Benim uygulama mutlu bu yaş için kullanıyordu, sonra mavi dışında bir RuntimeBinderException almaya başladı. Ben geçiş zorunda httpClient.DefaultRequestHeaders.Add ( "Yetki", "Hamiline", "Kişisel Oauth anahtarı"); tekrar devam etmesini sağlamak için.
kraeg

8
@kraeg, listelediğiniz kod derlenmiyor, son 2 dizeyi şu şekilde birleştirmeyi mi kastettiniz: client.DefaultRequestHeaders.Add ("Yetkilendirme", "Taşıyıcı" + "Oauth jetonunuz");
TroySteven

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

27
@MickyDuncan HttpClient öğesinin DefaultRequestHeaders.Authorization özelliği vardır. Ve bu cevap sadece günümü kurtardı. WhiteRabbit'e çok teşekkürler.
Joey Schluchter

3
Bu işe yaramazsa, Yetkilendirme üstbilgisinin Basic dizesinden başka bir şey içermediğini kontrol ederseniz.
Raffaeu

1
Bir kullanıcı adını ve şifreyi base64 dizesine dönüştürmenin neden önemli olduğunu açıklayabilir mi? Gerçek bir şifreleme sunmuyor, bu neden önemli?
Jonathan Wood

3
@JonathanWood Çünkü bu nasıl kullanılacak tanımlanır. Basic, şifreleme sunmaz, bir başlıktaki şifre karakterleri seçimiyle ilgili sorunları önlemek için yeterli kodlama sağlar.
Richard

4
Burada ASCII kodlamasını kullanmanızın özel bir nedeni var mı? Yine de Base64 kodladığımız için UTF8 kodlaması kullanmayla ilgili bir sorun olmadığını varsayıyorum. Temel kimlik doğrulama belirtimi kullanıcı adı: şifre combo sadece ASCII olması gerektiğini söylüyor merak ediyorum sanırım?
ezmek

82

Bu konuyla başa çıkmanın iyi bir yolunu arıyorum ve aynı soruyu arıyorum. Umarım, bu cevap aynı sorunu yaşayan herkesin beni sevmesine yardımcı olacaktır.

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

https://www.theidentityhub.com/hub/Documentation/CallTheIdentityHubApi referansı


1
@Willie ile aynı şeyi yapıyorum ve hala API'mdan 401 alıyorum
SomethingOn

2
Merhaba @SomethingOn, doğru bir jeton anahtarı alamadığını düşünüyorum, böylece 401'e sahipsin, kişisel "Soru Sor" yolumu paylaşacağım, umarım sorunla başa çıkmana yardımcı olabilir.
Willie Cheng

14
Bir usingbloğa HttpClient koymamalısınız . (Evet, geri geldiğini biliyorum, ancak usingsadece HttpClient'i geri dönüştürmek yerine kullanırsanız bağlantılara sızacaksınız.)
Jonathan Allen

42

Bir olduğu gibi HttpClient örneğini yeniden iyi bir uygulama için, performans ve liman tükenme problemlerinin cevapların hiçbiri bu çözüm vermek (ve hatta :( kötü uygulamalardan doğru sizi lider) nedeniyle ve ben burada yaptığım cevap doğru bir bağlantı koymak benzer bir soru üzerine:

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

HttpClient'in doğru şekilde nasıl kullanılacağı ile ilgili bazı kaynaklar:


5
Liman tükenme sorunu şaka değil. QA'da neredeyse hiç olmaz, ancak üretimde yoğun olarak kullanılan herhangi bir projeye çarpar.
Jonathan Allen

Somut bir örnek için yazıma bakın stackoverflow.com/a/59052193/790635
emp

41

TheWhiteRabbit'in cevabına katılıyorum, ancak HttpClient kullanarak çok fazla çağrınız varsa, kod bence biraz tekrarlı görünüyor.

Cevabı biraz geliştirmenin 2 yolu olduğunu düşünüyorum.

İstemciyi oluşturmak için bir yardımcı sınıf oluşturun:

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

Kullanımı:

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

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

Bir uzantı yöntemi oluşturun:

Bir güzellik ödülü kazanmaz ama harika çalışır :)

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

Kullanımı:

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

Yine yukarıdaki 2 seçenek ifade kullanarak istemci daha az tekrarlayan yapmak düşünüyorum. Birden fazla http çağrısı yapıyorsanız HttpClient'i yeniden kullanmanın en iyi yöntem olduğunu unutmayın, ancak bu sorunun biraz kapsam dışı olduğunu düşünüyorum.


20
Cevabınızın açıldığını görebiliyorum ama bu yaklaşımı tavsiye etmem TL; soket tükenmesi nedeniyle düz yanlış DR, işte açıklama bağlantısı
lacripta 16

2
@lacripta, Bu doğrudur, ancak son 2 cümleyi okursanız, HttpClient'i tam olarak bu nedenle yeniden kullanmak için en iyi uygulamasını söylüyorum, ancak bu sorunun kapsam dışı olduğunu düşünüyorum.
Florian Schaal

1
Ben senin noktaya görebiliyorum ama kod tekrarlayan olduğunu söyleyerek bir öneri yapıyoruz, bu bu fabrika yönteminin kötüye yol açabilir, ilk başta satırları için özel olarak kaynak kullanım sorunlarına neden olacağını işaret etmek iyi olurdu bu durum. ve sadece en çok okumayacak bir uyarı değil.
lacripta

1
Soket tükenmesi problemini önlemek için HttpClientFactory kullanmak çok daha iyi olur.
RyanOC

21

Taşıyıcı jetonunu ayarlıyordum

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

Bir uç noktada çalışıyordu, ama başka bir yerde değildi. Sorun, daha küçük olmama neden boldu "bearer". Değişimden sonra şimdi vurduğum her iki api için de çalışıyor. İğneyi aramak için samanlıklardan biri olarak düşünmüyorsanız bile kaçırması kolay bir şey.

"Bearer"Sermaye ile emin olun .


18

Size öneririm:

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

Ve sonra böyle kullanabilirsiniz:

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

Simgeniz her 1 saatte bir zaman aşımına uğradıysa, HttpClient'i bu çözümle güncellemeniz gerekir. Simgenizin hala geçerli olup olmadığını kontrol etmenizi ve aksi halde yenileyip HttpRequestMessage'a eklemenizi öneririm
Johan Franzén

13

C # HttpClient ile temel kimlik doğrulamasını ayarlamak için. Aşağıdaki kod benim için çalışıyor.

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

Tam olarak ihtiyacım olan şey, teşekkürler.
rchrd

9

Bunu nasıl yaptım:

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

Bu tüp video bana çok yardımcı oluyor. Lütfen kontrol et. https://www.youtube.com/watch?v=qCwnU06NV5Q


9

Temel Yetkilendirme ve Json Parametrelerini Kullanın.

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
Bunun gibi bir örnekte SSL sertifikalarının kontrolünü devre dışı bırakmak için kod eklememelisiniz. İnsanlar, ne yaptığını anlamadan kodunuzu körü körüne kopyalayabilir. Bu çizgileri senin için çıkardım.
John

9

Eğer yeniden kullanmak istiyorsanız , her istek ile göndermek için kullanıldıkları gibi HttpClientkullanmamanız tavsiye edilir DefaultRequestHeaders.

Bunu deneyebilirsiniz:

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 yıl sonra birisinin yardım etmesi durumunda bunu ekliyoruz.

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

Benim için çalıştı. Willie Cheng'in benim için işe yaramadığı cevabının aksine.
user890332

5

UTF8 Seçeneği

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

3

Montaj AuthenticationHeaderValuesınıfını kullanmaSystem.Net.Http

public AuthenticationHeaderValue(
    string scheme,
    string parameter
)

aşağıdaki gibi mevcut Authorizationbaşlığı ayarlayabilir veya güncelleyebiliriz httpclient:

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

1
SO'ya hoş geldiniz, ancak lütfen biraz daha bağlam ekleyin.
JP Hellemons

Cevap açıktır ancak kodunun ne yapması gerektiğini açıklayan tek bir astarın olması zarar vermez. Sadece söylüyorum.
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

HttpClientTaşıyıcı Jetonu ile istek göndermek istiyorsanız , bu kod iyi bir çözüm olabilir:

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

Net .core içinde şunları kullanabilirsiniz:

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

veya

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

1
İlk örnek SetBasicAuthentication()varsayılan olarak kullanılamadığı için çalışmaz, bu nedenle bir uzantı yöntemi olmalıdır. Nerede tanımlanır?
ViRuSTriNiTy

0

Mevcut bir kütüphaneyi kullanmak daha kolay olabilir.

Örneğin, aşağıdaki uzantı yöntemleri Identity Server 4 ile eklenmiştir 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

Oauth Süreç akışı karmaşıktır ve her zaman bir veya daha fazla hata için bir alan vardır. Benim önerim her zaman kazan plakası kodunu ve OAuth kimlik doğrulama akışı için bir dizi kütüphaneyi kullanmak olacaktır.

İşte kütüphane kümesinin bağlantısı. .Net için OAuth Kütüphaneleri


-1

Eğer hizmetten bir json veya bir xml alıyorsanız bu işe yarayabilir ve eğer MakeXmlRequest (xmldocumnet içinde sonuç koyun) ve MakeJsonRequest işlevini kullanırsanız, bu size üstbilgilerin ve T türünün nasıl çalıştığı hakkında bir fikir verebileceğini düşünüyorum (json'u, json yanıtıyla aynı yapıya sahip olmasını istediğiniz sınıfa koyun) bir sonraki şekilde

/*-------------------------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);
        }
    }

Stackoverflow'a hoş geldiniz. Verdiğiniz yanıta ek olarak, lütfen bunun neden ve nasıl sorunu çözdüğüne dair kısa bir açıklama sağlayın.
jtate

-2

Bu, başlığın ayarlanmasına yardımcı olabilir:

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
Kullanıyor HttpClient, değil WebClient.
Jean Hominal
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.