HttpClient का प्राधिकरण हैडर सेट करना

Question

मेरे पास एक HttpClient है जो मैं एक REST API के लिए उपयोग कर रहा हूं। हालाँकि मुझे प्राधिकरण हेडर सेट करने में समस्या हो रही है। मुझे अपने OAuth अनुरोध को करने से प्राप्त टोकन को हेडर पर सेट करना होगा। मैंने .NET के लिए कुछ कोड देखे जो निम्नलिखित सुझाव देते हैं,

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

हालाँकि क्रेडेंशियल वर्ग WinRT में मौजूद नहीं है। किसी के पास कोई भी विचार है कि प्राधिकरण हेडर कैसे सेट करें?

Comments

क्रेडेंशियल वर्ग किस नाम स्थान का है?

— kampj

@kampsj मैं नहीं जानता क्योंकि यह एक .NET नेमस्पेस है जो WinRT में मौजूद नहीं है

— स्टीफन हाइन्स

अनुरोध क्यों नहीं किया जाता है। Headers.Add ("प्राधिकरण", टोकन);

— आहले

Answer 1

तो यह करने का तरीका निम्नलिखित है,

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

Comments

आपको "आपका ओएथ टोकन" कैसे मिलेगा?

— सीक्रेट गिलहरी

मैंने जो उपयोग किया है वह है: client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", "encrypted user/pwd");उन्नत रेस्ट क्लाइंट क्रोम एक्सटेंशन से एन्क्रिप्टेड उपयोगकर्ता / पीडीडब्ल्यू लेना।

— Red

@Red fyi, दूसरा पैरामीटर बेस 64 एनकोडेड यूजर है: पासवर्ड (इसका एनक्रिप्टेड नहीं)।

— n00b

मेरा आवेदन खुशी से उम्र के लिए इसका उपयोग कर रहा था, फिर नीले रंग में से मुझे एक RuntimeBinderException मिलनी शुरू हुई। मुझे httpClient.DefaultRequestHeaders.Add ("प्राधिकरण", "बियरर", "आपका ओउथ टोकन") पर स्विच करना पड़ा ; फिर से पाने के लिए।

— क्रैग

@kraeg, आपके द्वारा सूचीबद्ध कोड संकलित नहीं करता है, क्या आपका मतलब पिछले 2 तार को समाप्‍त करना है जैसे: client.DefaultRequestHeaders.Add ("प्राधिकरण", "बियरर" + "आपका ओथूथ टोकन");

— ट्रॉयसेवेन

Answer 2

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

Comments

@MickyDuncan HttpClient में DefaultRequestHeaders.Authorization है। और इस जवाब ने मेरे दिन को उबार दिया। व्हाइटब्रैबिट को बहुत धन्यवाद।

— जोए श्लुचटर

यह काम नहीं कर रहा है, यदि आप निरीक्षण करते हैं कि Auhtorization हेडर में स्ट्रिंग बेसिक से अधिक कुछ नहीं है।

— रफ्फू

क्या कोई समझा सकता है कि उपयोगकर्ता नाम और पासवर्ड को आधार 64 स्ट्रिंग में बदलना क्यों महत्वपूर्ण है? यह कोई वास्तविक एन्क्रिप्शन प्रदान नहीं करता है, इसलिए यह क्यों मायने रखता है?

— जोनाथन वुड

@JonathanWood क्योंकि, इसका उपयोग करने के लिए कैसे परिभाषित किया गया है। बेसिक कोई एन्क्रिप्शन नहीं देता है, हेडर में पासवर्ड वर्णों की पसंद के मुद्दों से बचने के लिए बस पर्याप्त एन्कोडिंग है।

— रिचर्ड

क्या कोई विशेष कारण है जो आपने यहाँ ASCII एन्कोडिंग का उपयोग किया है? मुझे लगता है कि हम UT648 एन्कोडिंग का उपयोग करने के साथ कोई समस्या नहीं है क्योंकि हम Base64 इसे वैसे भी एन्कोडिंग कर रहे हैं। मुझे लगता है कि मैं सोच रहा था कि क्या बुनियादी प्रमाणीकरण विनिर्देश कहता है कि उपयोगकर्ता नाम: पासवर्ड कॉम्बो केवल ASCII में होना चाहिए?

— क्रश

Answer 3

मैं इस मुद्दे से निपटने के लिए एक अच्छा तरीका खोज रहा हूं और मैं एक ही सवाल देख रहा हूं। उम्मीद है, यह जवाब हर किसी की मदद कर रहा होगा जिनके पास वही समस्या है जो मुझे पसंद करती है।

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 से संदर्भ

Comments

मैं सटीक एक ही बात @willie कर रहा हूँ और मैं अभी भी अपने एपीआई से एक 401 हो रही है

— SomethingOn

हाय @SomethingOn मुझे लगता है कि आपको एक सही टोकन कुंजी नहीं मिली है, ताकि आपको 401 मिले, मैं अपने व्यक्तिगत "प्रश्न पूछें" पर अपना रास्ता साझा करूंगा, उम्मीद है कि यह आपकी समस्या से निपटने में आपकी मदद कर सकता है। एक पल का इंतजार कर

— विली चेंग

आपको किसी usingब्लॉक में HttpClient नहीं लगाना चाहिए । (हां, मुझे पता है कि यह पीछे की ओर लगता है, लेकिन यदि आप usingसिर्फ HttpClient को पुनर्चक्रित करने के बजाय उपयोग करते हैं, तो आप कनेक्शन को लीक कर देंगे ।)

— जोनाथन एलन

Answer 4

चूंकि यह प्रदर्शन और पोर्ट थकावट की समस्याओं के लिए , HttpClient उदाहरण का पुन: उपयोग करने के लिए एक अच्छा अभ्यास है , और क्योंकि कोई भी उत्तर इस समाधान को नहीं देता है (और आपको बुरी प्रथाओं की ओर भी ले जाता है :(), मैंने यहां उस उत्तर की ओर एक लिंक डाल दिया है जिसे मैंने बनाया है। इसी तरह के सवाल पर:

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

HttpClient का सही तरीके से उपयोग करने के कुछ तरीके:

• https://aspnetmonsters.com/2016/08/2016-08-27-httpclientwrong/
• https://blogs.msdn.microsoft.com/alazarev/2017/12/29/disposable-finalizers-and-httpclient/

Comments

पोर्ट थकावट की समस्या कोई मज़ाक नहीं है। यह लगभग कभी क्यूए में नहीं होता है, लेकिन उत्पादन में किसी भी भारी परियोजना का इस्तेमाल करेगा।

— जोनाथन एलन

एक ठोस उदाहरण के लिए मेरी पोस्ट देखें stackoverflow.com/a/59052193/790635

— है EMP

Answer 5

मैं TheWhiteRabbit के उत्तर से सहमत हूं, लेकिन यदि आपके पास HttpClient का उपयोग करने वाले बहुत सारे कॉल हैं, तो कोड मेरी राय में थोड़ा दोहरावदार लगता है।

मुझे लगता है कि उत्तर को थोड़ा सुधारने के 2 तरीके हैं।

ग्राहक बनाने के लिए एक सहायक वर्ग बनाएँ:

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

उपयोग:

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

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

एक विस्तार विधि बनाएँ:

एक सौंदर्य पुरस्कार नहीं जीतता है लेकिन महान काम करता है :)

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

उपयोग:

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

फिर से मुझे लगता है कि ऊपर दिए गए 2 विकल्प ग्राहक को कथन का उपयोग कम दोहरावदार बनाते हैं। ध्यान रखें कि यदि आप कई http कॉल कर रहे हैं तो HttpClient का पुन: उपयोग करना सबसे अच्छा अभ्यास है, लेकिन मुझे लगता है कि इस प्रश्न के लिए यह थोड़ा गुंजाइश है।

Comments

मैं देख सकता हूं कि आपका उत्तर अप-डाउन किया गया है, लेकिन मैं इस दृष्टिकोण टीएल की सिफारिश नहीं करूंगा; डॉ सादा गलत क्योंकि सॉकेट थकावट, यहाँ स्पष्टीकरण लिंक है

— लैक्रिप्टा

@lacripta, यह सच है लेकिन अगर आपने पिछले 2 वाक्य को पढ़ा है तो मैं कहता हूं कि HttpClient का पुन: उपयोग करने के लिए इसका सबसे अच्छा अभ्यास है, लेकिन मुझे लगता है कि यह इस सवाल के दायरे से बाहर है।

— फ्लोरियन शाल

मैं आपकी बात देख सकता हूं, लेकिन आपका एक सुझाव यह कह रहा है कि कोड दोहरावदार है, इससे इस फैक्ट्री पद्धति का दुरुपयोग हो सकता है, फर्स्ट लाइन्स में यह बताना अच्छा होगा कि इससे भविष्य में विशेष रूप से संसाधन उपयोग की समस्या पैदा होगी ये मामला। और न सिर्फ एक चेतावनी जो सबसे ज्यादा पढ़ी जाती है।

— लैक्रिप्टा

सॉकेट थकावट की समस्या से बचने के लिए HttpClientFactory का उपयोग करना बेहतर होगा।

— रयानकोट 13

Answer 6

मैं वाहक टोकन सेट कर रहा था

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

यह एक एंडपॉइंट में काम कर रहा था, लेकिन दूसरे में नहीं। मुद्दा यह है कि मैं लोअर केस था bपर"bearer" । बदलाव के बाद अब यह एपी के आई एम हिटिंग के लिए काम करता है। मिस करने के लिए इतनी आसान बात अगर आप इसे सुई के रूप में देखने के लिए हिस्टैक्स में से एक के रूप में भी नहीं मान रहे हैं।

"Bearer"पूंजी के साथ - सुनिश्चित करें ।

Answer 7

मैं आपको सुझाव देता हूं:

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

और फिर आप इसे इस तरह से उपयोग कर सकते हैं:

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

Comments

यदि आपका टोकन उदाहरण के लिए हर 1h समय है तो आपको इस समाधान के साथ HttpClient को अपडेट करना होगा। मैं यह जाँचने का सुझाव दूंगा कि आपका टोकन अभी भी वैध है और अन्यथा इसे रीफ्रेश करके HttpRequestMessage में जोड़ा जा रहा है

— जोहान फ्रेंजेन

Answer 8

C # HttpClient के साथ मूल प्रमाणीकरण सेट करने के लिए। निम्नलिखित कोड मेरे लिए काम कर रहा है।

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

Comments

वास्तव में मुझे क्या चाहिए, धन्यवाद।

— rchrd

Answer 9

मैंने इसे कैसे किया है:

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", "[e-mail]"},
           {"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());
      }
   }
}

यह यू-ट्यूब वीडियो मेरी बहुत मदद करता है। कृपया यह देखें। https://www.youtube.com/watch?v=qCwnU06NV5Q

Answer 10

मूल प्राधिकरण और 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();
                    }

Comments

इस तरह से एक उदाहरण में एसएसएल प्रमाणपत्रों की जांच को अक्षम करने के लिए आपको कोड शामिल नहीं करना चाहिए। लोग आँख बंद करके आपके कोड को महसूस कर सकते हैं कि यह क्या करता है। मैंने आपके लिए उन पंक्तियों को हटा दिया है।

— जॉन

Answer 11

यदि आप पुन: उपयोग करना चाहते हैं HttpClient, तो इसका उपयोग नहीं करने की सलाह दी जाती हैDefaultRequestHeaders प्रत्येक अनुरोध के साथ भेजने के लिए उनका किया जाए।

आप यह कोशिश कर सकते हैं:

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

Answer 12

6 साल बाद लेकिन इस मामले में इसे जोड़ने से किसी को मदद मिलती है।

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

Comments

मेरे लिए काम किया। विली चेंग के जवाब के विपरीत जो मेरे लिए काम नहीं करता था।

— user890332

Answer 13

UTF8 विकल्प

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

Answer 14

का उपयोग करते हुए AuthenticationHeaderValueकी कक्षा System.Net.Httpविधानसभा

public AuthenticationHeaderValue(
    string scheme,
    string parameter
)

हम Authorizationअपनी httpclientपसंद के लिए मौजूदा हेडर सेट या अपडेट कर सकते हैं :

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

Comments

SO पर आपका स्वागत है, लेकिन कृपया कुछ और संदर्भ जोड़ें।

— जेपी हेलिमोंस

जवाब हाजिर है, लेकिन एक लाइनर को यह बताने में दुख नहीं होगा कि उसका कोड क्या करना चाहिए। बस केह रहा हू।

— इमीनोव

Answer 15

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

Answer 16

यदि आप HttpClientबियरर टोकन के साथ अनुरोध भेजना चाहते हैं , तो यह कोड एक अच्छा समाधान हो सकता है:

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

Answer 17

Net .core में आप उपयोग कर सकते हैं

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

या

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

Comments

पहला उदाहरण काम नहीं करता है क्योंकि SetBasicAuthentication()यह डिफ़ॉल्ट रूप से उपलब्ध नहीं है, इसलिए इसे एक विस्तार विधि होना चाहिए। इसे कहां परिभाषित किया गया है?

— वीरुस्तृतीयि

Answer 18

मौजूदा लाइब्रेरी का उपयोग करना आसान हो सकता है।

उदाहरण के लिए, नीचे दिए गए विस्तार के तरीके आइडेंटिटी सर्वर 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);

Answer 19

Oauth प्रक्रिया प्रवाह जटिल है और हमेशा एक त्रुटि या दूसरे के लिए एक कमरा है। मेरा सुझाव हमेशा ऑइल प्रमाणीकरण प्रवाह के लिए बॉयलरप्लेट कोड और पुस्तकालयों के एक सेट का उपयोग करना होगा। यह आपके जीवन को आसान बना देगा।

यहाँ पुस्तकालयों के सेट के लिए लिंक है। OAuth पुस्तकालयों के लिए .Net

Answer 20

यह काम कर सकता है, यदि आपको सेवा से कोई json या xml प्राप्त हो रहा है और मुझे लगता है कि इससे आपको यह पता चल सकता है कि हेडर और T प्रकार कैसे काम करता है, यदि आप फ़ंक्शन MakeXmlRequest (xmococumnet में परिणाम डालें) और MakeJsonRequest का उपयोग करते हैं (आप जिस इच्छा को कक्षा में रखते हैं, उसे उसी तरह से तैयार करें, जिस तरह की संरचना में वह प्रतिक्रिया हो)

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

Answer 21

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

Comments

Stackoverflow में आपका स्वागत है। आपके द्वारा प्रदान किए गए उत्तर के अलावा, कृपया इस बात की संक्षिप्त व्याख्या प्रदान करें कि यह समस्या क्यों और कैसे ठीक होती है।

— 22

Answer 22

यह हेडर सेट करने में मदद कर सकता है:

WebClient client = new WebClient();

string authInfo = this.credentials.UserName + ":" + this.credentials.Password;
authInfo = Convert.ToBase64String(Encoding.Default.GetBytes(authInfo));
client.Headers["Authorization"] = "Basic " + authInfo;

Comments

वह उपयोग कर रहा है HttpClient, नहीं WebClient।

— जीन होमिनल