protected override async Task OnInitAsync()
{
_sendHandle = SignalService.Register <string>("Send", addItem);
await SignalService.Connect();
forecasts = await ForecastService.GetForecastAsync(DateTime.Now);
}
private async Task ExportResult(string format, DataSourceLoadOptionsBase dataOptions, HttpContext context)
{
XtraReport report = new XtraReport();
dataOptions.Skip = 0;
dataOptions.Take = 0;
var loadedData = DataSourceLoader.Load(await weatherForecastService.GetForecastAsync(), dataOptions);
report.DataSource = loadedData.data.Cast <WeatherForecast>();
ReportHelper.CreateReport(report, new string[] { "TemperatureC", "TemperatureF", "Summary", "Date" });
await new TaskFactory().StartNew(() => {
report.CreateDocument();
using (MemoryStream fs = new MemoryStream()) {
if (format == pdf)
{
report.ExportToPdf(fs);
}
else if (format == xlsx)
{
report.ExportToXlsx(fs);
}
else if (format == docx)
{
report.ExportToDocx(fs);
}
context.Response.Clear();
context.Response.Headers.Append("Content-Type", "application/" + format);
context.Response.Headers.Append("Content-Transfer-Encoding", "binary");
context.Response.Headers.Append("Content-Disposition", "attachment; filename=ExportedDocument." + format);
context.Response.Body.WriteAsync(fs.ToArray(), 0, fs.ToArray().Length);
return(context.Response.CompleteAsync());
}
});
}
protected override async Task OnInitializedAsync()
{
WeatherForecastModel.UseAnnotations = true;
weatherForecasts = await WeatherForecastService.GetForecastAsync(DateTime.Now);
WeatherForecastModel.Rows = weatherForecasts;
}
public async Task GetForecastAsyncTest()
{
WeatherForecastService service = new WeatherForecastService();
var result = await service.GetForecastAsync(DateTime.Now);
Assert.NotNull(result);
Assert.IsNotEmpty(result);
}
public IEnumerable <WeatherForecast> Get()
{
DateTime today = DateTime.Now;
return(service.GetForecastAsync(today)
.Result
.AsEnumerable());
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
var forecast = await _weatherForecastService.GetForecastAsync(DateTime.Now);
_weatherCache.Update(forecast);
// Wait ten seconds after starting before continuous updates
await Task.Delay(10000, stoppingToken);
while (!stoppingToken.IsCancellationRequested)
{
await Task.Delay(100, stoppingToken);
forecast = await _weatherForecastService.GetForecastAsync(DateTime.Now);
_weatherCache.Update(forecast);
}
}
public async Task <WeatherForecastState> UpdateAsync(
ILiveState <Local, WeatherForecastState> liveState, CancellationToken cancellationToken)
{
var local = liveState.Local;
var forecasts = await WeatherForecastService.GetForecastAsync(local.StartDate, cancellationToken);
return(new WeatherForecastState()
{
Forecasts = forecasts
});
}
public async Task <WeatherForecast[]> Get()
{
_logger.Here(l => l.Entering());
var forecasts = await _forecastService.GetForecastAsync(DateTime.Now);
_logger.Here(l => l.LogInformation("CorrelationId can be obtained with CorrelationProvider: {@0}", CorrelationProvider.CurrentCorrelationProvider?.GetCorrelationId()));
_logger.Here(l => l.Exiting(forecasts));
return(forecasts);
}
protected override async Task OnInitializedAsync()
{
Dictionary <string, string> keyValuePairs = new Dictionary <string, string>()
{
["Test1"] = "Tanvir",
["Test2"] = "Ahmad",
["Test"] = null
};
_navigationManager.NavigateTo("counter", keyValuePairs);
Forecasts = await _weatherForecastService.GetForecastAsync(DateTime.Now);
}
static async Task Main()
{
var service = new WeatherForecastService();
var forecasts = await service.GetForecastAsync(DateTime.Now);
Console.WriteLine("Date\tTemp. (C)\tTemp. (F)\tSummary");
foreach (var f in forecasts)
{
Console.WriteLine($"{f.Date.ToShortDateString()}\t" +
$"{f.TemperatureC}\t{f.TemperatureF}\t{f.Summary}");
}
}
public async Task HandleFetchDataAction(FetchDataAction action, IDispatcher dispatcher)
{
if (action == null)
{
throw new ArgumentNullException(nameof(action));
}
if (dispatcher == null)
{
throw new ArgumentNullException(nameof(dispatcher));
}
var forecasts = await _service.GetForecastAsync(DateTime.Now);
//var forecasts = await _http.GetFromJsonAsync<WeatherForecast[]>("WeatherForecast");
dispatcher.Dispatch(new FetchDataResultAction(forecasts));
}
public async Task Test_GetForecast_City_Async()
{
// Arrange
var service = new WeatherForecastService();
const double latitude = 59.334415;
const double longitude = 18.110103;
var city = new City {
X = latitude, Y = longitude, Name = "Stockholm"
};
// Act
var forecast = await service.GetForecastAsync(city);
// Assert
Assert.AreEqual(forecast.CityName, city.Name);
}
public void WeatherServiceTest()
{
var service = new WeatherForecastService();
var result = service.GetForecastAsync(DateTime.Now).Result;
var i = 1;
foreach (var item in result)
{
var date = DateTime.Now;
date = date.AddDays(i);
Assert.IsType <WeatherForecast>(item);
Assert.InRange(item.TemperatureC, -20, 55);
Assert.InRange(item.TemperatureF, -4, 131);
Assert.Contains(item.Summary, _list);
Assert.Equal(date.DayOfYear, item.Date.DayOfYear);
i++;
}
}
public void GetForecastAsyncTest()
{
string[] Summaries = new[]
{
"Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
};
var w = new WeatherForecastService();
var result = w.GetForecastAsync(DateTime.Today).Result;
result.Should().NotBeEmpty();
result.Should().HaveCount(5);
result.Should().BeAssignableTo <WeatherForecast[]>();
foreach (var item in result)
{
item.Should().NotBeNull();
item.Should().BeAssignableTo <WeatherForecast>();
item.TemperatureF.Should().Be(32 + ( int )(item.TemperatureC / 0.5556));
Summaries.ToList().Contains(item.Summary).Should().BeTrue();
}
}
private async void Initialize()
{
var weatherItems = await weatherForecastService.GetForecastAsync(DateTime.Now);
forecastList.AddRange(weatherItems);
}
protected override async Task OnInitializedAsync()
{
forecasts = (await ForecastService.GetForecastAsync(DateTime.Now)).AsQueryable();
ItemsCount = forecasts.Count();
}
public async Task <ActionResult <IEnumerable <WeatherForecast> > > Get()
{
return(await _weatherForecastService.GetForecastAsync(DateTime.Now));
}
protected override async Task OnInitializedAsync()
{
Forecasts = await _weatherForecastService.GetForecastAsync(DateTime.Now);
}
protected override async Task WhenAsync()
{
_forecasts = await _weatherForecastService.GetForecastAsync(
new DateTime(2020, 04, 20));
}
protected async override Task HandleAsync(FetchAction action, IStore store)
{
WeatherForecast[] data = await weatherForecastService.GetForecastAsync(action.Date);
store.Dispatch(new CompleteFetchAction(data));
}
public async Task <WeatherForecast[]> GetForecastAsync(DateTime startDate)
{
return(await WeatherForecastService.GetForecastAsync(startDate));
}
public async Task <WeatherForecast[]> GetWeatherForecastDataAsync()
{
return(await _forecastService.GetForecastAsync(DateTime.Now));
}
private async Task <WeatherForecast[]> LoadWeatherForecastsAsync()
{
return(await _weatherForecastService.GetForecastAsync(DateTime.Now));
}
public async Task HandleFetchDataAction(FetchDataAction action, IDispatcher dispatcher)
{
var forecasts = await WeatherForecastService.GetForecastAsync(DateTime.Now);
dispatcher.Dispatch(new FetchDataResultAction(forecasts));
}