Mengatur Otorisasi Header dari HttpClient

483

Saya memiliki HttpClient yang saya gunakan untuk REST API. Namun saya mengalami kesulitan mengatur header Otorisasi. Saya perlu mengatur header ke token yang saya terima dari melakukan permintaan OAuth saya. Saya melihat beberapa kode untuk .NET yang menyarankan yang berikut,

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

Namun kelas Kredensial apakah itu tidak ada di WinRT. Adakah yang tahu cara mengatur tajuk Otorisasi?

Stephen Hynes
sumber
1
Namespace apa yang dimiliki oleh kelas Kredensial?
kampsj
@ kampsj Saya tidak tahu karena itu .NET namespace yang tidak ada di WinRT
Stephen Hynes
1
Mengapa tidak meminta. Pemimpin. Menambahkan ("Otorisasi", token);
ahll

Jawaban:

817

Jadi cara untuk melakukannya adalah sebagai berikut,

httpClient.DefaultRequestHeaders.Authorization =
    new AuthenticationHeaderValue("Bearer", "Your Oauth token");
Stephen Hynes
sumber
16
Bagaimana Anda mendapatkan "Token Oauth Anda"?
Tupai Rahasia
3
Apa yang saya gunakan adalah: client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", "encrypted user/pwd");Mengambil pengguna terenkripsi / pwd dari ekstensi chrome Advanced Rest Client.
Merah
6
@Red fyi, parameter kedua adalah pengguna yang disandikan base64: kata sandi (tidak terenkripsi).
n00b
5
Aplikasi saya dengan senang hati menggunakan ini selama berabad-abad, lalu tiba-tiba saya mulai mendapatkan RuntimeBinderException. Saya harus beralih ke httpClient.DefaultRequestHeaders.Add ("Otorisasi", "Pembawa", "Token Oauth Anda"); untuk membuatnya lagi.
kraeg
8
@ kraeg, kode yang Anda cantumkan tidak dikompilasi, maksud Anda menyatukan 2 string terakhir seperti: client.DefaultRequestHeaders.Add ("Otorisasi", "Pembawa" + "Token Oauth Anda");
TroySteven
354
request.DefaultRequestHeaders.Authorization = 
    new AuthenticationHeaderValue(
        "Basic", Convert.ToBase64String(
            System.Text.ASCIIEncoding.ASCII.GetBytes(
               $"{yourusername}:{yourpwd}")));
TheWhiteRabbit
sumber
27
@MickyDuncan HttpClient memiliki DefaultRequestHeaders.Authorization. Dan jawaban ini hanya menyelamatkan hari saya. Terima kasih banyak kepada WhiteRabbit.
Joey Schluchter
3
Ini tidak berfungsi, jika Anda memeriksa header Auhtorization tidak mengandung apa pun selain string Basic.
Raffaeu
1
Adakah yang bisa menjelaskan mengapa penting untuk mengubah nama pengguna dan kata sandi menjadi string base64? Itu tidak menawarkan enkripsi nyata, jadi mengapa itu penting?
Jonathan Wood
3
@JonathanWood Karena itulah bagaimana didefinisikan untuk digunakan. Basic tidak menawarkan enkripsi, cukup penyandian untuk menghindari masalah dengan pilihan karakter kata sandi di header.
Richard
4
Apakah ada alasan khusus Anda menggunakan pengkodean ASCII di sini? Saya berasumsi tidak ada masalah dengan menggunakan pengkodean UTF8 karena kita Base64 yang mengkodekannya. Saya kira saya bertanya-tanya apakah spesifikasi otentikasi Dasar mengatakan bahwa nama pengguna: kata sandi kombo harus dalam ASCII saja?
naksir
82

Saya mencari cara yang baik untuk menangani masalah ini dan saya melihat pertanyaan yang sama. Semoga jawaban ini akan membantu semua orang yang memiliki masalah yang sama menyukai saya.

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

referensi dari https://www.theidentityhub.com/hub/Documentation/CallTheIdentityHubApi

Willie Cheng
sumber
1
Saya melakukan hal yang sama persis @willie dan saya masih mendapatkan 401 dari API saya
SomethingOn
2
Hai @ sesuatu. Saya pikir Anda tidak mendapatkan kunci token yang benar, sehingga Anda mendapat 401, saya akan membagikan cara saya pada "Ajukan Pertanyaan" pribadi saya, semoga ini dapat membantu Anda untuk mengatasi masalah Anda. Tunggu sebentar
Willie Cheng
14
Anda seharusnya tidak meletakkan HttpClient di usingblok. (Ya, saya tahu ini kedengarannya terbalik, tetapi Anda akan membocorkan koneksi jika Anda menggunakan usingalih-alih hanya mendaur ulang HttpClient.)
Jonathan Allen
42

Karena ini adalah praktik yang baik untuk menggunakan kembali contoh HttpClient , untuk masalah kinerja dan kelelahan pelabuhan , dan karena tidak ada jawaban yang memberikan solusi ini (dan bahkan mengarahkan Anda ke praktik buruk :(), saya taruh di sini tautan menuju jawaban yang saya buat pada pertanyaan serupa:

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

Beberapa sumber tentang cara menggunakan HttpClient dengan cara yang benar:

Philippe
sumber
5
Masalah kelelahan pelabuhan bukan lelucon. Ini hampir tidak pernah terjadi di QA, tetapi akan mengenai proyek yang banyak digunakan dalam produksi.
Jonathan Allen
Lihat posting saya untuk contoh nyata stackoverflow.com/a/59052193/790635
emp
41

Saya setuju dengan jawaban TheWhiteRabbit tetapi jika Anda memiliki banyak panggilan menggunakan HttpClient kodenya sepertinya sedikit berulang menurut pendapat saya.

Saya pikir ada 2 cara untuk meningkatkan jawabannya sedikit.

Buat kelas pembantu untuk membuat klien:

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

Pemakaian:

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

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

Buat metode ekstensi:

Tidak memenangkan hadiah kecantikan tapi berhasil :)

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

Pemakaian:

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

Sekali lagi saya pikir 2 opsi di atas membuat klien menggunakan pernyataan yang sedikit kurang berulang. Perlu diingat bahwa ini adalah praktik terbaik untuk menggunakan kembali HttpClient jika Anda membuat beberapa panggilan http tapi saya pikir itu sedikit di luar ruang lingkup untuk pertanyaan ini.

Florian Schaal
sumber
20
saya dapat melihat jawaban Anda sudah terbalik tetapi saya tidak akan merekomendasikan pendekatan ini TL; DR jelas salah karena kelelahan soket, di sini adalah link
lacripta
2
@ lacripta, Ini benar tetapi jika Anda membaca 2 kalimat terakhir saya katakan praktik terbaik untuk menggunakan kembali HttpClient untuk alasan ini, tetapi saya pikir itu di luar ruang lingkup untuk pertanyaan ini.
Florian Schaal
1
saya dapat melihat poin Anda tetapi Anda membuat saran yang mengatakan bahwa kode berulang, ini dapat menyebabkan penyalahgunaan metode pabrik ini, akan lebih baik untuk menunjukkan pada baris pertama bahwa itu akan menyebabkan masalah penggunaan sumber daya di masa depan khusus untuk kasus ini. dan bukan hanya peringatan yang kebanyakan tidak akan dibaca.
lacripta
1
Menggunakan HttpClientFactory akan jauh lebih baik untuk menghindari masalah kelelahan soket.
RyanOC
21

Saya sedang mengatur token pembawa

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

Itu bekerja di satu titik akhir, tetapi tidak di titik lain. Masalahnya adalah bahwa saya memiliki huruf kecil bdi "bearer". Setelah perubahan sekarang berfungsi untuk kedua api yang saya pukul. Suatu hal yang mudah terlewatkan jika Anda bahkan tidak menganggapnya sebagai salah satu tumpukan jerami untuk mencari jarum.

Pastikan untuk memiliki "Bearer"- dengan modal.

Alan Ball
sumber
18

Saya sarankan kepada Anda:

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

Dan kemudian Anda bisa menggunakannya seperti itu:

var response = await client.GetAsync(url);
if (response.IsSuccessStatusCode)
{
    responseMessage = await response.Content.ReadAsAsync<ResponseMessage>();
}
Amankhani MohammadJavad
sumber
Jika token Anda habis setiap 1 jam misalnya maka Anda harus memperbarui HttpClient dengan solusi ini. Saya sarankan memeriksa bahwa token Anda masih valid dan menyegarkannya dan menambahkannya ke HttpRequestMessage
Johan Franzén
13

Untuk mengatur otentikasi dasar dengan C # HttpClient. Kode berikut ini berfungsi untuk saya.

   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
sumber
Apa yang saya butuhkan, terima kasih.
rchrd
9

Beginilah cara saya melakukannya:

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

Video You-Tube ini banyak membantu saya. Silakan periksa. https://www.youtube.com/watch?v=qCwnU06NV5Q

Dayan
sumber
9

Gunakan Dasar Otorisasi Dan Parameter 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();
                    }
Mohammad Sooori
sumber
2
Anda tidak harus memasukkan kode untuk menonaktifkan pemeriksaan sertifikat SSL dalam contoh seperti ini. Orang-orang dapat secara buta menyalin kode Anda tanpa menyadari apa yang dilakukannya. Saya telah menghapus garis-garis itu untuk Anda.
John
9

Jika Anda ingin menggunakan kembali HttpClient, disarankan untuk tidak menggunakanDefaultRequestHeaders karena mereka digunakan untuk mengirim dengan setiap permintaan.

Anda bisa mencoba ini:

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
sumber
8

6 Tahun kemudian tetapi menambahkan ini jika itu membantu seseorang.

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
sumber
Bekerja untukku. Berbeda dengan jawaban Willie Cheng yang tidak berhasil untukku.
user890332
5

Opsi UTF8

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

Menggunakan AuthenticationHeaderValuekelas System.Net.Httpperakitan

public AuthenticationHeaderValue(
    string scheme,
    string parameter
)

kita dapat mengatur atau memperbarui Authorizationheader yang ada untuk httpclientseperti kita :

httpclient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", TokenResponse.AccessToken);
Fusi
sumber
1
Selamat datang di SO, tapi tolong tambahkan beberapa konteks lagi.
JP Hellemons
Jawabannya tepat tetapi tidak ada salahnya untuk memiliki satu liner menjelaskan apa yang seharusnya dilakukan kode-nya. Hanya mengatakan.
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
sumber
1

Jika Anda ingin mengirim HttpClientpermintaan dengan Bearer Token, kode ini bisa menjadi solusi yang baik:

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
sumber
0

Di net .core Anda bisa menggunakan

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

atau

var client = new HttpClient();
client.SetBearerToken(token);
Thom Kiesewetter
sumber
1
Contoh pertama tidak berfungsi karena SetBasicAuthentication()tidak tersedia secara default sehingga harus menjadi metode ekstensi. Di mana itu didefinisikan?
ViRuSTriNiTy
0

Mungkin lebih mudah menggunakan perpustakaan yang ada.

Misalnya, metode ekstensi di bawah ini ditambahkan dengan 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);
Lee Smith
sumber
0

Oauth Alur proses sangat kompleks dan selalu ada ruang untuk satu kesalahan atau lainnya. Saran saya adalah untuk selalu menggunakan kode boilerplate dan satu set perpustakaan untuk aliran otentikasi OAuth. Ini akan membuat hidup Anda lebih mudah.

Berikut ini tautan untuk sekumpulan perpustakaan. Perpustakaan OAuth untuk .Net

Khurram Jamil
sumber
-1

ini bisa bekerja, jika Anda menerima json atau xml dari layanan dan saya pikir ini dapat memberi Anda gambaran tentang bagaimana header dan tipe T bekerja juga, jika Anda menggunakan fungsi MakeXmlRequest (masukkan hasil dalam xmldocumnet) dan MakeJsonRequest (letakkan json di kelas yang Anda inginkan yang memiliki struktur yang sama dengan respons json) dengan cara berikutnya

/*-------------------------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
sumber
-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
sumber
Selamat datang di stackoverflow. Selain jawaban yang Anda berikan, silakan pertimbangkan untuk memberikan penjelasan singkat tentang mengapa dan bagaimana ini memperbaiki masalah.
jtate
-2

Ini dapat membantu Mengatur tajuk:

WebClient client = new WebClient();

string authInfo = this.credentials.UserName + ":" + this.credentials.Password;
authInfo = Convert.ToBase64String(Encoding.Default.GetBytes(authInfo));
client.Headers["Authorization"] = "Basic " + authInfo;
Bantuan kode
sumber
9
Dia menggunakan HttpClient, bukan WebClient.
Jean Hominal