/// <summary>
/// Creates a new tile information instance.
/// </summary>
/// <param name="readCompleteHandler">Handler to call when read operations initiated by
/// <see cref="RequestImageAync"/> are completed. Make sure that the handler calls
/// <see cref="MarkImageRequestCompleted"/> or <see cref="MarkImageRequestCancelled"/> once it finishes
/// handling the request.</param>
public TileInformation(DownloadDataCompletedEventHandler readCompleteHandler)
{
RequestClient = new WebClient();
RequestClient.DownloadDataCompleted += readCompleteHandler;
IsRequestCancelled = false;
imageBuffer = new byte[BingMapsTiles.InitialImageBufferSize];
}
/// <see cref="IAsyncWebClient.DownloadDataAsync"/>
public Task<byte[]> DownloadDataAsync(Uri address, IProgress<DownloadProgressChangedEventArgs> progress, CancellationToken cancellationToken)
{
cancellationToken.Register(() => _webClient.CancelAsync());
var cookie = Guid.NewGuid();
var tcs = new TaskCompletionSource<byte[]>();
DownloadProgressChangedEventHandler progressHandler = CreateProgressHandler(cookie, progress);
if (progress != null)
_webClient.DownloadProgressChanged += progressHandler;
DownloadDataCompletedEventHandler completedHandler = null;
completedHandler = (o, e) =>
{
if (!Equals(e.UserState, cookie))
return;
_webClient.DownloadProgressChanged -= progressHandler;
_webClient.DownloadDataCompleted -= completedHandler;
tcs.TrySetFromEventArgs(e, args => args.Result);
};
_webClient.DownloadDataCompleted += completedHandler;
_webClient.DownloadDataAsync(address, cookie);
return tcs.Task;
}
public Task <byte[]> DownloadDataAsync(Uri address, CancellationToken token)
{
var tcs = new TaskCompletionSource <byte[]>();
token.Register(() =>
{
this.CancelAsync();
});
DownloadDataCompletedEventHandler onCompleted = null;
onCompleted = (s, e) =>
{
this.DownloadDataCompleted -= onCompleted;
if (e.Cancelled)
{
tcs.TrySetCanceled();
return;
}
if (e.Error != null)
{
tcs.TrySetException(e.Error);
return;
}
tcs.SetResult(e.Result);
};
this.DownloadDataCompleted += onCompleted;
base.DownloadDataAsync(address);
return(tcs.Task);
}
/// <summary>Downloads the resource with the specified URI as a byte array, asynchronously.</summary>
/// <param name="webClient">The WebClient.</param>
/// <param name="address">The URI from which to download data.</param>
/// <returns>A Task that contains the downloaded data.</returns>
public static Task <byte[]> DownloadDataTask(this WebClient webClient, Uri address)
{
// Create the task to be returned
var tcs = new TaskCompletionSource <byte[]>(address);
// Setup the callback event handler
DownloadDataCompletedEventHandler handler = null;
handler = (sender, e) => EAPCommon.HandleCompletion(tcs, e, () => e.Result, () => webClient.DownloadDataCompleted -= handler);
webClient.DownloadDataCompleted += handler;
// Start the async work
try
{
webClient.DownloadDataAsync(address, tcs);
}
catch (Exception exc)
{
// If something goes wrong kicking off the async work,
// unregister the callback and cancel the created task
webClient.DownloadDataCompleted -= handler;
tcs.TrySetException(exc);
}
// Return the task that represents the async operation
return(tcs.Task);
}
/// <summary>
/// ダウンロードを開始します。
/// </summary>
public void BeginDownload(Uri address,
DownloadDataCompletedEventHandler callback)
{
if (address == null)
{
throw new ArgumentNullException("address");
}
var client = new WebClient();
client.DownloadProgressChanged += client_DownloadProgressChanged;
client.DownloadDataCompleted += client_DownloadDataCompleted;
// ダウンロード管理用オブジェクト
var item = new DownloadItem
{
Client = client,
Callback = callback,
};
// ここで例外が返る可能性がある。
Log.Debug("{0}: ダウンロードを開始します", address);
ThreadPool.QueueUserWorkItem(_ =>
client.DownloadDataAsync(address, item));
using (LazyLock())
{
this.itemList.Add(item);
this.RaisePropertyChanged("Count");
}
}
public static Task <byte[]> DownloadDataTaskAsync(this WebClient wc, Uri address)
{
var token = new object();
var task = new TaskCompletionSource <byte[]> ();
DownloadDataCompletedEventHandler handler = null;
handler = (s, e) =>
{
wc.DownloadDataCompleted -= handler;
if (e.Error != null)
{
task.TrySetException(e.Error);
}
else if (e.Cancelled)
{
task.TrySetCanceled();
}
else
{
task.TrySetResult(e.Result);
}
};
wc.DownloadDataCompleted += handler;
wc.DownloadDataAsync(address, token);
return(task.Task);
}
/// <summary>Downloads the resource with the specified URI as a byte array, asynchronously.</summary>
/// <param name="webClient">The WebClient.</param>
/// <param name="address">The URI from which to download data.</param>
/// <returns>A Task that contains the downloaded data.</returns>
public static Task <byte[]> DownloadDataTaskAsync(this WebClient webClient, Uri address)
{
// Create the task to be returned
var tcs = new TaskCompletionSource <byte[]>(address);
// Setup the callback event handler
DownloadDataCompletedEventHandler completedHandler = null;
completedHandler = (sender, e) => TaskServices.HandleEapCompletion(tcs, true, e, () => e.Result, () => webClient.DownloadDataCompleted -= completedHandler);
webClient.DownloadDataCompleted += completedHandler;
// Start the async operation.
try
{
webClient.DownloadDataAsync(address, tcs);
}
catch
{
webClient.DownloadDataCompleted -= completedHandler;
throw;
}
// Return the task that represents the async operation
return(tcs.Task);
}
/// <summary>
/// Create an instance of the DatabaseAutomationRunner window
/// </summary>
public DatabaseAutomationRunner(ModpackSettings modpackSettings, Logfiles logfile) : base(modpackSettings, logfile)
{
InitializeComponent();
DownloadProgressChanged = WebClient_DownloadProgressChanged;
DownloadDataCompleted = WebClient_DownloadDataComplted;
DownloadFileCompleted = WebClient_TransferFileCompleted;
UploadFileCompleted = WebClient_UploadFileCompleted;
UploadProgressChanged = WebClient_UploadProgressChanged;
RelhaxProgressChanged = RelhaxProgressReport_ProgressChanged;
ProgressChanged = GenericProgressChanged;
Settings = AutomationSettings;
//https://stackoverflow.com/questions/7712137/array-containing-methods
settingsMethods = new Action[]
{
() => OpenLogWindowOnStartupSetting_Click(null, null),
() => BigmodsUsernameSetting_TextChanged(null, null),
() => BigmodsPasswordSetting_TextChanged(null, null),
() => DumpParsedMacrosPerSequenceRunSetting_Click(null, null),
() => DumpEnvironmentVariablesAtSequenceStartSetting_Click(null, null),
() => SuppressDebugMessagesSetting_Click(null, null),
() => AutomamtionDatabaseSelectedBranchSetting_TextChanged(null, null),
() => SelectDBSaveLocationSetting_TextChanged(null, null),
() => UseLocalRunnerDatabaseSetting_Click(null, null),
() => LocalRunnerDatabaseRootSetting_TextChanged(null, null),
() => SelectWoTInstallLocationSetting_TextChanged(null, null)
};
}
public static void DownloadContextAsync(string url, DownloadDataCompletedEventHandler e) {
using (var webClient = new WebClient {
Encoding = Encoding.UTF8
}) {
webClient.DownloadDataAsync(new Uri(url));
webClient.DownloadDataCompleted += e;
}
}
/// <summary>
/// 内部采集方式
/// </summary>
/// <param name="url"></param>
/// <param name="completed"></param>
private void _collect(string url, DownloadDataCompletedEventHandler completed)
{
using (WebClient client = new WebClient())
{
client.DownloadDataCompleted += completed;
client.DownloadDataAsync(new Uri(url), client);
}
}
/// <summary>
/// Синхронная или асинхронная загрузка данных
/// </summary>
/// <param name="url">Адрес</param>
/// <param name="progress">Обработчик события прогресса загрузки для асинхронной загрузки (null для синхронной</param>
/// <param name="complete">Обработчик события завершения загрузки</param>
/// <returns>Результат синхронной загрузки или null при неудаче, всегда null при асинхронной</returns>
public static string DownloadPageSilent(string url, DownloadProgressChangedEventHandler progress,
DownloadDataCompletedEventHandler complete)
{
byte[] buffer = null;
int tries = 0;
var client = new WebClient();
try
{
if (_proxySetting.UseProxy)
{
IPAddress test;
if (!IPAddress.TryParse(_proxySetting.Address, out test))
throw new ArgumentException("Некорректный адрес прокси сервера");
client.Proxy = _proxySetting.UseAuthentification
? new WebProxy(
new Uri("http://" + _proxySetting.Address + ":" + _proxySetting.Port),
false,
new string[0],
new NetworkCredential(_proxySetting.UserName, _proxySetting.Password))
: new WebProxy(
new Uri("http://" + _proxySetting.Address + ":" + _proxySetting.Port));
}
}
catch (Exception ex)
{
_logger.Add(ex.StackTrace, false, true);
_logger.Add(ex.Message, false, true);
_logger.Add("Ошибка конструктора прокси", false, true);
}
while (tries < 3)
{
try
{
SetHttpHeaders(client, null);
if (progress == null)
buffer = client.DownloadData(url);
else
{
client.DownloadProgressChanged += progress;
client.DownloadDataCompleted += complete;
client.DownloadDataAsync(new Uri(url));
return null;
}
break;
}
catch (Exception ex)
{
_logger.Add(ex.StackTrace, false, true);
_logger.Add(ex.Message, false, true);
_logger.Add("Ошибка загрузки страницы", false, true);
tries++;
}
}
return (buffer != null) ? ConvertPage(buffer) : null;
}
public void DownloadFileAsync(string url, DownloadProgressChangedEventHandler downloadProgressChanged,
DownloadDataCompletedEventHandler downloadCompleted)
{
var client = new WebClient();
client.DownloadProgressChanged += downloadProgressChanged;
client.DownloadDataCompleted += downloadCompleted;
client.DownloadDataAsync(new Uri(url));
}
/// <summary>
/// Extends BeginInvoke so that when a state object is not needed, null does not need to be passed.
/// <example>
/// downloaddatacompletedeventhandler.BeginInvoke(sender, e, callback);
/// </example>
/// </summary>
public static IAsyncResult BeginInvoke(this DownloadDataCompletedEventHandler downloaddatacompletedeventhandler, Object sender, DownloadDataCompletedEventArgs e, AsyncCallback callback)
{
if (downloaddatacompletedeventhandler == null)
{
throw new ArgumentNullException("downloaddatacompletedeventhandler");
}
return(downloaddatacompletedeventhandler.BeginInvoke(sender, e, callback, null));
}
/// <summary>
/// This event is raised each time an asynchronous data download operation completes
/// </summary>
private void Gett_DownloadDataCompleted(object sender, DownloadDataCompletedEventArgs e)
{
DownloadDataCompletedEventHandler copyDownloadDataCompleted = DownloadDataCompleted;
if (copyDownloadDataCompleted != null)
{
copyDownloadDataCompleted(this, e);
}
}
async void GetImageBitmapFromUrl(string url, DownloadDataCompletedEventHandler eventFunc)
{
Bitmap img1 = null;
using (var webClient = new System.Net.WebClient())
{
webClient.DownloadDataCompleted += eventFunc;
webClient.DownloadDataAsync(new Uri(url));
}
}
public static void ByteRequestAsync(string url, DownloadDataCompletedEventHandler dataHandler)
{
Log.O("Downloading Async: " + url);
var wc = new WebClient();
if (_proxy != null)
wc.Proxy = _proxy;
wc.DownloadDataCompleted += dataHandler;
wc.DownloadDataAsync(new Uri(url));
}
void _client_DownloadDataCompleted(object sender, DownloadDataCompletedEventArgs e)
{
DisconnectEvents();
DownloadDataCompletedEventHandler handler = DownloadDataCompleted;
if (handler != null)
{
handler(this, e);
}
}
public static void Download(string downloadUrl, string filename, DownloadDataCompletedEventHandler callbackDelegate)
{
try
{
URLDownloadToFile(0, downloadUrl, filename, 0, 0);
}
catch (Exception ex)
{
Trace.TraceError(ex.Message);
}
}
/// <summary>
/// Cancel the download
/// </summary>
public void Cancel()
{
_webc.CancelAsync();
File.Delete(_tmplocation);
DownloadDataCompletedEventHandler handler = DownloadCompleted;
if (handler != null)
{
handler(null, null);
}
}
/// <summary>
/// Downloads a file from the web.
/// </summary>
/// <param name="uri">The URI to download from.</param>
/// <param name="downloadCompleted">The event to fire when the download completes.</param>
/// <param name="downloadProgressChanged">The event to fire when the download progress changes.</param>
public static async Task <byte[]> DownloadFile(Uri uri,
DownloadDataCompletedEventHandler downloadCompleted = null,
DownloadProgressChangedEventHandler downloadProgressChanged = null)
{
// Start the modification download.
using (WebClient client = new WebClient())
{
client.DownloadDataCompleted += downloadCompleted;
client.DownloadProgressChanged += downloadProgressChanged;
return(await client.DownloadDataTaskAsync(uri));
}
}
public static void ByteRequestAsync(string url, DownloadDataCompletedEventHandler dataHandler)
{
Log.O("Downloading Async: " + url);
var wc = new WebClient();
if (_proxy != null)
{
wc.Proxy = _proxy;
}
wc.DownloadDataCompleted += dataHandler;
wc.DownloadDataAsync(new Uri(url));
}
internal static IObservable <byte[]> DownloadAttachment(this WebClient client, Uri address, string contentType = "text/plain", string username = "", string password = "")
{
return(Observable.Create <byte[]>(observer =>
{
DownloadDataCompletedEventHandler handler = (sender, args) =>
{
if (args.Cancelled)
{
observer.OnCompleted();
}
else if (args.Error != null)
{
observer.OnError(args.Error);
}
else
{
try
{
observer.OnNext(args.Result);
observer.OnCompleted();
}
catch (Exception ex)
{
observer.OnError(ex);
}
}
};
client.DownloadDataCompleted += handler;
try
{
if (!string.IsNullOrWhiteSpace(username) && !string.IsNullOrWhiteSpace(password))
{
client.SetAuthenticationHeaders(username, password);
}
client.Headers.Add(HttpRequestHeader.ContentType, contentType);
client.DownloadDataAsync(address);
}
catch (Exception ex)
{
observer.OnError(ex);
}
return () => client.DownloadDataCompleted -= handler;
}));
}
/// <summary>
/// <paramref name="address"/>의 리소스를 비동기적으로 다운받아 byte array로 반환하는 Task{byte[]}를 빌드합니다.
/// </summary>
/// <param name="webClient"><see cref="WebClient"/> 인스턴스</param>
/// <param name="token">작업 취소를 위한 Token</param>
/// <param name="address">리소스 위치</param>
/// <returns></returns>
public static Task <byte[]> DownloadDataTask(this WebClient webClient, CancellationToken token, Uri address)
{
webClient.ShouldNotBeNull("webClient");
token.ShouldNotBeNull("token");
address.ShouldNotBeNull("address");
if (IsDebugEnabled)
{
log.Debug("WebClient를 이용하여 지정된 주소로부터 리소스를 비동기 방식으로 다운받습니다... address=[{0}]", address.AbsoluteUri);
}
var tcs = new TaskCompletionSource <byte[]>(address);
token.Register(webClient.CancelAsync);
// 비동기 완료 시의 처리를 정의합니다.
DownloadDataCompletedEventHandler handler = null;
handler =
(sender, args) =>
EventAsyncPattern.HandleCompletion(tcs, args, () => args.Result, () => webClient.DownloadDataCompleted -= handler);
webClient.DownloadDataCompleted += handler;
try {
webClient.DownloadDataAsync(address, tcs);
}
catch (Exception ex) {
if (log.IsWarnEnabled)
{
log.Warn("WebClient를 이용하여 리소스 Data를 비동기적으로 다운받는데 실패했습니다. address=[{0}]", address.AbsoluteUri);
log.Warn(ex);
}
webClient.DownloadDataCompleted -= handler;
tcs.TrySetException(ex);
}
var result = tcs.Task;
if (result.IsCompleted)
{
result = result.ContinueWith(antecedent => DecompressByContentEncoding(webClient, antecedent.Result),
TaskContinuationOptions.ExecuteSynchronously);
}
return(result);
}
/// <summary>
/// Handle finished download, move file from temporary to target location
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Finished(object sender, DownloadDataCompletedEventArgs e)
{
Logger.Log(LogLevel.Info, "FileDownloadProgressBar", "Download finished!", _url);
// Move to the correct location
if (File.Exists(_targetlocation))
{
File.Delete(_targetlocation);
}
File.Move(_tmplocation, _targetlocation);
DownloadDataCompletedEventHandler handler = DownloadCompleted;
if (handler != null)
{
handler(sender, e);
}
}
public Task <byte[]> GetDataAsync(string url, CancellationToken token)
{
// create completion source
var tcs = new TaskCompletionSource <byte[]>();
// create a web client for downloading the string
var wc = new WebClient();
// Set up variable for referencing anonymous event handler method. We
// need to first assign null, and then create the method so that we
// can reference the variable within the method itself.
DownloadDataCompletedEventHandler downloadCompletedHandler = null;
// Set up an anonymous method that will handle the DownloadStringCompleted
// event.
downloadCompletedHandler = (s, e) =>
{
wc.DownloadDataCompleted -= downloadCompletedHandler;
if (e.Cancelled)
{
tcs.TrySetCanceled();
}
else if (e.Error == null)
{
tcs.TrySetResult(e.Result);
}
else
{
tcs.TrySetException(e.Error);
}
wc.Dispose();
};
// Subscribe to the completed event
wc.DownloadDataCompleted += downloadCompletedHandler;
try
{
wc.DownloadDataAsync(new Uri(url));
token.Register(new Action(wc.CancelAsync));
}
catch (Exception exception)
{
tcs.TrySetException(exception);
}
return(tcs.Task);
}
/// <summary>Downloads the resource with the specified URI as a byte array, asynchronously.</summary>
/// <param name="webClient">The WebClient.</param>
/// <param name="address">The URI from which to download data.</param>
/// <returns>A Task that contains the downloaded data.</returns>
public static Task <byte[]> DownloadDataTask(this WebClient webClient, Uri address)
{
TaskCompletionSource <byte[]> tcs = new TaskCompletionSource <byte[]>(address);
DownloadDataCompletedEventHandler handler = null;
handler = delegate(object sender, DownloadDataCompletedEventArgs e) {
EAPCommon.HandleCompletion <byte[]>(tcs, e, () => e.Result, delegate {
webClient.DownloadDataCompleted -= handler;
});
};
webClient.DownloadDataCompleted += handler;
try
{
webClient.DownloadDataAsync(address, tcs);
}
catch (Exception exception)
{
webClient.DownloadDataCompleted -= handler;
tcs.TrySetException(exception);
}
return(tcs.Task);
}
public static Task <byte[]> DownloadDataTaskAsync(this WebClient webClient, Uri address)
{
TaskCompletionSource <byte[]> tcs = new TaskCompletionSource <byte[]>(address);
DownloadDataCompletedEventHandler completedHandler = null;
completedHandler = delegate(object sender, DownloadDataCompletedEventArgs e)
{
AsyncCompatLibExtensions.HandleEapCompletion <byte[]>(tcs, true, e, () => e.Result, delegate
{
webClient.DownloadDataCompleted -= completedHandler;
});
};
webClient.DownloadDataCompleted += completedHandler;
try
{
webClient.DownloadDataAsync(address, tcs);
}
catch
{
webClient.DownloadDataCompleted -= completedHandler;
throw;
}
return(tcs.Task);
}
/// <summary>
/// 异步抓取页面HTML代码
/// </summary>
private TmphDataCrawler()
{
onDownloadHandle = onDownload;
onUploadHandle = onUpload;
}
/// <summary>
/// Asynchronously downloads the resource with the specified URI as a Byte array limited by the specified timeout and allows cancelling the operation.
/// </summary>
/// <param name="webClient">The client with which to download the specified resource.</param>
/// <param name="uri">The address of the resource to download.</param>
/// <param name="timeout">A TimeSpan specifying the amount of time to wait for a response before aborting the request.
/// The specify an infinite timeout, pass a TimeSpan with a TotalMillisecond value of Timeout.Infinite.
/// When a request is aborted due to a timeout the returned task will transition to the Faulted state with a TimeoutException.</param>
/// <param name="token">A cancellation token that can be used to cancel the pending asynchronous task.</param>
/// <returns>A Task with the future value of the downloaded string.</returns>
/// <exception cref="ArgumentNullException">Thrown when a null value is passed to the client or address parameters.</exception>
/// <exception cref="ArgumentOutOfRangeException">Thrown when the value of timeout is neither a positive value or infinite.</exception>
public static Task <byte[]> DownloadDataTaskAsync(this WebClient webClient, Uri uri, TimeSpan timeout, CancellationToken token)
{
if (webClient == null)
{
throw new ArgumentNullException(nameof(webClient));
}
if (uri == null)
{
throw new ArgumentNullException(nameof(uri));
}
if (timeout.TotalMilliseconds < 0 && timeout != DefaultTimeout)
{
throw new ArgumentOutOfRangeException(nameof(uri), timeout, "The timeout value must be a positive or equal to InfiniteTimeout.");
}
if (token.IsCancellationRequested)
{
return(PreCancelledTask);
}
var taskCompletionSource = new TaskCompletionSource <byte[]>();
var cancellationTokenSource = new CancellationTokenSource();
if (timeout != DefaultTimeout)
{
Task.Delay(timeout, cancellationTokenSource.Token).ContinueWith(x =>
{
taskCompletionSource.TrySetException(new TimeoutException($"The request has exceeded the timeout limit of {timeout} and has been aborted."));
webClient.CancelAsync();
}, TaskContinuationOptions.ExecuteSynchronously | TaskContinuationOptions.NotOnCanceled);
}
DownloadDataCompletedEventHandler completedHandler = null;
completedHandler = (sender, args) =>
{
webClient.DownloadDataCompleted -= completedHandler;
cancellationTokenSource.Cancel();
if (args.Cancelled)
{
taskCompletionSource.TrySetCanceled();
}
else if (args.Error != null)
{
taskCompletionSource.TrySetException(args.Error);
}
else
{
taskCompletionSource.TrySetResult(args.Result);
}
};
webClient.DownloadDataCompleted += completedHandler;
try
{
webClient.DownloadDataAsync(uri);
}
catch
{
webClient.DownloadDataCompleted -= completedHandler;
throw;
}
token.Register(() =>
{
cancellationTokenSource.Cancel();
webClient.CancelAsync();
});
return(taskCompletionSource.Task);
}
/// <summary>
/// Синхронная или асинхронная загрузка данных
/// </summary>
/// <param name="url">Адрес</param>
/// <param name="progress">Обработчик события прогресса загрузки для асинхронной загрузки (null для синхронной</param>
/// <param name="complete">Обработчик события завершения загрузки</param>
/// <returns>Результат синхронной загрузки или null при неудаче, всегда null при асинхронной</returns>
public static string DownloadPageSilent(string url, DownloadProgressChangedEventHandler progress,
DownloadDataCompletedEventHandler complete)
{
byte[] buffer = null;
int tries = 0;
var client = new WebClient();
try
{
if (_proxySetting.UseProxy)
{
IPAddress test;
if (!IPAddress.TryParse(_proxySetting.Address, out test))
{
throw new ArgumentException("Некорректный адрес прокси сервера");
}
client.Proxy = _proxySetting.UseAuthentification
? new WebProxy(
new Uri("http://" + _proxySetting.Address + ":" + _proxySetting.Port),
false,
new string[0],
new NetworkCredential(_proxySetting.UserName, _proxySetting.Password))
: new WebProxy(
new Uri("http://" + _proxySetting.Address + ":" + _proxySetting.Port));
}
}
catch (Exception ex)
{
_logger.Add(ex.StackTrace, false, true);
_logger.Add(ex.Message, false, true);
_logger.Add("Ошибка конструктора прокси", false, true);
}
while (tries < 3)
{
try
{
SetHttpHeaders(client, null);
if (progress == null)
{
buffer = client.DownloadData(url);
}
else
{
client.DownloadProgressChanged += progress;
client.DownloadDataCompleted += complete;
client.DownloadDataAsync(new Uri(url));
return(null);
}
break;
}
catch (Exception ex)
{
_logger.Add(ex.StackTrace, false, true);
_logger.Add(ex.Message, false, true);
_logger.Add("Ошибка загрузки страницы", false, true);
tries++;
}
}
return((buffer != null) ? ConvertPage(buffer) : null);
}
/// <summary>
/// Http同步Get异步请求
/// </summary>
/// <param name="uriString"></param>
/// <param name="uriParameters"></param>
/// <param name="callBackDownDataCompleted"></param>
/// <param name="msg"></param>
/// <param name="queryUrl"></param>
public void GetSrcAsync(string uriString, Dictionary <string, object> uriParameters, DownloadDataCompletedEventHandler callBackDownDataCompleted, out string msg, out string queryUrl)
{
queryUrl = "";
msg = "";
try
{
string parameters = BuildingUrlParams(uriParameters);
string cookieString = BuildCookies();
if (!string.IsNullOrWhiteSpace(parameters))
{
uriString += "?" + parameters;
}
if (!string.IsNullOrWhiteSpace(cookieString))
{
this.Headers[HttpRequestHeader.Cookie] = cookieString;
}
// 返回页面的字节数组
this.Headers[HttpRequestHeader.Accept] = "application/json, text/javascript, */*; q=0.01";
if (callBackDownDataCompleted != null)
{
this.DownloadDataCompleted += callBackDownDataCompleted;
}
this.DownloadDataAsync(new Uri(uriString));
}
catch (WebException we)
{
msg = we.Message;
}
}
/// <summary>
/// 异步抓取页面HTML代码
/// </summary>
private dataCrawler()
{
onDownloadHandle = onDownload;
onPostFormHandle = onPostForm;
onUploadHandle = onUpload;
}
/// <summary>
/// Asynchronously downloads the resource with the specified URI as a Byte array limited by the specified timeout and allows cancelling the operation.
/// </summary>
/// <param name="_client">The client with which to download the specified resource.</param>
/// <param name="_address">The address of the resource to download.</param>
/// <param name="_timeout">A TimeSpan specifying the amount of time to wait for a response before aborting the request.
/// The specify an infinite timeout, pass a TimeSpan with a TotalMillisecond value of Timeout.Infinite.
/// When a request is aborted due to a timeout the returned task will transition to the Faulted state with a TimeoutException.</param>
/// <param name="_token">A cancellation token that can be used to cancel the pending asynchronous task.</param>
/// <returns>A Task with the future value of the downloaded string.</returns>
/// <exception cref="ArgumentNullException">Thrown when a null value is passed to the client or address parameters.</exception>
/// <exception cref="ArgumentOutOfRangeException">Thrown when the value of timeout is neither a positive value or infinite.</exception>
public static Task <byte[]> DownloadDataTaskAsync(this WebClient _client, Uri _address, TimeSpan _timeout, CancellationToken _token)
{
if (_client == null)
{
throw new ArgumentNullException("_client");
}
if (_address == null)
{
throw new ArgumentNullException("_address");
}
if (_timeout.TotalMilliseconds < 0 && _timeout != _infiniteTimeout)
{
throw new ArgumentOutOfRangeException("_address", _timeout, "The timeout value must be a positive or equal to InfiniteTimeout.");
}
if (_token.IsCancellationRequested)
{
return(_preCancelledTask);
}
var _tcs = new TaskCompletionSource <byte[]>();
var _delayTokenSource = new CancellationTokenSource();
if (_timeout != _infiniteTimeout)
{
Task.Delay(_timeout, _delayTokenSource.Token).ContinueWith(_t =>
{
_tcs.TrySetException(new TimeoutException(string.Format("The request has exceeded the timeout limit of {0} and has been aborted.", _timeout)));
_client.CancelAsync();
}, TaskContinuationOptions.ExecuteSynchronously | TaskContinuationOptions.NotOnCanceled);
}
DownloadDataCompletedEventHandler _completedHandler = null;
_completedHandler = (_sender, _args) =>
{
_client.DownloadDataCompleted -= _completedHandler;
_delayTokenSource.Cancel();
if (_args.Cancelled)
{
_tcs.TrySetCanceled();
}
else if (_args.Error != null)
{
_tcs.TrySetException(_args.Error);
}
else
{
_tcs.TrySetResult(_args.Result);
}
};
_client.DownloadDataCompleted += _completedHandler;
try
{
_client.DownloadDataAsync(_address);
}
catch
{
_client.DownloadDataCompleted -= _completedHandler;
throw;
}
_token.Register(() =>
{
_delayTokenSource.Cancel();
_client.CancelAsync();
});
return(_tcs.Task);
}
/// <summary>
/// Asynchronously downloads the resource with the specified URI as a Byte array limited by the specified timeout and allows cancelling the operation.
/// </summary>
/// <param name="client">The client with which to download the specified resource.</param>
/// <param name="address">The address of the resource to download.</param>
/// <param name="timeout">A TimeSpan specifying the amount of time to wait for a response before aborting the request.
/// The specify an infinite timeout, pass a TimeSpan with a TotalMillisecond value of Timeout.Infinite.
/// When a request is aborted due to a timeout the returned task will transition to the Faulted state with a TimeoutException.</param>
/// <param name="token">A cancellation token that can be used to cancel the pending asynchronous task.</param>
/// <returns>A Task with the future value of the downloaded string.</returns>
/// <exception cref="ArgumentNullException">Thrown when a null value is passed to the client or address parameters.</exception>
/// <exception cref="ArgumentOutOfRangeException">Thrown when the value of timeout is neither a positive value or infinite.</exception>
public static Task <byte[]> DownloadDataTaskAsync(this WebClient client, Uri address, TimeSpan timeout, CancellationToken token)
{
if (client == null)
{
throw new ArgumentNullException("client");
}
if (address == null)
{
throw new ArgumentNullException("address");
}
if (timeout.TotalMilliseconds < 0 && timeout != InfiniteTimeout)
{
throw new ArgumentOutOfRangeException("address", timeout, "The timeout value must be a positive or equal to InfiniteTimeout.");
}
if (token.IsCancellationRequested)
{
return(PreCancelledTask);
}
var tcs = new TaskCompletionSource <byte[]>();
var delayTokenSource = new CancellationTokenSource();
if (timeout != InfiniteTimeout)
{
Task.Factory.Delay(timeout, delayTokenSource.Token).ContinueWith(t =>
{
tcs.TrySetException(new TimeoutException(string.Format("The request has exceeded the timeout limit of {0} and has been aborted.", timeout)));
client.CancelAsync();
}, TaskContinuationOptions.ExecuteSynchronously | TaskContinuationOptions.NotOnCanceled);
}
DownloadDataCompletedEventHandler completedHandler = null;
completedHandler = (sender, args) =>
{
client.DownloadDataCompleted -= completedHandler;
delayTokenSource.Cancel();
if (args.Cancelled)
{
tcs.TrySetCanceled();
}
else if (args.Error != null)
{
tcs.TrySetException(args.Error);
}
else
{
tcs.TrySetResult(args.Result);
}
};
client.DownloadDataCompleted += completedHandler;
try
{
client.DownloadDataAsync(address);
}
catch
{
client.DownloadDataCompleted -= completedHandler;
throw;
}
token.Register(() =>
{
delayTokenSource.Cancel();
client.CancelAsync();
});
return(tcs.Task);
}
// per-revision logic
private void DownloadFileAndDisplayThumb()
{
XmlNode topImage = ImageInfos[SelectedRevisions[0]];
Invoke((MethodInvoker) delegate()
{
if (SelectedRevisions.Length > 1)
lblRevision.Text = Localization.GetString("MultipleVersions_Label", SelectedRevisions.Length.ToString(),
ImageInfos.Count.ToString());
else if (SelectedRevisions[0] == 0)
lblRevision.Text = Localization.GetString("CurrentVersion_Label") + " (" + FormatTimestamp(topImage) + ")";
else
lblRevision.Text = Localization.GetString("OldVersion_Label") + " (" + FormatTimestamp(topImage) + ")";
lblDimensions.Text = FormatDimensions(topImage);
lblRevision.ForeColor = lblName.ForeColor = (SelectedRevisions[0] == 0 && SelectedRevisions.Length == 1 ? SystemColors.ControlText : Color.Red);
XmlNodeList metadatas = topImage.SelectNodes("metadata/metadata");
if (metadatas.Count > 4)
{
lblViewExif.Visible = btnViewExif.Visible = true;
btnViewExif.Tag = metadatas;
}
else
lblViewExif.Visible = btnViewExif.Visible = false;
pictureBox1.SizeMode = PictureBoxSizeMode.CenterImage;
pictureBox1.Image = pictureBox1.InitialImage;
pictureBox1.Cursor = Cursors.Default;
});
// decide whether PictureBox can display this image
bool previewDownloadedFile = false;
if (topImage.Attributes["thumburl"].Value == "")
{
// probably an OGG or something
Invoke((MethodInvoker) delegate()
{
pictureBox1.Image = pictureBox1.ErrorImage;
});
}
else
{
switch (topImage.Attributes["mime"].Value)
{
// GDI+ natively supports only these formats
case "image/gif":
case "image/jpeg":
case "image/png":
case "image/tiff":
previewDownloadedFile = true;
break;
default:
// try to download PNG thumb
// ImageLocation doesn't work, because of the useragent
WebClient clThumb = new WebClient();
clThumb.Headers.Add("User-Agent", MorebitsDotNet.UserAgent);
clThumb.DownloadDataCompleted += new DownloadDataCompletedEventHandler(
delegate(object s, DownloadDataCompletedEventArgs v)
{
pictureBox1.SizeMode = PictureBoxSizeMode.CenterImage;
Invoke((MethodInvoker) delegate()
{
try
{
pictureBox1.Image = Image.FromStream(new MemoryStream(v.Result, false));
pictureBox1.Cursor = ZoomInCursor;
}
catch (Exception)
{
pictureBox1.Image = pictureBox1.ErrorImage;
}
});
});
clThumb.DownloadDataAsync(new Uri(topImage.Attributes["thumburl"].Value));
break;
}
}
// download files
SetTransferButtonDownloading(true);
int currentIndexIndex = 0; // the index into SelectedRevisions (an array of indexes). So meta!
DownloadDataCompletedEventHandler displayThumbHandler = null;
displayThumbHandler = new DownloadDataCompletedEventHandler(
delegate(object s, DownloadDataCompletedEventArgs v)
{
if (v.Cancelled)
{
SetTransferButtonDownloading(false);
return;
}
if (v.Error != null)
{
ErrorHandler(Localization.GetString("FailedToDownload") + "\n\n" + v.Error.Message);
SetTransferButtonDownloading(false);
return;
}
ImageDatas[SelectedRevisions[currentIndexIndex]] = v.Result;
if (previewDownloadedFile && currentIndexIndex == 0)
{
Invoke((MethodInvoker) delegate()
{
try
{
Image img = Image.FromStream(new MemoryStream(ImageDatas[SelectedRevisions[currentIndexIndex]], false));
if (img.Height > pictureBox1.Height || img.Width > pictureBox1.Width)
pictureBox1.SizeMode = PictureBoxSizeMode.Zoom;
else
pictureBox1.SizeMode = PictureBoxSizeMode.CenterImage;
pictureBox1.Image = img;
pictureBox1.Cursor = ZoomInCursor;
}
catch (Exception)
{
pictureBox1.SizeMode = PictureBoxSizeMode.CenterImage;
pictureBox1.Image = pictureBox1.ErrorImage;
}
});
}
if (++currentIndexIndex < SelectedRevisions.Length)
{
ImageDataDownloader = new WebClient();
ImageDataDownloader.Headers.Add("User-Agent", MorebitsDotNet.UserAgent);
ImageDataDownloader.DownloadDataCompleted += displayThumbHandler;
ImageDataDownloader.DownloadDataAsync(new Uri(ImageInfos[SelectedRevisions[currentIndexIndex]].Attributes["url"].Value));
}
else
{
SetTransferButtonDownloading(false);
}
});
ImageDataDownloader = new WebClient();
ImageDataDownloader.Headers.Add("User-Agent", MorebitsDotNet.UserAgent);
ImageDataDownloader.DownloadDataCompleted += displayThumbHandler;
ImageDataDownloader.DownloadDataAsync(new Uri(ImageInfos[SelectedRevisions[currentIndexIndex]].Attributes["url"].Value));
}
/// <summary>
/// 下载更新文件
/// </summary>
void DownloadFile(string baseAddress, string file, DownloadDataCompletedEventHandler downloadCompleted, double progress)
{
var client = new WebClient();
client.BaseAddress = baseAddress;
double value = 0;
client.DownloadProgressChanged += (sender, e) =>
{
var i = e.ProgressPercentage * progress / 100 - value;
value = e.ProgressPercentage * progress / 100;
MainWindow.UpdateProgress(i);
};
client.DownloadDataCompleted += (x, y) =>
{
if (y.Error != null)
MainWindow.ShowError(y.Error);
else
{
try
{
downloadCompleted(x, y);
}
catch (Exception exc) { MainWindow.ShowError(exc); }
}
};
client.DownloadDataAsync(new Uri(file, UriKind.Relative));
}
/// <summary>
/// ダウンロードを開始します。
/// </summary>
public void BeginDownload(Uri address,
DownloadDataCompletedEventHandler callback)
{
if (address == null)
{
throw new ArgumentNullException("address");
}
var client = new WebClient();
client.DownloadProgressChanged += client_DownloadProgressChanged;
client.DownloadDataCompleted += client_DownloadDataCompleted;
// ダウンロード管理用オブジェクト
var item = new DownloadItem
{
Client = client,
Callback = callback,
};
// ここで例外が返る可能性がある。
Log.Debug("{0}: ダウンロードを開始します", address);
ThreadPool.QueueUserWorkItem(_ =>
client.DownloadDataAsync(address, item));
using (LazyLock())
{
this.itemList.Add(item);
this.RaisePropertyChanged("Count");
}
}
