[Fork] Application Developer Test Task.WhenAll | C# Online Compiler

[Fork] Application Developer Test Task.WhenAll by enano90

using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Threading.Tasks;

namespace DCUTest
{
	public class Program
	{
		public static void Main(string[] args)
		{
			try
			{
				// Get the locations that we want to retrieve the forecast information for
				List<Location> locations = GetLocations();

				// Set the forecasts for each location
				SetForecastsAsync(locations).GetAwaiter().GetResult();

				// Remove the forecasts that aren't in the next 5 days
				locations.ForEach(x => x.Forecasts.RemoveAll(y => y.Date <= DateTime.Today || y.Date > DateTime.Today.AddDays(5)));

				// Output the results
				OutputResults(locations);
			}
			catch (Exception ex)
			{
				// TODO: Log the error instead of just displaying the error message
				Console.WriteLine(ex.Message);
			}
		}

		#region Private Methods
		private static List<Location> GetLocations()
		{
			// This list is hard-coded for now
			// In a production environment, this would most likely come from a database or user input
			return new List<Location>
			{
				// .NET Fiddle doesn't support property initializers so initialize the Forecasts lists here
				new Location{ City = "Marlboro", State = "MA", ZIPCode = "01752", Forecasts = new List<Forecast>() },
				new Location{ City = "San Diego", State = "CA", ZIPCode = "92101", Forecasts = new List<Forecast>() },
				new Location{ City = "Cheyenne", State = "WY", ZIPCode = "82001", Forecasts = new List<Forecast>() },
				new Location{ City = "Anchorage", State = "AK", ZIPCode = "99501", Forecasts = new List<Forecast>() },
				new Location{ City = "Austin", State = "TX", ZIPCode = "73301", Forecasts = new List<Forecast>() },
				new Location{ City = "Orlando", State = "FL", ZIPCode = "32801", Forecasts = new List<Forecast>() },
				new Location{ City = "Seattle", State = "WA", ZIPCode = "98101", Forecasts = new List<Forecast>() },
				new Location{ City = "Cleveland", State = "OH", ZIPCode = "44101", Forecasts = new List<Forecast>() },
				new Location{ City = "Portland", State = "ME", ZIPCode = "04101", Forecasts = new List<Forecast>() },
				new Location{ City = "Honolulu", State = "HI", ZIPCode = "96801", Forecasts = new List<Forecast>() }
			};
		}

		private async static Task SetForecastsAsync(List<Location> locations)
		{
			List<Task> forecastTasks = new List<Task>();

			foreach (Location location in locations)
			{
				Task task = SetForecastAsync(location);
				forecastTasks.Add(task);
			}

			await Task.WhenAll(forecastTasks);
		}

		private static async Task SetForecastAsync(Location location)
		{
			try
			{
				// Get the API Url
				string url = GetWeatherApiUrl(location.ZIPCode);

				using (HttpClient client = GetHttpClient())
				{
					// Get the forecast data
					HttpResponseMessage response = await client.GetAsync(url).ConfigureAwait(false);

					// If the response wasn't successful just return so we can attempt to get the forecast for the remaining locations
					if (!response.IsSuccessStatusCode) return;

					// Get the results, which will be in JSON format
					string result = await response.Content.ReadAsStringAsync();

					// Deserialize the JSON to a ForecastResponse object
					ForecastResponse forecastResponse = JsonConvert.DeserializeObject<ForecastResponse>(result, new JsonSerializerSettings { MissingMemberHandling = MissingMemberHandling.Ignore, NullValueHandling = NullValueHandling.Ignore });

					// Remove any records that have either an invalid date or temperature
					// .NET Fiddle doesn't support the use of _ in a TryParse so create variables to store the data
					DateTime date;
					double temperature;
					forecastResponse.Forecasts.RemoveAll(x => !DateTime.TryParse(x.ForecastDateTime, out date));
					forecastResponse.Forecasts.RemoveAll(x => !double.TryParse(x.Main.Temperature, out temperature));

					// Use GroupBy for deferred execution
					//var forecasts = forecastResponse.Forecasts.GroupBy(x => x.ForecastDateTime.Date).Select(x => x).ToList();
					
					// Use ToLookup for immediate execution
					var forecasts = forecastResponse.Forecasts.ToLookup(x => DateTime.Parse(x.ForecastDateTime).Date).Select(x => x).ToList();

					foreach (var forecast in forecasts)
					{
						// Get the average temperature
						double averageTemperature = forecast.Average(x => double.Parse(x.Main.Temperature));

						// Set a boolean to indicate if there is any precipitation for the current day
						// Based on the API documentation, there will be data in either the Rain or Snow node if rain or snow are expected
						bool precipitation = forecast.Any(x => x.Rain != null || x.Snow != null);

						// Add a new Forecast object which holds the forecast data for a specific day
						location.Forecasts.Add(new Forecast { Date = forecast.Key, AverageTemperature = averageTemperature, PrecipitationExpected = precipitation });
					}
				}
			}
			catch (Exception ex)
			{
				// TODO: Log the error instead of just displaying the error message
				Console.WriteLine(ex.Message);
			}
		}

		private static void OutputResults(List<Location> locations)
		{
			// Display the results
			foreach (Location location in locations)
			{
				// Format the results
				Console.WriteLine("______________________________");
				
				//Console.WriteLine($"{location.City}, {location.State} ({location.ZIPCode})");
				// .NET Fiddle doesn't support string interpolation so create the string the old fashioned way
				Console.WriteLine(location.City + ", " + location.State + " (" + location.ZIPCode + ")");
				
				Console.WriteLine();

				// If there was an error retrieving the forecast data for a location, display a message indicating this
				if (!location.Forecasts.Any())
				{
					Console.WriteLine("Unable to retrieve forecast data.");
				}
				else
				{
					Console.WriteLine("Date" + '\t' + '\t' + "Avg Temp(F)");
					Console.WriteLine("------------------------------");
					foreach (Forecast forecast in location.Forecasts)
					{
						Console.WriteLine(forecast.Date.ToShortDateString() + (forecast.PrecipitationExpected ? "*" : "") + '\t' + forecast.AverageTemperature.ToString("N2") + " F");
					}
				}
				
				Console.WriteLine();
				Console.WriteLine();
			}
		}

		private static HttpClient GetHttpClient()
		{
			HttpClient httpClient = new HttpClient();

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

			return httpClient;
		}

		private static string GetWeatherApiUrl(string ZIPCode)
		{
			try
			{
				// .NET Fiddle doesn't support string interpolation so create the string the old fashioned way
				//return $"https://api.openweathermap.org/data/2.5/forecast?APPID=18d9276a9325e3147ac2996320fa24f8&units=Imperial&zip={ZIPCode}";
				return "https://api.openweathermap.org/data/2.5/forecast?APPID=18d9276a9325e3147ac2996320fa24f8&units=Imperial&zip=" + ZIPCode;
			}
			catch (Exception ex)
			{
				// TODO: Log the error instead of just displaying the error message
				Console.WriteLine(ex.Message);

				// If we don't have a URL then we can't continue so throw an error
				throw;
			}
		}
		#endregion
	}
	
	class Location
	{
		public string City { get; set; }
		public string State { get; set; }
		public string ZIPCode { get; set; }
		public List<Forecast> Forecasts { get; set; }	// = new List<Forecast>();
	}

	class Forecast
	{
		public DateTime Date { get; set; }
		public double AverageTemperature { get; set; }
		public bool PrecipitationExpected { get; set; }
	}

	class ForecastResponse
	{
		// Internal parameter
		[JsonProperty("cod")]
		public string Cod { get; set; }

		// Internal parameter
		[JsonProperty("message")]
		public string Message { get; set; }

		// Number of lines returned by this API call
		[JsonProperty("cnt")]
		public string NumberOfDays { get; set; }

		[JsonProperty("list")]
		public List<Forecast> Forecasts { get; set; }

		[JsonProperty("city")]
		public CityData City { get; set; }

		public class Main
		{
			// Temperature. Unit Default: Kelvin, Metric: Celsius, Imperial: Fahrenheit.
			[JsonProperty("temp")]
			public string Temperature { get; set; }

			// Minimum temperature at the moment of calculation. This is deviation from 'temp' that is possible for large cities and megalopolises geographically expanded (use these parameter optionally). Unit Default: Kelvin, Metric: Celsius, Imperial: Fahrenheit.
			[JsonProperty("temp_min")]
			public string MinimumTemperature { get; set; }

			// Maximum temperature at the moment of calculation.This is deviation from 'temp' that is possible for large cities and megalopolises geographically expanded(use these parameter optionally). Unit Default: Kelvin, Metric: Celsius, Imperial: Fahrenheit.
			[JsonProperty("temp_max")]
			public string MaximumTemperature { get; set; }

			// Atmospheric pressure on the sea level by default, hPa
			[JsonProperty("pressure")]
			public string Pressure { get; set; }

			// Atmospheric pressure on the sea level, hPa
			[JsonProperty("sea_level")]
			public string SeaLevel { get; set; }

			// Atmospheric pressure on the ground level, hPa
			[JsonProperty("grnd_level")]
			public string GroundLevel { get; set; }

			// Humidity, %
			[JsonProperty("humidity")]
			public string Humidity { get; set; }

			// Internal parameter
			[JsonProperty("temp_kf")]
			public string KFTemperature { get; set; }
		}

		public class Weather
		{
			// Weather condition id
			[JsonProperty("id")]
			public string Id { get; set; }

			// Group of weather parameters (Rain, Snow, Extreme etc.)
			[JsonProperty("main")]
			public string Main { get; set; }

			// Weather condition within the group
			[JsonProperty("description")]
			public string Description { get; set; }

			// Weather icon id
			[JsonProperty("icon")]
			public string Icon { get; set; }
		}

		public class Clouds
		{
			// Cloudiness, %
			[JsonProperty("all")]
			public string Cloudiness { get; set; }
		}

		public class Wind
		{
			// Wind speed. Unit Default: meter/sec, Metric: meter/sec, Imperial: miles/hour.
			[JsonProperty("speed")]
			public string Speed { get; set; }

			// Wind direction, degrees (meteorological)
			[JsonProperty("deg")]
			public string WindDirection { get; set; }
		}

		public class Precipitation
		{
			// Volume for last 3 hours, mm
			[JsonProperty("3h")]
			public string VolumeForLast3Hours { get; set; }
		}

		public class Sys
		{
			[JsonProperty("pod")]
			public string Pod { get; set; }
		}

		public class Forecast
		{
			// Time of data forecasted, unix, UTC
			[JsonProperty("dt")]
			public string ForecastTime { get; set; }

			[JsonProperty("main")]
			public Main Main { get; set; }

			[JsonProperty("weather")]
			public List<Weather> Weather { get; set; }

			[JsonProperty("clouds")]
			public Clouds Clouds { get; set; }

			[JsonProperty("wind")]
			public Wind Wind { get; set; }

			[JsonProperty("rain")]
			public Precipitation Rain { get; set; }

			[JsonProperty("snow")]
			public Precipitation Snow { get; set; }

			[JsonProperty("sys")]
			public Sys Sys { get; set; }

			// Data/time of calculation, UTC
			[JsonProperty("dt_txt")]
			public string ForecastDateTime { get; set; }
		}

		public class Coordinates
		{
			// City geo location, latitude
			[JsonProperty("lat")]
			public string Latitude { get; set; }

			// City geo location, longitude
			[JsonProperty("lon")]
			public string Longitude { get; set; }
		}

		public class CityData
		{
			// City name
			[JsonProperty("name")]
			public string Name { get; set; }

			[JsonProperty("coord")]
			public Coordinates Coordinates { get; set; }

			// Country code (GB, JP etc.)
			[JsonProperty("country")]
			public string Country { get; set; }

			// Shift in seconds from UTC
			[JsonProperty("timezone")]
			public string TimeZone { get; set; }

			[JsonProperty("sunrise")]
			public string Sunrise { get; set; }

			[JsonProperty("sunset")]
			public string Sunset { get; set; }
		}
	}
}

​x
 
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Threading.Tasks;
​
namespace DCUTest
{
    public class Program
    {
        public static void Main(string[] args)
        {
            try
            {
                // Get the locations that we want to retrieve the forecast information for
                List<Location> locations = GetLocations();
​
                // Set the forecasts for each location
                SetForecastsAsync(locations).GetAwaiter().GetResult();
​
                // Remove the forecasts that aren't in the next 5 days
                locations.ForEach(x => x.Forecasts.RemoveAll(y => y.Date <= DateTime.Today || y.Date > DateTime.Today.AddDays(5)));
​
                // Output the results
                OutputResults(locations);
            }
            catch (Exception ex)
            {
                // TODO: Log the error instead of just displaying the error message
                Console.WriteLine(ex.Message);
            }
        }
​
        #region Private Methods
        private static List<Location> GetLocations()
        {
            // This list is hard-coded for now
            // In a production environment, this would most likely come from a database or user input
            return new List<Location>
            {
                // .NET Fiddle doesn't support property initializers so initialize the Forecasts lists here
                new Location{ City = "Marlboro", State = "MA", ZIPCode = "01752", Forecasts = new List<Forecast>() },
                new Location{ City = "San Diego", State = "CA", ZIPCode = "92101", Forecasts = new List<Forecast>() },
                new Location{ City = "Cheyenne", State = "WY", ZIPCode = "82001", Forecasts = new List<Forecast>() },
                new Location{ City = "Anchorage", State = "AK", ZIPCode = "99501", Forecasts = new List<Forecast>() },
                new Location{ City = "Austin", State = "TX", ZIPCode = "73301", Forecasts = new List<Forecast>() },
                new Location{ City = "Orlando", State = "FL", ZIPCode = "32801", Forecasts = new List<Forecast>() },
                new Location{ City = "Seattle", State = "WA", ZIPCode = "98101", Forecasts = new List<Forecast>() },
                new Location{ City = "Cleveland", State = "OH", ZIPCode = "44101", Forecasts = new List<Forecast>() },
                new Location{ City = "Portland", State = "ME", ZIPCode = "04101", Forecasts = new List<Forecast>() },
                new Location{ City = "Honolulu", State = "HI", ZIPCode = "96801", Forecasts = new List<Forecast>() }
            };
        }
​
        private async static Task SetForecastsAsync(List<Location> locations)
        {
            List<Task> forecastTasks = new List<Task>();
​
            foreach (Location location in locations)
            {
                Task task = SetForecastAsync(location);
                forecastTasks.Add(task);
            }
​
            await Task.WhenAll(forecastTasks);
        }
​
        private static async Task SetForecastAsync(Location location)
        {
            try
            {
                // Get the API Url
                string url = GetWeatherApiUrl(location.ZIPCode);
​
                using (HttpClient client = GetHttpClient())
                {
                    // Get the forecast data
                    HttpResponseMessage response = await client.GetAsync(url).ConfigureAwait(false);
​
                    // If the response wasn't successful just return so we can attempt to get the forecast for the remaining locations
                    if (!response.IsSuccessStatusCode) return;
​
                    // Get the results, which will be in JSON format
                    string result = await response.Content.ReadAsStringAsync();
​
                    // Deserialize the JSON to a ForecastResponse object
                    ForecastResponse forecastResponse = JsonConvert.DeserializeObject<ForecastResponse>(result, new JsonSerializerSettings { MissingMemberHandling = MissingMemberHandling.Ignore, NullValueHandling = NullValueHandling.Ignore });
​
                    // Remove any records that have either an invalid date or temperature
                    // .NET Fiddle doesn't support the use of _ in a TryParse so create variables to store the data
                    DateTime date;
                    double temperature;
                    forecastResponse.Forecasts.RemoveAll(x => !DateTime.TryParse(x.ForecastDateTime, out date));
                    forecastResponse.Forecasts.RemoveAll(x => !double.TryParse(x.Main.Temperature, out temperature));
​
                    // Use GroupBy for deferred execution
                    //var forecasts = forecastResponse.Forecasts.GroupBy(x => x.ForecastDateTime.Date).Select(x => x).ToList();
                    
                    // Use ToLookup for immediate execution
                    var forecasts = forecastResponse.Forecasts.ToLookup(x => DateTime.Parse(x.ForecastDateTime).Date).Select(x => x).ToList();
​
                    foreach (var forecast in forecasts)
                    {
                        // Get the average temperature
                        double averageTemperature = forecast.Average(x => double.Parse(x.Main.Temperature));
​
                        // Set a boolean to indicate if there is any precipitation for the current day
                        // Based on the API documentation, there will be data in either the Rain or Snow node if rain or snow are expected
                        bool precipitation = forecast.Any(x => x.Rain != null || x.Snow != null);
​
                        // Add a new Forecast object which holds the forecast data for a specific day
                        location.Forecasts.Add(new Forecast { Date = forecast.Key, AverageTemperature = averageTemperature, PrecipitationExpected = precipitation });
                    }
                }
            }
            catch (Exception ex)
            {
                // TODO: Log the error instead of just displaying the error message
                Console.WriteLine(ex.Message);
            }
        }
​
        private static void OutputResults(List<Location> locations)
        {
            // Display the results
            foreach (Location location in locations)
            {
                // Format the results
                Console.WriteLine("______________________________");
                
                //Console.WriteLine($"{location.City}, {location.State} ({location.ZIPCode})");
                // .NET Fiddle doesn't support string interpolation so create the string the old fashioned way
                Console.WriteLine(location.City + ", " + location.State + " (" + location.ZIPCode + ")");
                
                Console.WriteLine();
​
                // If there was an error retrieving the forecast data for a location, display a message indicating this
                if (!location.Forecasts.Any())
                {
                    Console.WriteLine("Unable to retrieve forecast data.");
                }
                else
                {
                    Console.WriteLine("Date" + '\t' + '\t' + "Avg Temp(F)");
                    Console.WriteLine("------------------------------");
                    foreach (Forecast forecast in location.Forecasts)
                    {
                        Console.WriteLine(forecast.Date.ToShortDateString() + (forecast.PrecipitationExpected ? "*" : "") + '\t' + forecast.AverageTemperature.ToString("N2") + " F");
                    }
                }
                
                Console.WriteLine();
                Console.WriteLine();
            }
        }
​
        private static HttpClient GetHttpClient()
        {
            HttpClient httpClient = new HttpClient();
​
            httpClient.DefaultRequestHeaders.Clear();
            httpClient.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
​
            return httpClient;
        }
​
        private static string GetWeatherApiUrl(string ZIPCode)
        {
            try
            {
                // .NET Fiddle doesn't support string interpolation so create the string the old fashioned way
                //return $"https://api.openweathermap.org/data/2.5/forecast?APPID=18d9276a9325e3147ac2996320fa24f8&units=Imperial&zip={ZIPCode}";
                return "https://api.openweathermap.org/data/2.5/forecast?APPID=18d9276a9325e3147ac2996320fa24f8&units=Imperial&zip=" + ZIPCode;
            }
            catch (Exception ex)
            {
                // TODO: Log the error instead of just displaying the error message
                Console.WriteLine(ex.Message);
​
                // If we don't have a URL then we can't continue so throw an error
                throw;
            }
        }
        #endregion
    }
    
    class Location
    {
        public string City { get; set; }
        public string State { get; set; }
        public string ZIPCode { get; set; }
        public List<Forecast> Forecasts { get; set; }   // = new List<Forecast>();
    }
​
    class Forecast
    {
        public DateTime Date { get; set; }
        public double AverageTemperature { get; set; }
        public bool PrecipitationExpected { get; set; }
    }
​
    class ForecastResponse
    {
        // Internal parameter
        [JsonProperty("cod")]
        public string Cod { get; set; }
​
        // Internal parameter
        [JsonProperty("message")]
        public string Message { get; set; }
​
        // Number of lines returned by this API call
        [JsonProperty("cnt")]
        public string NumberOfDays { get; set; }
​
        [JsonProperty("list")]
        public List<Forecast> Forecasts { get; set; }
​
        [JsonProperty("city")]
        public CityData City { get; set; }
​
        public class Main
        {
            // Temperature. Unit Default: Kelvin, Metric: Celsius, Imperial: Fahrenheit.
            [JsonProperty("temp")]
            public string Temperature { get; set; }
​
            // Minimum temperature at the moment of calculation. This is deviation from 'temp' that is possible for large cities and megalopolises geographically expanded (use these parameter optionally). Unit Default: Kelvin, Metric: Celsius, Imperial: Fahrenheit.
            [JsonProperty("temp_min")]
            public string MinimumTemperature { get; set; }
​
            // Maximum temperature at the moment of calculation.This is deviation from 'temp' that is possible for large cities and megalopolises geographically expanded(use these parameter optionally). Unit Default: Kelvin, Metric: Celsius, Imperial: Fahrenheit.
            [JsonProperty("temp_max")]
            public string MaximumTemperature { get; set; }
​
            // Atmospheric pressure on the sea level by default, hPa
            [JsonProperty("pressure")]
            public string Pressure { get; set; }
​
            // Atmospheric pressure on the sea level, hPa
            [JsonProperty("sea_level")]
            public string SeaLevel { get; set; }
​
            // Atmospheric pressure on the ground level, hPa
            [JsonProperty("grnd_level")]
            public string GroundLevel { get; set; }
​
            // Humidity, %
            [JsonProperty("humidity")]
            public string Humidity { get; set; }
​
            // Internal parameter
            [JsonProperty("temp_kf")]
            public string KFTemperature { get; set; }
        }
​
        public class Weather
        {
            // Weather condition id
            [JsonProperty("id")]
            public string Id { get; set; }
​
            // Group of weather parameters (Rain, Snow, Extreme etc.)
            [JsonProperty("main")]
            public string Main { get; set; }
​
            // Weather condition within the group
            [JsonProperty("description")]
            public string Description { get; set; }
​
            // Weather icon id
            [JsonProperty("icon")]
            public string Icon { get; set; }
        }
​
        public class Clouds
        {
            // Cloudiness, %
            [JsonProperty("all")]
            public string Cloudiness { get; set; }
        }
​
        public class Wind
        {
            // Wind speed. Unit Default: meter/sec, Metric: meter/sec, Imperial: miles/hour.
            [JsonProperty("speed")]
            public string Speed { get; set; }
​
            // Wind direction, degrees (meteorological)
            [JsonProperty("deg")]
            public string WindDirection { get; set; }
        }
​
        public class Precipitation
        {
            // Volume for last 3 hours, mm
            [JsonProperty("3h")]
            public string VolumeForLast3Hours { get; set; }
        }
​
        public class Sys
        {
            [JsonProperty("pod")]
            public string Pod { get; set; }
        }
​
        public class Forecast
        {
            // Time of data forecasted, unix, UTC
            [JsonProperty("dt")]
            public string ForecastTime { get; set; }
​
            [JsonProperty("main")]
            public Main Main { get; set; }
​
            [JsonProperty("weather")]
            public List<Weather> Weather { get; set; }
​
            [JsonProperty("clouds")]
            public Clouds Clouds { get; set; }
​
            [JsonProperty("wind")]
            public Wind Wind { get; set; }
​
            [JsonProperty("rain")]
            public Precipitation Rain { get; set; }
​
            [JsonProperty("snow")]
            public Precipitation Snow { get; set; }
​
            [JsonProperty("sys")]
            public Sys Sys { get; set; }
​
            // Data/time of calculation, UTC
            [JsonProperty("dt_txt")]
            public string ForecastDateTime { get; set; }
        }
​
        public class Coordinates
        {
            // City geo location, latitude
            [JsonProperty("lat")]
            public string Latitude { get; set; }
​
            // City geo location, longitude
            [JsonProperty("lon")]
            public string Longitude { get; set; }
        }
​
        public class CityData
        {
            // City name
            [JsonProperty("name")]
            public string Name { get; set; }
​
            [JsonProperty("coord")]
            public Coordinates Coordinates { get; set; }
​
            // Country code (GB, JP etc.)
            [JsonProperty("country")]
            public string Country { get; set; }
​
            // Shift in seconds from UTC
            [JsonProperty("timezone")]
            public string TimeZone { get; set; }
​
            [JsonProperty("sunrise")]
            public string Sunrise { get; set; }
​
            [JsonProperty("sunset")]
            public string Sunset { get; set; }
        }
    }
}
​

View IL Code