public async Task <IHttpConnectionResponse> SendAsync(HttpConnectionRequest request, bool allowBuffering, CancellationToken cancellationToken, WebResponse webResponse = null)
{
Uri url = request.Url;
IHttpConnectionResponse response = await this._webReaderManager.GetAsync(request, cancellationToken);
this.Update(url, response, webResponse);
return(response);
}
public async Task <IWebStreamResponse> GetWebStreamAsync(Uri url, bool waitForContent, CancellationToken cancellationToken, Uri referrer = null, long?from = null, long?to = null, WebResponse webResponse = null)
{
HttpConnectionRequest request = this._webReaderManager.CreateRequest(url, referrer, (IWebReader)this, this.ContentType, (string)null, waitForContent, from, to);
IHttpConnectionResponse response = await this._webReaderManager.GetAsync(request, cancellationToken).ConfigureAwait(false);
this.Update(url, response, webResponse);
return((IWebStreamResponse) new HttpConnectionWebStreamResponse(response));
}
private HttpConnectionRequest CreateRequest()
{
Uri uri = this.WebReader.BaseAddress;
bool flag = false;
if (null == this._cachedObject)
{
this._lastModified = (string)null;
this._etag = (string)null;
}
if (null != this._lastModified)
{
flag = true;
}
if (null != this._etag)
{
flag = true;
}
if (this._firstRequestCompleted && (!flag && null == this._cacheControl))
{
this._noCache = "nocache=" + Guid.NewGuid().ToString("N");
}
if (null != this._noCache)
{
UriBuilder uriBuilder = new UriBuilder(uri);
uriBuilder.Query = !string.IsNullOrEmpty(uriBuilder.Query) ? uriBuilder.Query.Substring(1) + "&" + this._noCache : this._noCache;
uri = uriBuilder.Uri;
}
HttpConnectionRequest webRequest = this._webReader.CreateWebRequest(uri, (Uri)null);
List <KeyValuePair <string, string> > list = new List <KeyValuePair <string, string> >();
if (null != this._lastModified)
{
list.Add(new KeyValuePair <string, string>("If-Modified-Since", this._lastModified));
}
if (null != this._etag)
{
list.Add(new KeyValuePair <string, string>("If-None-Match", this._etag));
}
if (!flag)
{
list.Add(new KeyValuePair <string, string>("Cache-Control", "no-cache"));
}
if (list.Count > 0)
{
webRequest.Headers = (IEnumerable <KeyValuePair <string, string> >)list;
}
return(webRequest);
}
internal virtual async Task <IHttpConnectionResponse> GetAsync(HttpConnectionRequest request, CancellationToken cancellationToken)
{
IHttpConnection connection = this._httpConnectionFactory.CreateHttpConnection();
Uri requestUrl = request.Url;
Uri url = requestUrl;
int retry = 0;
IHttpConnectionResponse response;
string location;
do
{
await connection.ConnectAsync(request.Proxy ?? url, cancellationToken).ConfigureAwait(false);
request.Url = url;
response = await connection.GetAsync(request, true, cancellationToken).ConfigureAwait(false);
request.Url = requestUrl;
IHttpStatus status = response.Status;
if (HttpStatusCode.Moved == status.StatusCode || HttpStatusCode.Found == status.StatusCode)
{
if (++retry < 8)
{
connection.Close();
location = Enumerable.FirstOrDefault <string>(response.Headers["Location"]);
}
else
{
goto label_5;
}
}
else
{
goto label_3;
}
}while (Uri.TryCreate(request.Url, location, out url));
goto label_7;
label_3:
IHttpConnectionResponse connectionResponse = response;
goto label_9;
label_5:
connectionResponse = response;
goto label_9;
label_7:
connectionResponse = response;
label_9:
return(connectionResponse);
}
public virtual HttpConnectionRequest CreateRequest(Uri url, Uri referrer, ContentType contentType, long?fromBytes, long?toBytes, IEnumerable <KeyValuePair <string, string> > headers)
{
HttpConnectionRequest connectionRequest = new HttpConnectionRequest()
{
Url = url,
Referrer = referrer,
RangeFrom = fromBytes,
RangeTo = toBytes,
Proxy = this._parameters.Proxy,
Headers = headers
};
if ((ContentType)null != contentType)
{
connectionRequest.Accept = this.CreateAcceptHeader(contentType);
}
return(connectionRequest);
}
private async Task Fetch <TCached>(IRetry retry, Func <Uri, byte[], TCached> factory, WebResponse webResponse, CancellationToken cancellationToken) where TCached : class
{
label_12:
HttpConnectionRequest request = this.CreateRequest();
using (IHttpConnectionResponse response = await this._webReader.SendAsync(request, true, cancellationToken, webResponse).ConfigureAwait(false))
{
if (response.IsSuccessStatusCode)
{
this._firstRequestCompleted = true;
Func <Uri, byte[], TCached> func1 = factory;
Uri responseUri = response.ResponseUri;
Func <Uri, byte[], TCached> func2 = func1;
HttpConnectionWebCache connectionWebCache = this;
byte[] numArray = await this.FetchObject(response, cancellationToken).ConfigureAwait(false);
// ISSUE: variable of a boxed type
var local = (object)func2(responseUri, numArray);
connectionWebCache._cachedObject = (object)local;
}
else
{
HttpStatusCode statusCode = response.Status.StatusCode;
if (HttpStatusCode.NotModified != statusCode)
{
if (RetryPolicy.IsRetryable(statusCode))
{
if (await retry.CanRetryAfterDelayAsync(cancellationToken).ConfigureAwait(false))
{
goto label_12;
}
}
this._cachedObject = (object)null;
response.EnsureSuccessStatusCode();
throw new WebException("Unable to fetch " + (object)request.Url);
}
}
}
}
