DxDataGrid<T>.RowInsertingAsync Event

@inject MyApp.Data.WeatherForecastService ForecastService
@using MyApp.Data

<DxDataGrid DataAsync="@ForecastService.GetForecastAsync" 
            RowInsertingAsync="@OnRowInserting"
            InitNewRow="@OnInitNewRow">
    <DxDataGridCommandColumn />
    <DxDataGridDateEditColumn Field=@nameof(WeatherForecast.Date) />
    <DxDataGridSpinEditColumn Field="@nameof(WeatherForecast.TemperatureC)" 
                              Caption="@("Temp. (\x2103)")" />
    <DxDataGridColumn Field=@nameof(WeatherForecast.TemperatureF) Caption="Temp. (F)" />
</DxDataGrid>

@code {
    async Task OnRowInserting(IDictionary<string, object> newValue) {
        await ForecastService.Insert(newValue);
    }

    Task OnInitNewRow(Dictionary<string, object> values) {
        values.Add("Date", DateTime.Now);
        values.Add("TemperatureC", 13);
        return Task.CompletedTask;
    }
}

using System;

namespace MyApp.Data {
    public class WeatherForecast {
        public DateTime Date { get; set; }
        public int TemperatureC { get; set; }
        public int TemperatureF => 32 + (int)(TemperatureC / 0.5556);
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

namespace MyApp.Data {
    public class WeatherForecastService {

        private List<WeatherForecast> CreateForecast() {
            var rng = new Random();
            DateTime startDate = DateTime.Now;

            return Enumerable.Range(1, 15).Select(index => new WeatherForecast {
                Date = startDate.AddDays(index),
                TemperatureC = rng.Next(-15, 20)
            }).ToList();
        }

        private List<WeatherForecast> Forecasts { get; set; }

        public WeatherForecastService() {
            Forecasts = CreateForecast();
        }

        public Task<IEnumerable<WeatherForecast>> GetForecastAsync(CancellationToken ct = default) {
            return Task.FromResult(Forecasts.AsEnumerable());
        }

        WeatherForecast[] UpdateInternal(WeatherForecast dataItem, IDictionary<string, object> newValue) {
            foreach (var field in newValue.Keys) {
                switch (field) {
                    case nameof(dataItem.Date):
                        dataItem.Date = (DateTime)newValue[field];
                        break;
                    case nameof(dataItem.TemperatureC):
                        dataItem.TemperatureC = (int)newValue[field];
                        break;
                }
            }
            return Forecasts.ToArray();
        }

        public Task<WeatherForecast[]> Update(WeatherForecast dataItem, IDictionary<string, object> newValue) {
            return Task.FromResult(UpdateInternal(dataItem, newValue));
        }

        WeatherForecast[] InsertInternal(IDictionary<string, object> newValue) {
            var dataItem = new WeatherForecast();
            Update(dataItem, newValue);
            Forecasts.Insert(0, dataItem);
            return Forecasts.ToArray();
        }

        public Task<WeatherForecast[]> Insert(IDictionary<string, object> newValue) {
            return Task.FromResult(InsertInternal(newValue));
        }
    }
}

public class Startup {
    // ...

    public void ConfigureServices(IServiceCollection services) {
        // ...
        services.AddSingleton<WeatherForecastService>();
    }

}