public IReadOnlyList<IGridSummaryItem> SummaryItems { get; }

@inject WeatherForecastService ForecastService

<DxGrid Data="@forecasts" 
        ShowGroupPanel="true"
        ContextMenus="GridContextMenus.GroupFooter"
        CustomizeContextMenu="OnCustomizeContextMenu">
    <Columns>
        <DxGridSelectionColumn />
        <DxGridDataColumn FieldName=@nameof(WeatherForecast.TemperatureC) Caption="Temp. (C)" />
        <DxGridDataColumn FieldName=@nameof(WeatherForecast.TemperatureF) Caption="Temp. (F)" />
        <DxGridDataColumn FieldName=@nameof(WeatherForecast.Summary) Caption="Summary" GroupIndex="0" />
        <DxGridDataColumn FieldName=@nameof(WeatherForecast.Date) DisplayFormat="dd/MM/yyyy" />
    </Columns>
    <GroupSummary>
        @foreach (var item in GroupSummaryItems) {
            <DxGridSummaryItem FieldName="@item.FieldName" FooterColumnName="@item.FieldName"
                               SummaryType="item.Type"
                               ValueDisplayFormat="@item.DisplayFormat"
                               @key="item" />
        }
    </GroupSummary>
</DxGrid>

@code {
    string[]? summaries;
    private List<WeatherForecast>? forecasts;
    IList<SummaryItem> GroupSummaryItems { get; set; }

    static readonly GridSummaryItemType[] SummaryTypes = Enum.GetValues<GridSummaryItemType>()
        .Where(s => s != GridSummaryItemType.None && s != GridSummaryItemType.Custom && s != GridSummaryItemType.Sum)
        .ToArray();
    bool IsStringColumn(string fieldName) => new[] { "Summary" }.Contains(fieldName);

    record SummaryItem(string FieldName, GridSummaryItemType Type) {
        public string DisplayFormat { get; init; }
    }

    protected override async Task OnInitializedAsync() {
        forecasts = await ForecastService.GetForecastAsync();
        summaries = ForecastService.Summaries;
        GroupSummaryItems = new List<SummaryItem>([
            new SummaryItem("TemperatureC", GridSummaryItemType.Count),
        ]);
    }

    void OnCustomizeContextMenu(GridCustomizeContextMenuEventArgs args) {
        IGridColumn column = null;
        IReadOnlyList<IGridSummaryItem> contextSummaryItems = null;
        IList<SummaryItem> summaryItemsCollection = null;

        if (args.Context is GridGroupFooterCommandContext groupFooterCommandContext) {
            column = groupFooterCommandContext.Column;
            contextSummaryItems = groupFooterCommandContext.SummaryItems;
            summaryItemsCollection = GroupSummaryItems;
        }
        if (column != null && column is IGridDataColumn dataColumn) {
            foreach (var summaryType in SummaryTypes) {
                var fieldName = dataColumn.FieldName;
                if (IsStringColumn(fieldName) && summaryType != GridSummaryItemType.Count)
                    continue;
                var existingItem = contextSummaryItems.FirstOrDefault(i => i.FieldName == fieldName && i.SummaryType == summaryType);
                var menuItem = args.Items.AddCustomItem(summaryType.ToString(), () => OnSummaryCommand(dataColumn, summaryType, summaryItemsCollection));
            }
        }
    }

    void OnSummaryCommand(IGridDataColumn dataColumn, GridSummaryItemType summaryType, IList<SummaryItem> summaryItemsCollection) {
        var fieldName = dataColumn.FieldName;
        var existingItem = summaryItemsCollection.FirstOrDefault(i => i.FieldName == fieldName && i.Type == summaryType);
        if (existingItem != null)
            summaryItemsCollection.Remove(existingItem);
        else
            summaryItemsCollection.Add(new SummaryItem(fieldName, summaryType) {
                    DisplayFormat = summaryType == GridSummaryItemType.Count ? null : dataColumn.DisplayFormat
                });
        StateHasChanged();
    }
}

using System;

public class WeatherForecast {
    public int ID { get; set; }
    public DateTime Date { get; set; }
    public int TemperatureC { get; set; }
    public int TemperatureF => 32 + (int)(TemperatureC / 0.5556);
    public string? Summary { get; set; }
}

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

public class WeatherForecastService {
    public readonly string[] Summaries = new[] {
        "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
    };
    private List<WeatherForecast>? Forecasts;
    public Task<List<WeatherForecast>> GetForecastAsync() {
        if (Forecasts == null) {
            var rnd = new Random();
            Forecasts = Enumerable.Range(1, 50).Select(index => new WeatherForecast {
                ID = index,
                Date = DateTime.Today.AddDays(index),
                TemperatureC = rnd.Next(-20, 55),
                Summary = Summaries[rnd.Next(Summaries.Length)]
            }).ToList();
        }
        return Task.FromResult(Forecasts);
    }
    public Task<List<WeatherForecast>> ChangeForecastAsync(WeatherForecast changed) {
        var originalForecast = Forecasts.FirstOrDefault(i => i.ID == changed.ID);
        if (originalForecast != null) {
            originalForecast.TemperatureC = changed.TemperatureC;
            originalForecast.Summary = changed.Summary;
            originalForecast.Date = changed.Date;
        } else {
            Forecasts.Add(changed);
        }
        return Task.FromResult(Forecasts);
    }
    public Task<List<WeatherForecast>> Remove(WeatherForecast forecast) {
        Forecasts.Remove(forecast);
        return Task.FromResult(Forecasts);
    }
}

// ...
builder.Services.AddSingleton<WeatherForecastService>();