private void RunDownloadSync() { List <string> websites = PrepData(); foreach (string site in websites) { WebsiteDataModel results = DownloadWebsite(site); ReportWebsiteInfo(results); } }
/// <summary> /// Here is shown how a method can return a Task wrapped with data. /// The Task contains the WebsiteDataModel and it can be used in RunDownloadParallelAsync() method /// </summary> /// <param name="websiteURL"></param> /// <returns></returns> private async Task <WebsiteDataModel> DownloadWebsiteAsync(string websiteURL) { WebsiteDataModel output = new WebsiteDataModel(); WebClient client = new WebClient(); output.WebsiteUrl = websiteURL; output.WebsiteData = await client.DownloadStringTaskAsync(websiteURL); return(output); }
private static WebsiteDataModel DownloadWebsite(string websiteURL) { WebsiteDataModel output = new WebsiteDataModel(); WebClient client = new WebClient(); output.WebsiteUrl = websiteURL; output.WebsiteData = client.DownloadString(websiteURL); return(output); }
private WebsiteDataModel DownloadWebsite(string websiteURL) { var output = new WebsiteDataModel(); var client = new WebClient(); output.WebsiteUrl = websiteURL; output.WebsiteData = client.DownloadString(websiteURL); return(output); }
/// <summary> /// Method that downloads website data asynchronus. /// Notice that it returns a Task and has the keyword async. /// The await is used for the Task to wait for a method to be done executing. And the UI can be responsive while this is happening. /// </summary> /// <returns></returns> private async Task RunDownloadAsync() { List <string> websites = PrepData(); foreach (string site in websites) { WebsiteDataModel results = await Task.Run(() => DownloadWebsite(site)); ReportWebsiteInfo(results); } }
public static List <WebsiteDataModel> RunDownloadSync() { List <string> websites = PrepData(); List <WebsiteDataModel> output = new List <WebsiteDataModel>(); foreach (string site in websites) { WebsiteDataModel results = DownloadWebsite(site); output.Add(results); } return(output); }
private async Task RunDownloadAsync() { //this method is don't provide any performance optimitation because the ask for a site and the wait for the interrogation. List <string> websites = PrepData(); foreach (string site in websites) { WebsiteDataModel results = await Task.Run(() => DownloadWebsite(site)); ReportWebsiteInfo(results); } }
private WebsiteDataModel DownloadWebsite(string websiteUrl) { WebsiteDataModel output = new WebsiteDataModel(); WebClient client = new WebClient(); output.WebsiteUrl = websiteUrl; var result = client.DownloadString(websiteUrl); output.WebsiteData = result; output.getResults = !string.IsNullOrEmpty(result); return(output); }
public static List <WebsiteDataModel> RunDownloadParallelSync() { List <string> websites = PrepData(); List <WebsiteDataModel> output = new List <WebsiteDataModel>(); Parallel.ForEach <string>(websites, (site) => { WebsiteDataModel results = DownloadWebsite(site); output.Add(results); }); return(output); }
public static List <WebsiteDataModel> RunDownloadSync(System.Windows.Controls.ProgressBar dashboardProgress) { List <string> websites = PrepData(); List <WebsiteDataModel> output = new List <WebsiteDataModel>(); foreach (string site in websites) { WebsiteDataModel results = DownloadWebsite(site); output.Add(results); dashboardProgress.Dispatcher.Invoke(() => dashboardProgress.Value = output.Count * 100 / websites.Count, DispatcherPriority.Background); } return(output); }
private async Task RunDownloadAsync() { List <string> websites = PrepData(); foreach (string site in websites) { // it will block next website until the 1st website done // obs:optimize: never keep the await in foreach //u can make entire method async thats great else ts.run(method()) both same st is preferrable WebsiteDataModel results = await Task.Run(() => DownloadWebsite(site)); ReportWebsiteInfo(results); } }
//Never return void from an async task(only by an event thats an exception) private async Task RunDownloadAsync() { List <string> websites = PrepData(); foreach (string site in websites) { //Do that asynchronosly but wait for the result //The caller will go on with his work while this is running //When he gets the ressults he makes further here WebsiteDataModel results = await Task.Run(() => DownloadWebsite(site)); ReportWebsiteInfo(results); } }
private async Task <WebsiteDataModel> DownloadWebsiteAsync(string websiteUrl) { WebsiteDataModel output = new WebsiteDataModel(); output.WebsiteUrl = websiteUrl; var stopwatch = System.Diagnostics.Stopwatch.StartNew(); var result = await HttpClient.GetStringAsync(websiteUrl); output.getResults = !string.IsNullOrEmpty(result); output.WebsiteData = result; output.ThreadElapsedTime = $"{stopwatch.ElapsedMilliseconds}"; return(output); }
/// <summary> /// If we don't have control over the synchronous method 'DownloadWebsite' /// but we still need to run it asyncronously then use Task.Run. /// Tip: Don't return void from an async method. If there's nothing to return, use 'Task' /// Or if there's a return type e.g. string, use Task<string> /// One exception: In case of event leave the return type void. /// Naming convention: Append 'Async' to the end of the methodname which going to return asynchronously. /// 'async' means the caller of this method can go on with their task! /// /// </summary> /// <returns></returns> private async Task RunDownloadAsync() { List <string> websites = PrepData(); foreach (string site in websites) { //Starts DownloadWebsite method and waits it to return //Loads sites one by one //This cause similar execution time as synchronous RunDownloadSync() //But at least the UI will be responsive WebsiteDataModel results = await Task.Run(() => DownloadWebsite(site)); ReportWebsiteInfo(results); } }
public static List <WebsiteDataModel> RunDownloadParallelSync() { List <string> websites = PrepData(); List <WebsiteDataModel> output = new List <WebsiteDataModel>(); // Inside the foreach code execution is parralell, not iteration by iteration // It locks up until the longest task is ready, so the UI is inresponsive. Parallel.ForEach <string>(websites, (site) => { WebsiteDataModel results = DownloadWebsite(site); output.Add(results); }); return(output); }
public static async Task <List <WebsiteDataModel> > RunDownloadParallelAsyncV2() { List <string> websites = PrepData(); List <WebsiteDataModel> output = new List <WebsiteDataModel>(); await Task.Run(() => { Parallel.ForEach <string>(websites, (site) => { WebsiteDataModel results = DownloadWebsite(site); output.Add(results); }); }); return(output); }
private static WebsiteDataModel DownloadWebsite(string websiteURL) { WebProxy p = new WebProxy("10.216.190.6", true); p.Credentials = new NetworkCredential("john.reese", "john.reese"); WebRequest.DefaultWebProxy = p; WebsiteDataModel output = new WebsiteDataModel(); WebClient client = new WebClient(); client.Proxy = p; output.WebsiteUrl = websiteURL; output.WebsiteData = client.DownloadString(websiteURL); return(output); }
public static async Task <List <WebsiteDataModel> > RunDownloadAsync(IProgress <ProgressReportModel> progress) { List <string> websites = PrepData(); List <WebsiteDataModel> output = new List <WebsiteDataModel>(); ProgressReportModel report = new ProgressReportModel(); foreach (string site in websites) { WebsiteDataModel results = await DownloadWebsiteAsync(site); output.Add(results); report.PercentageComplete = output.Count * 100 / websites.Count; report.SitesDownloaded = output; progress.Report(report); } return(output); }
// Using Parallel ForEach public static List <WebsiteDataModel> RunDownloadParallelSync() { List <string> websites = PrepData(); List <WebsiteDataModel> output = new List <WebsiteDataModel>(); // Parallel ForEach: // foreach (string site in website) // { // WebsiteDataModel results = DownloadWebsite(site); // output.Add(results); // } Parallel.ForEach <string>(websites, (site) => { WebsiteDataModel results = DownloadWebsite(site); output.Add(results); }); return(output); }//RunDownloadParallelSync
}//RunDownloadParallelSync // Wrapping Parallel.ForEach to an Async Task public static async Task <List <WebsiteDataModel> > RunDownloadParallelAsyncV2(IProgress <ProgressReportModel> progress) { List <string> websites = PrepData(); List <WebsiteDataModel> output = new List <WebsiteDataModel>(); ProgressReportModel report = new ProgressReportModel(); await Task.Run(() => { Parallel.ForEach <string>(websites, (site) => { WebsiteDataModel results = DownloadWebsite(site); output.Add(results); report.SitesDownloaded = output; report.PercentageComplete = (output.Count * 100) / websites.Count; // converting to percent values progress.Report(report); }); }); return(output); }//RunDownloadParallelAsyncV2
public static async Task <List <WebsiteDataModel> > RunDownloadParallelAsync(IProgress <ProgressReportModel> progress) { List <string> websites = PrepData(); List <WebsiteDataModel> output = new List <WebsiteDataModel>(); ProgressReportModel report = new ProgressReportModel(); ParallelOptions parallelOptions = new ParallelOptions(); parallelOptions.MaxDegreeOfParallelism = 6; await Task.Run(() => { Parallel.ForEach <string>(websites, parallelOptions, (site) => { WebsiteDataModel results = DownloadWebsite(site); output.Add(results); report.PercentageComplete = output.Count * 100 / websites.Count; report.SitesDownloaded = output; progress.Report(report); }); }); return(output); }
public static async Task <List <WebsiteDataModel> > RunDownloadAsync(IProgress <ProgressReportModel> progress, CancellationToken cancellationToken) { List <string> websites = PrepData(); List <WebsiteDataModel> output = new List <WebsiteDataModel>(); ProgressReportModel progressReportModel = new ProgressReportModel(); foreach (string site in websites) { WebsiteDataModel results = await DownloadWebsiteAsync(site); output.Add(results); cancellationToken.ThrowIfCancellationRequested(); progressReportModel.SitesDownloaded = output; progressReportModel.PercentageComplete = (output.Count * 100) / websites.Count; progress.Report(progressReportModel); } return(output); }
}//RunDownloadParallelAsyncV2 public static async Task <List <WebsiteDataModel> > RunDownloadAsync(IProgress <ProgressReportModel> progress, CancellationToken cancellationToken) { List <string> websites = PrepData(); List <WebsiteDataModel> output = new List <WebsiteDataModel>(); ProgressReportModel report = new ProgressReportModel(); foreach (string site in websites) { WebsiteDataModel results = await DownloadWebsiteAsync(site); output.Add(results); // TODO implement if to check IsCancellationRequested method // Adding Cancelling functionaly if page takes too long to download, Won't cancel unless the task is cancelled (clicked) cancellationToken.ThrowIfCancellationRequested(); report.SitesDownloaded = output; report.PercentageComplete = (output.Count * 100) / websites.Count; // converting to percent values progress.Report(report); } return(output); }// RunDownloadAsync
private void ReportWebsiteInfo(WebsiteDataModel data) { resultsWindow.Text += $"{ data.WebsiteUrl } downloaded: { data.WebsiteData.Length } characters long.{ Environment.NewLine }"; }
private void ReportWebsiteInfo(WebsiteDataModel data) { resultsWindowBlack.Text += $"{ data.WebsiteUrl } (DL: { data.WebsiteData.Length } bytes). Time: {data.ThreadElapsedTime} ms. { Environment.NewLine }"; resultsWindowGreen.Text += $"\t {(data.getResults ? "OK!" : "FAILED!")} { Environment.NewLine }"; }