In-Memory Data Binding in Blazor Grid

• Apr 01, 2026
• 12 minutes to read

You can bind the DevExpress Blazor Grid component directly to a data collection:

1. Assign a C# field to the Data property.
2. Populate this field with data in the OnInitialized/OnInitializedAsync lifecycle method. The following data types are supported:
   • Array
   • DataTable
   • IEnumerable<T>, including ICollection<T> and List<T>
3. To display data within the Grid, declare DxGridDataColumn objects in the Columns tags.
4. Use the DxGridDataColumn.FieldName property to assign data fields to columns. Note that each data column’s FieldName property value must be unique.

The following code snippet binds the Grid to a weather forecast list:

Razor

@inject WeatherForecastService ForecastService

<DxGrid Data="@Data">
    <Columns>
        <DxGridDataColumn FieldName="Date" DisplayFormat="D" />
        <DxGridDataColumn FieldName="TemperatureC" Caption="@("Temp. (\x2103)")" Width="120px" />
        <DxGridDataColumn FieldName="TemperatureF" Caption="@("Temp. (\x2109)")" Width="120px" />
        <DxGridDataColumn FieldName="Forecast" />
        <DxGridDataColumn FieldName="CloudCover" />
    </Columns>
</DxGrid>

@code {
    object Data { get; set; }

    protected override async Task OnInitializedAsync() {
        Data = await ForecastService.GetForecastAsync();
    }
}

WeatherForecast

using System;

public class WeatherForecast {
    public DateTime Date { get; set; }
    public int TemperatureC { get; set; }
    public double TemperatureF => Math.Round((TemperatureC * 1.8 + 32), 2);
    public string Forecast { get; set; }
    public string CloudCover { get; set; }
    public bool Precipitation { get; set; }
}

WeatherForecastService

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

public class WeatherForecastService {
    private List<WeatherForecast> Forecast { get; set; }

    private static string[] CloudCover = new[] {
        "Sunny", "Partly cloudy", "Cloudy", "Storm"
    };

    Tuple<int, string>[] ConditionsForForecast = new Tuple<int, string>[] {
        Tuple.Create(22, "Hot"),
        Tuple.Create(13, "Warm"),
        Tuple.Create(0, "Cold"),
        Tuple.Create(-10, "Freezing")
    };

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

    private List<WeatherForecast> CreateForecast() {
        var rng = new Random();
        DateTime startDate = DateTime.Now;
        return Enumerable.Range(1, 15).Select(index => {
            var temperatureC = rng.Next(-10, 30);
            return new WeatherForecast {
                Date = startDate.AddDays(index),
                TemperatureC = temperatureC,
                CloudCover = CloudCover[rng.Next(0, 4)],
                Precipitation = Convert.ToBoolean(rng.Next(0, 2)),
                Forecast = ConditionsForForecast.First(c => c.Item1 <= temperatureC).Item2
            };
        }).ToList();
    }
    // ...

    public Task<WeatherForecast[]> GetForecastAsync(CancellationToken ct = default) {
        return Task.FromResult(Forecast.ToArray());
    }

Program.cs

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

Run Demo: Grid - Data Binding Run Demo: Grid - Asynchronous Data Binding

Limitations

In this data binding mode, the Grid stores all data records in memory. All data processing operations, such as sorting, grouping, and filtering, are executed in the Blazor application. This increases memory consumption and can affect performance when the dataset is large.

For large datasets, use a Server Mode or Queryable data source instead.

Bind to a DataTable

You can bind the Grid component to a DataTable object. Generate/obtain such an object and pass it to the Grid’s Data property:

@using System.Data

<DxGrid Data="@dataTable">
    <Columns>
        <DxGridDataColumn FieldName="Text" Caption="Text Value" />
        <DxGridDataColumn FieldName="Number" Caption="Numeric Value" />
        <DxGridDataColumn FieldName="Date" DisplayFormat="D" Caption="Date-Time Value" />
    </Columns>
</DxGrid>

@code {
    public DataTable dataTable;

    protected override void OnInitialized() {
        dataTable = GetDataTable();
    }
    DataTable GetDataTable() {
        var dataTable = new DataTable();
        dataTable.Columns.Add("Text", typeof(string));
        dataTable.Columns.Add("Number", typeof(int));
        dataTable.Columns.Add("Date", typeof(DateTime));
        for (int i = 0; i < 3; i++) {
            dataTable.Rows.Add(new object[] { $"Text {i}", i, DateTime.Now.AddDays(-i) });
        }
        return dataTable;
    }
}

View Example: Bind to DataTable

Bind to a Remote Dataset

You can load data from a remote data source and assign it directly to the DxGrid.Data property. The following example uses Entity Framework Core to bind the Grid component to a database and enable data editing:

Razor

@using Microsoft.EntityFrameworkCore
@inject IDbContextFactory<NorthwindContext> NorthwindContextFactory
@implements IDisposable

<DxGrid Data="Data"
        EditMode="GridEditMode.EditRow"
        EditModelSaving="OnEditModelSaving"
        DataItemDeleting="OnDataItemDeleting"
        KeyFieldName="EmployeeId">
    <Columns>
        <DxGridCommandColumn />
        <DxGridDataColumn FieldName="FirstName" />
        <DxGridDataColumn FieldName="LastName" />
        <DxGridDataColumn FieldName="Title" />
        <DxGridDataColumn FieldName="HireDate" />
    </Columns>
</DxGrid>

@code {
    IEnumerable<Employee> Data { get; set; }
    NorthwindContext Northwind { get; set; }

    protected override async Task OnInitializedAsync() {
        Northwind = NorthwindContextFactory.CreateDbContext();
        Data = await Northwind.Employees.ToListAsync();
    }

    async Task OnEditModelSaving(GridEditModelSavingEventArgs e) {
        var editModel = (Employee)e.EditModel;
        // Apply changes to the data item
        if (!e.IsNew)
            e.CopyChangesToDataItem();
        else {
            editModel.EmployeeId = Data.Max(x => x.EmployeeId) + 1;
            await Northwind.AddAsync(editModel);
        }
        // Post changes to the database.
        await Northwind.SaveChangesAsync();
        // Reload the entire Grid.
        Data = await Northwind.Employees.ToListAsync();
    }

    async Task OnDataItemDeleting(GridDataItemDeletingEventArgs e) {
        // Re-query a data item from the database.
        var dataItem = Northwind.Employees.Find((e.DataItem as Employee).EmployeeId);
        if (dataItem != null) {
            // Remove the data item from the database.
            Northwind.Remove(dataItem);
            await Northwind.SaveChangesAsync();
            // Reload the entire Grid.
            Data = await Northwind.Employees.ToListAsync();
        }
    }

    public void Dispose() {
        Northwind?.Dispose();
    }
}

Employee

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;

namespace BindToData.Models;

public partial class Employee {
    public int EmployeeId { get; set; }
    [Required]
    public string LastName { get; set; } = null!;
    [Required]
    public string FirstName { get; set; } = null!;
    public string? Title { get; set; }
    public string? TitleOfCourtesy { get; set; }
    public DateTime? BirthDate { get; set; }
    public DateTime? HireDate { get; set; }
    public string? Address { get; set; }
    public string? City { get; set; }
    public string? Region { get; set; }
    public string? PostalCode { get; set; }
    public string? Country { get; set; }
    public string? HomePhone { get; set; }
    public string? Extension { get; set; }
    public byte[]? Photo { get; set; }
    public string? Notes { get; set; }
    public int? ReportsTo { get; set; }
    public string? PhotoPath { get; set; }
    public virtual ICollection<Employee> InverseReportsToNavigation { get; } = new List<Employee>();
    public virtual Employee? ReportsToNavigation { get; set; }
}

NorthwindContext

using System;
using System.Collections.Generic;
using Microsoft.EntityFrameworkCore;

namespace BindToData.Models;

public partial class NorthwindContext : DbContext {
    public NorthwindContext() {}
    public NorthwindContext(DbContextOptions<NorthwindContext> options) : base(options) {}
    public virtual DbSet<Employee> Employees { get; set; }
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) {
    }
    protected override void OnModelCreating(ModelBuilder modelBuilder) {
        modelBuilder.UseCollation("SQL_Latin1_General_CP1_CI_AS");
        modelBuilder.Entity<Employee>(entity => {
            entity.HasIndex(e => e.LastName, "LastName");
            entity.HasIndex(e => e.PostalCode, "PostalCode");
            entity.Property(e => e.EmployeeId).HasColumnName("EmployeeID");
            entity.Property(e => e.Address).HasMaxLength(60);
            entity.Property(e => e.BirthDate).HasColumnType("datetime");
            entity.Property(e => e.City).HasMaxLength(15);
            entity.Property(e => e.Country).HasMaxLength(15);
            entity.Property(e => e.Extension).HasMaxLength(4);
            entity.Property(e => e.FirstName).HasMaxLength(10);
            entity.Property(e => e.HireDate).HasColumnType("datetime");
            entity.Property(e => e.HomePhone).HasMaxLength(24);
            entity.Property(e => e.LastName).HasMaxLength(20);
            entity.Property(e => e.Notes).HasColumnType("ntext");
            entity.Property(e => e.Photo).HasColumnType("image");
            entity.Property(e => e.PhotoPath).HasMaxLength(255);
            entity.Property(e => e.PostalCode).HasMaxLength(10);
            entity.Property(e => e.Region).HasMaxLength(15);
            entity.Property(e => e.Title).HasMaxLength(30);
            entity.Property(e => e.TitleOfCourtesy).HasMaxLength(25);
            entity.HasOne(d => d.ReportsToNavigation).WithMany(p => p.InverseReportsToNavigation)
                .HasForeignKey(d => d.ReportsTo)
                .HasConstraintName("FK_Employees_Employees");
        });
        OnModelCreatingPartial(modelBuilder);
    }
    partial void OnModelCreatingPartial(ModelBuilder modelBuilder);
}

Program.cs

// ...
using Microsoft.EntityFrameworkCore;
// ...
builder.Services.AddDbContextFactory<NorthwindContext>((sp, options) => {
    var env = sp.GetRequiredService<IWebHostEnvironment>();
    var dbPath = Path.Combine(env.ContentRootPath, "Northwind.db");
    options.UseSqlite("DataSource=" + dbPath);
});

View Example: Bind the Grid to Data with Entity Framework Core

Bind to a Web API Service

You can use an HttpClient to obtain data from a remote service. Save data to a collection and assign it to the Grid component.

The following code snippet binds the Grid to a Web API service and allows users to create, modify, and delete records:

Razor

@using System.Net.Http
@using System.Net.Http.Json
@inject HttpClient Http
@inject WebServicePath wsp
@using DataGridWithWebApiService.Data

<DxGrid Data=@categories
        PagerVisible="false"
        EditModelSaving="OnEditModelSaving"
        DataItemDeleting="OnDataItemDeleting"
        EditMode="GridEditMode.EditRow">
    <Columns>
        <DxGridCommandColumn Width="150px" />
        <DxGridDataColumn FieldName=@nameof(Categories.CategoryId) />
        <DxGridDataColumn FieldName=@nameof(Categories.CategoryName) />
        <DxGridDataColumn FieldName=@nameof(Categories.Description) />
    </Columns>
</DxGrid>

@code {
    List<Categories>? categories;
    string path = "https://localhost:44340/api/";

    protected override async Task OnInitializedAsync() {
        categories = await Http.GetFromJsonAsync<List<Categories>>(path + "categories");
    }
    async Task OnEditModelSaving(GridEditModelSavingEventArgs e) {
        if (e.IsNew) {
            Categories newCategory = new Categories();
            SetNewValues(newCategory, (Categories)e.EditModel);
            await Http.PostAsJsonAsync<Categories>(path + "categories/", newCategory);
            categories = await Http.GetFromJsonAsync<List<Categories>>(path + "categories");
        }
        else {
            var dataItem = (Categories)e.DataItem;
            SetNewValues(dataItem, (Categories)e.EditModel);
            await Http.PutAsJsonAsync(path + "categories/" + dataItem.CategoryId, dataItem);
            categories = await Http.GetFromJsonAsync<List<Categories>>(path + "categories");
        }
    }
    async Task OnDataItemDeleting(GridDataItemDeletingEventArgs e) {
        await Http.DeleteAsync(path + "categories/" + ((Categories)e.DataItem).CategoryId);
        categories = await Http.GetFromJsonAsync<List<Categories>>(path + "categories");
    }
    private void SetNewValues(Categories dataItem, Categories newValues) {
        dataItem.CategoryName = newValues.CategoryName;
        dataItem.Description = newValues.Description;
    }
}

Categories

class Categories {
    public int CategoryId { get; set; }
    public string? CategoryName { get; set; }
    public string? Description { get; set; }
}

Controller

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using MyTestWebService.Models;
using Microsoft.EntityFrameworkCore;

namespace MyTestWebService.Controllers {
    [Route("api/[controller]")]
    [ApiController]
    public class CategoriesController : ControllerBase {
        private readonly NWINDContext _context;
        public CategoriesController(NWINDContext context) {
            _context = context;
        }
        [HttpGet]
        public async Task<ActionResult<IEnumerable<Categories>>> Get() {
            return await _context.Categories.ToListAsync();
        }

        // GET api/<controller>/5
        [HttpGet("{id}")]
        public async Task<ActionResult<Categories>> Get(int id) {
            var todoItem = await _context.Categories.FindAsync(id);
            if (todoItem == null) {
                return NotFound();
            }
            return todoItem;
        }

        // POST api/<controller>
        [HttpPost]
        public async Task<ActionResult<Categories>> Post(Categories item) {
            _context.Categories.Add(item);
            await _context.SaveChangesAsync();
            return CreatedAtAction(nameof(Get), new { id = item.CategoryId }, item);
        }

        // PUT api/<controller>/5
        [HttpPut("{id}")]
        public async Task<IActionResult> Put(int id, Categories item) {
            if (id != item.CategoryId) {
                return BadRequest();
            }
            _context.Entry(item).State = EntityState.Modified;
            await _context.SaveChangesAsync();
            return NoContent();
        }

        // DELETE api/<controller>/5
        [HttpDelete("{id}")]
        public async Task<IActionResult> Delete(int id) {
            var todoItem = await _context.Categories.FindAsync(id);
            if (todoItem == null) {
                return NotFound();
            }
            _context.Categories.Remove(todoItem);
            await _context.SaveChangesAsync();
            return NoContent();
        }
    }
}

NWINDContext

using System;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata;

public partial class NWINDContext : DbContext{
    public NWINDContext() {}

    public NWINDContext(DbContextOptions<NWINDContext> options) : base(options){}
    public virtual DbSet<Categories> Categories { get; set; }
    public virtual DbSet<Products> Products { get; set; }
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) {
    }
    protected override void OnModelCreating(ModelBuilder modelBuilder) {
        modelBuilder.Entity<Categories>(entity => {
            entity.HasKey(e => e.CategoryId);
            entity.Property(e => e.CategoryId).HasColumnName("CategoryID");
            entity.Property(e => e.CategoryName)
                .IsRequired()
                .HasMaxLength(15);
            entity.Property(e => e.Description).HasColumnType("ntext");
        });
        modelBuilder.Entity<Products>(entity => {
            entity.HasKey(e => e.ProductId);
            entity.Property(e => e.ProductId).HasColumnName("ProductID");
            entity.Property(e => e.CategoryId).HasColumnName("CategoryID");
            entity.Property(e => e.Ean13)
                .HasColumnName("EAN13")
                .HasColumnType("text");
            entity.Property(e => e.ProductName)
                .IsRequired()
                .HasMaxLength(40);
            entity.Property(e => e.QuantityPerUnit).HasMaxLength(20);
            entity.Property(e => e.SupplierId).HasColumnName("SupplierID");
            entity.Property(e => e.UnitPrice).HasColumnType("smallmoney");
            entity.HasOne(d => d.Category)
                .WithMany(p => p.Products)
                .HasForeignKey(d => d.CategoryId)
                .HasConstraintName("FK_Products_Categories");
        });
        OnModelCreatingPartial(modelBuilder);
    }
    partial void OnModelCreatingPartial(ModelBuilder modelBuilder);
}

View Example: Bind to the Web API Service View Example: Display Error Messages from the Web API Service

Bind to Observable Data

You can bind the Grid to a data collection that implements the INotifyCollectionChanged or IBindingList interface. For instance, you can use standard ObservableCollection<T> or BindingList<T> objects.

These objects notify the Grid about collection changes such as add, remove, and refresh operations. To notify the Grid when a record value changes, each collection item must also implement INotifyPropertyChanged. The Grid then updates its data automatically.

Note

After you bind a dynamic data collection to the Grid, the collection sends notifications after each change separately. When you make a sequence of modifications (for instance, in a for loop), the Grid is re-rendered after each iteration.

The following sample binds the Grid to an ObservableCollection<T> and adds new items to this collection on button clicks. The INotifyCollectionChanged interface is not implemented because field values of existing items do not change.

Razor

@using System.Collections.ObjectModel

<DxButton Text="Add New Day"
          Click="(e) => AddNewForecast()" />

<p/>
<DxGrid Data="@WeatherForecastData">
    <Columns>
        <DxGridDataColumn FieldName="Date" DisplayFormat="D" />
        <DxGridDataColumn FieldName="TemperatureC" Caption="@("Temp. (\x2103)")" />
        <DxGridDataColumn FieldName="TemperatureF" Caption="@("Temp. (\x2109)")" />
    </Columns>
</DxGrid>

@code {
    int DayCount { get; set; } = 0;
    ObservableCollection<WeatherForecast> WeatherForecastData { get; set; }
    static readonly Random Rnd = new Random();

    protected override void OnInitialized() {
        WeatherForecastData = new ObservableCollection<WeatherForecast>();
        foreach (var date in Enumerable.Range(1, 5).Select(i => DateTime.Now.Date.AddDays(i))) {
            AddNewForecast();
        }
    }

    void AddNewForecast() {
        WeatherForecastData.Add(new WeatherForecast() {
            Date = DateTime.Now.Date.AddDays(++DayCount),
            TemperatureC = Rnd.Next(10, 20)
        });
    }
}

WeatherForecast

using System;

public class WeatherForecast {
    public DateTime Date { get; set; }
    public int TemperatureC { get; set; }
    public double TemperatureF => Math.Round((TemperatureC * 1.8 + 32), 2);
    public string Forecast { get; set; }
    public string CloudCover { get; set; }
    public bool Precipitation { get; set; }
}

Run Demo: Observable Data Collections

Bind to an ExpandoObject

You can bind the Blazor Grid component to an ExpandoObject collection and use user-defined schemas from external sources as data models (such as JSON files or NoSQL databases). This way, you can introduce CRUD (Create, Read, Update, Delete) operations when your data structure is not defined at compile time.

Follow the steps below to bind the DevExpress Blazor Grid to a dynamic ExpandoObject list and activate CRUD operations:

1. Create an ExpandoObject collection and populate it with initial data.
2. Add DxGrid to the page and bind it to the ExpandoObject list.
3. Implement a custom edit model in the CustomizeEditModel event handler.
4. Handle the EditModelSaving event to retrieve data from the custom edit model and update the ExpandoObject.
5. Handle the DataItemDeleting event to remove an item from the ExpandoObject collection.
6. Add a custom CellEditTemplate for all data columns. In a template, bind an inline editor to the ExpandoObject using IDictionary<string, object>.

The following example activates edit operations in a DxGrid bound to an ExpandoObject collection:

Razor

@using Expando.Services
@using System.Dynamic
@inject WeatherForecastService ForecastService

<DxGrid Data="@forecasts"
        CssClass="mw-1100"
        EditMode="GridEditMode.EditRow"
        EditModelSaving="Grid_EditModelSaving"
        DataItemDeleting="Grid_DataItemDeleting"
        CustomizeEditModel="Grid_CustomizeEditModel">
    <Columns>
        <DxGridCommandColumn />

        <DxGridDataColumn Caption="Date" FieldName="Date">
            <CellEditTemplate>
                @{
                    var editItem = (IDictionary<string, object>)context.EditModel;
                    var date = (DateOnly)editItem["Date"];
                }
                <DxDateEdit Date="@(date)"
                            DateChanged="@((DateOnly newVal) => editItem["Date"] = newVal)"
                            DateExpression="@(() => date)">
                </DxDateEdit>
            </CellEditTemplate>
        </DxGridDataColumn>
        <DxGridDataColumn Caption="Temperature °C" FieldName="TemperatureC">
            <CellEditTemplate>
                @{
                    var editItem = (IDictionary<string, object>)context.EditModel;
                    var temperature = (int)editItem["TemperatureC"];
                }
                <DxSpinEdit Value="@temperature"
                            ValueChanged="@((int newVal) => editItem["TemperatureC"] = newVal)"
                            ValueExpression="@(() => temperature)">
                </DxSpinEdit>
            </CellEditTemplate>
        </DxGridDataColumn>
        <DxGridDataColumn Caption="Summary" FieldName="Summary">
            <CellEditTemplate>
                @{
                    var editItem = (IDictionary<string, object>)context.EditModel;
                    var summary = (string)editItem["Summary"];
                }
                <DxTextBox Text="@summary"
                            TextChanged="@((string newVal) => editItem["Summary"] = newVal)"
                            TextExpression="@(() => summary)">
                </DxTextBox>
            </CellEditTemplate>
        </DxGridDataColumn>
    </Columns>
</DxGrid>

@code {
    private List<ExpandoObject>? forecasts;

    protected override async Task OnInitializedAsync() {
        forecasts = await ForecastService.GetForecastAsyncExpando(DateTime.Now);
    }

    private void Grid_CustomizeEditModel(GridCustomizeEditModelEventArgs e) {
        if (e.IsNew) {
            dynamic forecast = new ExpandoObject();
            forecast.Id = Guid.NewGuid();
            forecast.Date = DateOnly.FromDateTime(DateTime.Now.AddDays(1));
            forecast.TemperatureC = 0;
            forecast.Summary = "";
            e.EditModel = forecast;
        }
    }

    private async Task Grid_EditModelSaving(GridEditModelSavingEventArgs e) {
        if (e.IsNew) {
            forecasts.Add((ExpandoObject)e.EditModel);
        }
        else {
            dynamic editableForecast = (ExpandoObject)e.EditModel;
            dynamic originalForecast = forecasts
                .Cast<dynamic>()
                .First(s => (Guid)s.Id == (Guid)editableForecast.Id);
            originalForecast.Date = editableForecast.Date;
            originalForecast.TemperatureC = editableForecast.TemperatureC;
            originalForecast.Summary = editableForecast.Summary;
        }
    }

    private async Task Grid_DataItemDeleting(GridDataItemDeletingEventArgs e) {
        forecasts.Remove((ExpandoObject)e.DataItem);
    }
}

WeatherForecast

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

WeatherForecastService

using System.Dynamic;

public class WeatherForecastService {
    private static readonly string[] Summaries = [
        "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
    ];

    public Task<WeatherForecast[]> GetForecastAsync(DateTime startDate) {
        var rng = new Random();
        return Task.FromResult(Enumerable.Range(1, 20).Select(index => new WeatherForecast {
            Date = DateOnly.FromDateTime(startDate.AddDays(index)),
            TemperatureC = rng.Next(-20, 55),
            Summary = Summaries[rng.Next(Summaries.Length)]
        }).ToArray());
    }

    public async Task<List<ExpandoObject>> GetForecastAsyncExpando(DateTime startDate) {
        var weatherForecasts = await GetForecastAsync(DateTime.Now);
        List<ExpandoObject> dynamicList = [];
        foreach (WeatherForecast weatherForecast in weatherForecasts) {
            dynamic dynamicWeatherForecast = new ExpandoObject();
            dynamicWeatherForecast.Id = Guid.NewGuid();
            dynamicWeatherForecast.Date = weatherForecast.Date;
            dynamicWeatherForecast.TemperatureC = weatherForecast.TemperatureC;
            dynamicWeatherForecast.Summary = weatherForecast.Summary;
            dynamicList.Add(dynamicWeatherForecast);
        }
        return dynamicList;
    }
}

Program.cs

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

View Example: Bind to ExpandoObject