设置HttpClient的授权标头

所以要做到这一点的方法如下，

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

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

这可能有助于设置标题：

WebClient client = new WebClient();


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

如果您从服务接收到json或xml，这可能会起作用，我认为这可以让您了解标头和T类型的工作原理，如果您使用函数MakeXmlRequest（将结果放入xmldocuments net中）和MakeJsonRequest（将json放入您希望具有与json响应相同结构的类中）

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

我在寻找一个好的方法来处理这个问题，我正在寻找同样的问题。希望这个答案能帮助所有有同样问题的人喜欢我。

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

使用System.Net.Http汇编的AuthenticationHeaderValue类

public AuthenticationHeaderValue(
string scheme,
string parameter
)

我们可以为我们的httpclient设置或更新现有的Authorization标头，如下所示：

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

因为它是重用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/

我是这样做的：

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

这个you-tube视频帮了我很多忙。请检查出来。 https://www.youtube.com/watch?v=qCwnU06NV5Q

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

使用基本授权和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();
}

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

我在设置无记名令牌

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

它在一个端点上工作，但在另一个端点上不工作。问题是我在"bearer"上有小写b。经过更改，现在它适用于我正在访问的两个api。如果你甚至不认为它是寻找针的干草堆之一，那么很容易错过。

确保拥有"Bearer"-资本。

UTF8选项

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

在net. core中，您可以与身份服务器4一起使用

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

或

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

查看https://github.com/IdentityModel/IdentityModel/blob/main/src/Client/Extensions/AuthorizationHeaderExtensions.cs

我建议你：

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

然后你可以这样使用它：

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

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

如果您想重用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);

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

使用现有的库可能更容易。

例如，下面的扩展方法是添加到身份服务器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);

如果您想使用承载令牌发送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);

Oauth进程流很复杂，总是有一个错误或另一个错误的空间。 我的建议是始终使用样板代码和一组库来进行OAuth身份验证流程。这将使您的生活更轻松。

这是一组库的链接。. net的OAuth库

对于现在（2021年）找到这个旧线程的人，请查看这个留档关于HttpClientFactory，它是可注入的，并且还将在每个请求上重新运行，避免过期令牌，这将使其对承载令牌有用，生成的客户端，池等。

太长别读：使用HttpClientFactory和DelegatingHandler，它们将作为配置客户端的所有传出请求的中间件。

这就是我为Azure身份（由Azure管理）添加承载者的方式，但您当然可以随心所欲地获取令牌；

using Microsoft.Azure.Services.AppAuthentication;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;


public class BearerTokenHandler : DelegatingHandler
{
public BearerTokenHandler(AzureServiceTokenProvider tokenProvider, string resource)
{
TokenProvider = tokenProvider;
Resource = resource;
}


public AzureServiceTokenProvider TokenProvider { get; }
public string Resource { get; }


protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
if (!request.Headers.Contains("Authorization"))
{
// Fetch your token here
string token = await TokenProvider.GetAccessTokenAsync(Resource);
request.Headers.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", token);
}


return await base.SendAsync(request, cancellationToken);
}
}

我在Startup中这样配置我的类型化客户端（使用NSwag生成）；

   var accessTokenProvider = new AzureServiceTokenProvider("<your-connection-string-for-access-token-provider>");


builder.Services.AddHttpClient<IOrdersClient, OrdersClient>().ConfigureHttpClient(async conf =>
{
conf.BaseAddress = new Uri("<your-api-base-url>");
}).AddHttpMessageHandler(() => new BearerTokenHandler(accessTokenProvider, "https://your-azure-tenant.onmicrosoft.com/api"));

然后，您可以在任何您喜欢的地方注入您的IOrdersClient，所有请求都将拥有承载者。

首先，我不会直接使用HttpClient。这太容易出错了——尤其是在标题部分。DefaultHeadersCollection不是不可变的，也不是线程安全的，因为应用的其他部分可以更改你的标题。最好在调用时设置标题。如果你正在使用抽象，并且建议这样做，因为这方面的类有点混乱，在发送之前，你可能希望有一个标题集合并将它们放在你的HttpRequestMessage上。你需要确保将内容标题放在内容上，而不是消息上。

代码参考

foreach (var headerName in request.Headers.Names)
{
//"Content-Type"
if (string.Compare(headerName, HeadersExtensions.ContentTypeHeaderName, StringComparison.OrdinalIgnoreCase) == 0)
{
//Note: not sure why this is necessary...
//The HttpClient class seems to differentiate between content headers and request message headers, but this distinction doesn't exist in the real world...
//TODO: Other Content headers
httpContent?.Headers.Add(HeadersExtensions.ContentTypeHeaderName, request.Headers[headerName]);
}
else
{
httpRequestMessage.Headers.Add(headerName, request.Headers[headerName]);
}
}

这是一个数据结构，您可以使用它来发送包含标头的请求。

代码参考

public interface IRequest
{
CancellationToken CancellationToken { get; }
string? CustomHttpRequestMethod { get; }
IHeadersCollection Headers { get; }
HttpRequestMethod HttpRequestMethod { get; }
AbsoluteUrl Uri { get; }
}


public interface IRequest<TBody> : IRequest
{
TBody? BodyData { get; }
}

而且，一个标题集合：

代码参考

public sealed class HeadersCollection : IHeadersCollection
{
#region Fields
private readonly IDictionary<string, IEnumerable<string>> dictionary;
#endregion


#region Public Constructors


public HeadersCollection(IDictionary<string, IEnumerable<string>> dictionary) => this.dictionary = dictionary;


public HeadersCollection(string key, string value) : this(ImmutableDictionary.CreateRange(
new List<KeyValuePair<string, IEnumerable<string>>>
{
new(key, ImmutableList.Create(value))
}
))
{
}


#endregion Public Constructors


#region Public Properties
public static HeadersCollection Empty { get; } = new HeadersCollection(ImmutableDictionary.Create<string, IEnumerable<string>>());
public IEnumerable<string> Names => dictionary.Keys;
IEnumerable<string> IHeadersCollection.this[string name] => dictionary[name];
#endregion Public Properties


#region Public Methods
public bool Contains(string name) => dictionary.ContainsKey(name);


public IEnumerator<KeyValuePair<string, IEnumerable<string>>> GetEnumerator() => dictionary.GetEnumerator();


IEnumerator IEnumerable.GetEnumerator() => dictionary.GetEnumerator();
public override string ToString() => string.Join("\r\n", dictionary.Select(kvp => $"{kvp.Key}: {string.Join(", ", kvp.Value)}\r\n"));
#endregion
}

查看所有工作代码和示例这里。

如果您使用Visual Studio IISExpress调试模式并连接到HTTP端口而不是HTTPS端口，您可能会发现正在删除身份验证标头。

切换到SLL连接，它们将再次出现。

不确定原因，可能是设置重定向了超文本传输协议流量，导致身份验证被删除。

您也可以使用以下示例，它使用IHttpClientFactory：

    readonly IHttpClientFactory _httpClientFactory;
    

public HTTPClientHelper(IHttpClientFactory httpClientFactory, string clientName = null)
{
this._httpClientFactory = httpClientFactory;
}


public Task<T> GetAsync(string url, string token) {


var client = _httpClientFactory.CreateClient(_clientName);


client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(JwtBearerDefaults.AuthenticationScheme, token);


using (HttpResponseMessage response = await _client.GetAsync(url)){
......
}
}

我遇到了这个旧线程。我遇到的问题是我知道使用静态HttpClient，但我的令牌需要每59分钟刷新一次。

所以我可以使用HttpClientFactory，但是因为我的一个项目还在. NET 4.8中，我创建了一个继承自HttpClient的类，所以我在所有项目中都有类似的代码。需要一个秘密才能获得令牌（我使用的是标识服务器4）。

然后我将其设置为DI中的单例（我在这里使用的是N的）：

Bind<MyHttpClient>().ToMethod(c =>
{
var accessKey = ConfigurationManager.AppSettings["AccessKey"];


var client = new MyHttpClient(accessKey)
{
BaseAddress = new Uri(MyUrls.MyApiBaseUrl)
};


client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));


return client;
}).InSingletonScope();

然后类本身-以它用于访问的API命名：

public class MyHttpClient : BaseHttpClient
{
private static readonly HttpClient _authHttpClient = new HttpClient();
private string _secret;


public MyHttpClient(string secret)
{
_secret = secret;
}


/// <summary>
/// Add the token to each and every request, cached for 1 minute less than the token's lifetime
/// </summary>
/// <param name="request"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
/// <exception cref="Exception"></exception>
public override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();


var cacheSeconds = 3600 - 60; // Default of 59 minutes


var token = CacheHelper<string>.Get("MyToken", cacheSeconds * 60, () =>
{
var authorityUrl = MyUrls.AuthServerUrl;


// discover endpoints from metadata
DiscoveryDocumentResponse disco;
disco = _authHttpClient.GetDiscoveryDocumentAsync(authorityUrl).Result;
if (disco.IsError)
{
throw new Exception("Error getting discovery document: " + disco.Error);
}


// request token
var tokenResponse = _authHttpClient.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
{
Address = disco.TokenEndpoint,


ClientId = "myapp",
ClientSecret = _secret,
Scope = "myapi"
}).Result;


if (tokenResponse.IsError)
{
throw new Exception("Error getting token: " + tokenResponse.Error);
}


if (tokenResponse.ExpiresIn < cacheSeconds + 60)
{
throw new Exception($"Token expires in {tokenResponse.ExpiresIn}s, which is less than {cacheSeconds + 60}");
}


if (tokenResponse.ExpiresIn > cacheSeconds + 60)
{
Log.Warn().Message($"Token expiry in {tokenResponse.ExpiresIn}s, which is greater than {cacheSeconds}").Write();
}


return tokenResponse.AccessToken;
});


// THIS IS THE BIT - Assign this inside a SendAsync override and you are done!
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", token);
return base.SendAsync(request, cancellationToken);
}


}

最后，为了完整性，我的CacheHelper类看起来像这样：

public static class CacheHelper<T>
{
private static readonly object _locker = new object();


public static T Get(string cacheName, int cacheTimeoutSeconds, Func<T> func)
{
var obj = MemoryCache.Default.Get(cacheName, null);
if (obj != null) return (T)obj;


lock (_locker)
{
obj = MemoryCache.Default.Get(cacheName, null);
if (obj == null)
{
obj = func();
var cip = new CacheItemPolicy
{
AbsoluteExpiration = new DateTimeOffset(DateTime.UtcNow.AddSeconds(cacheTimeoutSeconds))
};
MemoryCache.Default.Set(cacheName, obj, cip);
}
}


return (T)obj;
}
}