Bind Blazor Grid to Server Mode Data Sources

• Apr 01, 2026
• 14 minutes to read

In Blazor Server applications, you can bind the DevExpress Blazor Grid component to Server Mode data sources. These data sources are designed to reduce memory consumption when working with large data collections.

When bound to a Server Mode data source, the Grid loads data in small portions on demand (instead of the entire dataset). The component delegates all data shaping operations to underlying services (EF Core, XPO, and so on). These services process data more efficiently and enhance overall performance.

You can run the following example to compare in-memory data binding and Server Mode data loading strategies: Server Mode Data Processing

Data Source Types

The Grid includes two types of Server Mode data sources:

Server Mode Data Source

A synchronous data source that locks UI and does not respond to user actions while data is retrieved.

Instant Feedback Data Source

An asynchronous data source that loads data in a background thread and does not freeze the UI. The Grid displays skeletons and data load indicators while data is retrieved.

The following table lists cross-platform Server Mode data sources compatible with the Blazor Grid:

Data Access Technology	Server Mode Data Source	Instant Feedback Data Source
Entity Framework Core	EntityServerModeSource	EntityInstantFeedbackSource
XPO	XPServerCollectionSource XPServerModeView	XPInstantFeedbackSource XPInstantFeedbackView
Parallel LINQ	PLinqServerModeSource	PLinqInstantFeedbackSource
OData	ODataServerModeSource	ODataInstantFeedbackSource

How to Use Server Mode

Follow these steps to use a Server Mode data source in the Grid:

1. Add a reference to a data source namespace (for instance, DevExpress.Data.Linq for EF Core data sources).
2. Create a data source instance and configure its parameters.
3. Bind the data source instance to the Grid’s Data parameter.
4. Implement the IDisposable interface on the Razor page (use the @implements directive). Within the page’s Dispose method, check the data source instance for null and dispose of it.

The following sections contain code samples for different data access technologies.

Bind to Data using Entity Framework Core

For the EntityInstantFeedbackSource, you must specify the following data source parameters:

KeyExpression

Identifies the key property name in the entity model. If the database does not contain the primary key, you cannot use this database as a Server Mode data source.

QueryableSource

Defines a queryable data source from an EF Core data context (for instance, DbSet<T>).

The following example binds the Grid to an EntityInstantFeedbackSource:

Razor

@using InstantFeedback.Models;
@using Microsoft.EntityFrameworkCore
@using DevExpress.Data.Linq
@inject IDbContextFactory<NorthwindContext> NorthwindContextFactory
@implements IDisposable

<DxGrid Data="InstantFeedbackSource"
        KeyFieldName="OrderId">
    <Columns>
        <DxGridDataColumn FieldName="ShipName" />
        <DxGridDataColumn FieldName="ShipCity" />
        <DxGridDataColumn FieldName="ShipCountry" />
        <DxGridDataColumn FieldName="Freight" />
        <DxGridDataColumn FieldName="OrderDate" />
        <DxGridDataColumn FieldName="ShippedDate" />
    </Columns>
</DxGrid>
@code {
    EntityInstantFeedbackSource InstantFeedbackSource { get; set; }
    NorthwindContext Northwind { get; set; }

    protected override void OnInitialized() {
        Northwind = NorthwindContextFactory.CreateDbContext();
        InstantFeedbackSource = new EntityInstantFeedbackSource(e => {
            e.KeyExpression = "OrderId";
            e.QueryableSource = Northwind.Orders;
        });
    }
    public void Dispose() {
        InstantFeedbackSource?.Dispose();
        Northwind?.Dispose();
    }
}

Invoice

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

namespace InstantFeedback.Models {
    public partial class Order {
        public int OrderId { get; set; }

        [Required]
        public string ShipName { get; set; }

        [Required]
        public string ShipCity { get; set; }

        [Required]
        public string ShipCountry { get; set; }

        public decimal? Freight { get; set; }

        [Range(typeof(DateTime), "1/1/2010", "1/1/2024",
        ErrorMessage = "OrderDate must be between {1:d} and {2:d}")]
        public DateTime? OrderDate { get; set; }

        [Range(typeof(DateTime), "1/1/2010", "1/1/2024",
        ErrorMessage = "ShippedDate must be between {1:d} and {2:d}")]
        public DateTime? ShippedDate { get; set; }
    }
}

NorthwindContext

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

namespace InstantFeedback.Models;
public partial class NorthwindContext : DbContext {
    public NorthwindContext() {}
    public NorthwindContext(DbContextOptions<NorthwindContext> options) : base(options) {}
    public virtual DbSet<Order> Orders { get; set; }
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) {
    }
    protected override void OnModelCreating(ModelBuilder modelBuilder) {
        modelBuilder.HasAnnotation("Relational:Collation", "SQL_Latin1_General_CP1_CI_AS");
        modelBuilder.Entity<Order>(entity => {
            entity.HasIndex(e => e.OrderDate, "OrderDate");
            entity.HasIndex(e => e.ShippedDate, "ShippedDate");
            entity.Property(e => e.OrderId).HasColumnName("OrderID");
            entity.Property(e => e.Freight)
                .HasColumnType("money")
                .HasDefaultValueSql("((0))");
            entity.Property(e => e.OrderDate).HasColumnType("datetime");
            entity.Property(e => e.ShipCity).HasMaxLength(15);
            entity.Property(e => e.ShipCountry).HasMaxLength(15);
            entity.Property(e => e.ShipName).HasMaxLength(40);
            entity.Property(e => e.ShippedDate).HasColumnType("datetime");
        });
        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("Data Source=" + dbPath);
});

Run Demo: Grid - Large Dataset (Server Mode) Read Tutorial: Bind to Data with Entity Framework Core View Example: Bind to an Instant Feedback Data Source and Enable Edit Operations

Bind to Data using OData

The ODataInstantFeedbackSource includes the following mandatory settings:

KeyExpression

Specifies the key property name. To specify multiple columns of a composite key, pass a comma-separated or semicolon-separated list of key column names to this property.

GetSource

Handle this event to supply a queryable source connected to an OData service.

The following code snippet binds the Grid to an ODataInstantFeedbackSource and activates edit operations:

Razor

@using InstantFeedback.Models
@using DevExpress.Data.ODataLinq
@implements IDisposable

<DxGrid EditMode="GridEditMode.EditRow"
        Data="ODataSource"
        KeyFieldName="Product_ID"
        EditModelSaving="OnEditModelSaving"
        DataItemDeleting="OnDataItemDeleting">
    <Columns>
        <DxGridCommandColumn />
        <DxGridDataColumn FieldName="Product_ID" Caption="ID" />
        <DxGridDataColumn FieldName="Product_Name" Caption="Product Name" />
        <DxGridDataColumn FieldName="Product_Cost" Caption="Unit Price" DisplayFormat="c" />
        <DxGridDataColumn FieldName="Product_Category" Caption="Category" />
    </Columns>
</DxGrid>

@code {
    ODataInstantFeedbackSource ODataSource { get; set; }

    protected override void OnInitialized() {
        ODataSource = new ODataInstantFeedbackSource();
        ODataSource.KeyExpression = "Product_ID";
        ODataSource.GetSource += (sender, e) => e.Query = new ProductsContext().Products;
    }

    async Task OnEditModelSaving(GridEditModelSavingEventArgs e) {
        var product = (Product)e.EditModel;
        var context = new ProductsContext();
        if (e.IsNew) {
            context.AddObject("Products", product);
        } else {
            context.AttachTo("Products", product);
            context.UpdateObject(product);
        }
        await Task.Run(() => context.SaveChanges());
    }

    async Task OnDataItemDeleting(GridDataItemDeletingEventArgs e) {
        var id = (int)e.Grid.GetDataItemValue(e.DataItem, "Product_ID");
        var context = new ProductsContext();
        var product = new Product { Product_ID = id };
        context.AttachTo("Products", product);
        context.DeleteObject(product);
        await Task.Run(() => context.SaveChanges());
    }

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

Product

using Microsoft.OData.Client;

namespace InstantFeedback.Models {
    [Key("Product_ID")]
    public class Product {
        public int Product_ID { get; set; }
        public string? Product_Name { get; set; }
        public DateTime Product_Production_Start { get; set; }
        public bool Product_Available { get; set; }
        public int Product_Current_Inventory { get; set; }
        public double Product_Cost { get; set; }
        public double Product_Sale_Price { get; set; }
        public double Product_Retail_Price { get; set; }
        public double Product_Consumer_Rating { get; set; }
        public string? Product_Category { get; set; }
    }
}

ProductsContext

using Microsoft.OData.Client;

namespace InstantFeedback.Models {
    public class ProductsContext : DataServiceContext {
        public ProductsContext() : base(new Uri("https://localhost:5006/odata")) {
            MergeOption = MergeOption.OverwriteChanges;
        }

        public DataServiceQuery<Product> Products => CreateQuery<Product>("Products");
    }
}

Controller

using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.OData.Deltas;
using Microsoft.AspNetCore.OData.Query;
using Microsoft.AspNetCore.OData.Routing.Controllers;
using ODataServer.Models;

namespace ODataServer.Controllers {
    public class ProductsController : ODataController {
        [EnableQuery]
        public ActionResult<IEnumerable<Product>> Get() {
            return Ok(SampleData.Products);
        }

        public ActionResult Post([FromBody] Product product) {
            product.Product_ID = SampleData.Products.Count > 0
                ? SampleData.Products.Max(p => p.Product_ID) + 1
                : 1;
            SampleData.Products.Add(product);
            return Created(product);
        }

        public ActionResult Patch(int key, [FromBody] Delta<Product> delta) {
            var product = SampleData.Products.FirstOrDefault(p => p.Product_ID == key);
            if (product == null)
                return NotFound();
            delta.Patch(product);
            return Updated(product);
        }

        public ActionResult Put(int key, [FromBody] Product product) {
            var existing = SampleData.Products.FirstOrDefault(p => p.Product_ID == key);
            if (existing == null)
                return NotFound();
            var index = SampleData.Products.IndexOf(existing);
            product.Product_ID = key;
            SampleData.Products[index] = product;
            return Updated(product);
        }

        public ActionResult Delete(int key) {
            var product = SampleData.Products.FirstOrDefault(p => p.Product_ID == key);
            if (product == null)
                return NotFound();
            SampleData.Products.Remove(product);
            return NoContent();
        }
    }
}

SampleData

namespace ODataServer.Models {
    static class SampleData {
        public static List<Product> Products = [
            new Product {
                Product_ID = 1,
                Product_Name = "HD Video Player",
                Product_Production_Start = new DateTime(2013, 10, 7, 16, 0, 0),
                Product_Available = true,
                Product_Current_Inventory = 225,
                Product_Cost = 110.00,
                Product_Sale_Price = 220.00,
                Product_Retail_Price = 330.00,
                Product_Consumer_Rating = 4,
                Product_Category = "Video Players"
            },
            new Product {
                Product_ID = 2,
                Product_Name = "SuperHD Video Player",
                Product_Production_Start = new DateTime(2013, 12, 1, 0, 30, 0),
                Product_Available = true,
                Product_Current_Inventory = 150,
                Product_Cost = 175.00,
                Product_Sale_Price = 275.00,
                Product_Retail_Price = 400.00,
                Product_Consumer_Rating = 4,
                Product_Category = "Video Players"
            },
            new Product {
                Product_ID = 3,
                Product_Name = "SuperPlasma 50",
                Product_Production_Start = new DateTime(2005, 1, 10, 12, 45, 0),
                Product_Available = false,
                Product_Current_Inventory = 0,
                Product_Cost = 1100.00,
                Product_Sale_Price = 1800.00,
                Product_Retail_Price = 2400.00,
                Product_Consumer_Rating = 4.5,
                Product_Category = "Televisions"
            },
            new Product {
                Product_ID = 4,
                Product_Name = "SuperLED 50",
                Product_Production_Start = new DateTime(2011, 10, 30, 8, 30, 0),
                Product_Available = true,
                Product_Current_Inventory = 77,
                Product_Cost = 775.00,
                Product_Sale_Price = 1100.00,
                Product_Retail_Price = 1600.00,
                Product_Consumer_Rating = 5,
                Product_Category = "Televisions"
            },
            new Product {
                Product_ID = 5,
                Product_Name = "SuperLED 42",
                Product_Production_Start = new DateTime(2012, 9, 15, 8, 0, 0),
                Product_Available = true,
                Product_Current_Inventory = 445,
                Product_Cost = 675.00,
                Product_Sale_Price = 1050.00,
                Product_Retail_Price = 1450.00,
                Product_Consumer_Rating = 5,
                Product_Category = "Televisions"
            }
        ];
    }
}

Bind to Data using XPO

You must configure the following parameters for the XPInstantFeedbackSource:

DisplayableProperties

Lists semicolon-separated property names available for data binding.

ResolveSession

Handle this event to supply the XPInstantFeedbackSource with a Session connected to your data store.

DismissSession

Handle this event to dispose of the Session created in the ResolveSession event handler.

The following code snippet binds the Grid to an XPInstantFeedbackSource and activates edit operations:

Razor

@using DevExpress.Xpo;
@inject CustomerService CustomerService
@inject IDataLayer DataLayer
@implements IDisposable

<DxGrid Data="@instantFeedbackSource"
        KeyFieldName="Oid"
        EditMode="GridEditMode.EditRow"
        CustomizeEditModel="Grid_CustomizeEditModel"
        EditModelSaving="Grid_EditModelSaving"
        DataItemDeleting="Grid_DataItemDeleting">
    <Columns>
        <DxGridCommandColumn Width="110px" />
        <DxGridDataColumn Width="100px" FieldName="@nameof(Customer.Oid)" Caption="ID" ReadOnly="true" />
        <DxGridDataColumn FieldName="@nameof(Customer.FirstName)" />
        <DxGridDataColumn FieldName="@nameof(Customer.LastName)" />
    </Columns>
</DxGrid>

@code {

    XPInstantFeedbackSource instantFeedbackSource;
    string properties = $"{nameof(Customer.Oid)};{nameof(Customer.FirstName)};{nameof(Customer.LastName)}";

    protected override Task OnInitializedAsync() {
        instantFeedbackSource = new XPInstantFeedbackSource(typeof(Customer));
        instantFeedbackSource.DisplayableProperties = properties;
        instantFeedbackSource.ResolveSession += InstantFeedbackSource_ResolveSession;
        instantFeedbackSource.DismissSession += InstantFeedbackSource_DismissSession;
        return Task.CompletedTask;
    }

    void InstantFeedbackSource_ResolveSession(object sender, ResolveSessionEventArgs e) {
        e.Session = new Session(DataLayer);
    }

    void InstantFeedbackSource_DismissSession(object sender, ResolveSessionEventArgs e) {
        IDisposable session = e.Session as IDisposable;
        if (session != null)
            session.Dispose();
    }
    void Grid_CustomizeEditModel(GridCustomizeEditModelEventArgs e) {
        var customer = CustomerService.CreateObject();
        e.EditModel = customer;
        if (e.DataItem != null) {
            customer.Oid = (int)e.Grid.GetDataItemValue(e.DataItem, nameof(Customer.Oid));
            customer.FirstName = (string)e.Grid.GetDataItemValue(e.DataItem, nameof(Customer.FirstName));
            customer.LastName = (string)e.Grid.GetDataItemValue(e.DataItem, nameof(Customer.LastName));
        }
    }
    async void Grid_EditModelSaving(GridEditModelSavingEventArgs e) {
        Customer customer = null;
        customer = (Customer)e.EditModel;
        var customerChanges = GetCustomerChanges(customer);
        if (e.IsNew) {
            await CustomerService.Add(customerChanges);
        } else {
            await CustomerService.Update(customer.Oid, customerChanges);
        }
    }
    async void Grid_DataItemDeleting(GridDataItemDeletingEventArgs e) {
        var oid = (int)e.Grid.GetDataItemValue(e.DataItem, nameof(Customer.Oid));
        await CustomerService.Delete(oid);
    }
    private Dictionary<string, object> GetCustomerChanges(Customer obj) {
        var propertiesMapping = new Dictionary<string, object> {
            { nameof(Customer.FirstName), obj.FirstName },
            { nameof(Customer.LastName), obj.LastName },
        };
        return propertiesMapping;
    }
    public void Dispose() {
        if (instantFeedbackSource != null) {
            instantFeedbackSource.ResolveSession -= InstantFeedbackSource_ResolveSession;
            instantFeedbackSource.DismissSession -= InstantFeedbackSource_DismissSession;
            instantFeedbackSource.Dispose();
        }
    }
}

Customer

using DevExpress.Xpo;

namespace BlazorServerSideApplication {
    public class Customer : XPObject {
        public Customer(Session session) : base(session) { }
        private string fFirstName;
        public string FirstName {
            get { return fFirstName; }
            set { SetPropertyValue(nameof(FirstName), ref fFirstName, value); }
        }

        private string fLastName;
        public string LastName {
            get { return fLastName; }
            set { SetPropertyValue(nameof(LastName), ref fLastName, value); }
        }
        [PersistentAlias("Concat([FirstName], ' ', [LastName])")]
        public string ContactName {
            get { return (string)EvaluateAlias(nameof(ContactName)); }
        }
        [Association("CustomerOrders")]
        public XPCollection<Order> Orders {
            get { return GetCollection<Order>(nameof(Orders)); }
        }
    }
}

CustomerService

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Threading.Tasks;
using DevExpress.Data.ODataLinq.Helpers;
using DevExpress.Xpo;

namespace BlazorServerSideApplication.Services {

    public abstract class BaseService {
        readonly IDataLayer dataLayer;
        protected readonly UnitOfWork readUnitOfWork;
        public BaseService(IDataLayer dataLayer, UnitOfWork readUnitOfWork) {
            this.dataLayer = dataLayer;
            this.readUnitOfWork = readUnitOfWork;
        }
        protected UnitOfWork CreateModificationUnitOfWork() {
            return new UnitOfWork(dataLayer);
        }
    }

    public class CustomerService : BaseService {
        public CustomerService(IDataLayer dataLayer, UnitOfWork modificationUnitOfWork)
            : base(dataLayer, modificationUnitOfWork) { }
        public Task<IQueryable<Customer>> Get() {
            var query = (IQueryable<Customer>)readUnitOfWork.Query<Customer>();
            return Task.FromResult(query);
        }
        public Customer CreateObject() {
           return new Customer(CreateModificationUnitOfWork());
        }
        public async Task Add(Dictionary<string, object> values) {
            using(UnitOfWork uow = CreateModificationUnitOfWork()) {
                Customer newCustomer = new Customer(uow);
                PopulateObjectHelper.PopulateObject(uow, newCustomer, values);
                await uow.CommitChangesAsync();
            }
        }
        public async Task Update(int oid, Dictionary<string, object> values) {
            using(UnitOfWork uow = CreateModificationUnitOfWork()) {
                Customer customer = uow.GetObjectByKey<Customer>(oid);
                PopulateObjectHelper.PopulateObject(uow, customer, values);
                await uow.CommitChangesAsync();
            }
        }
        public async Task Delete(int oid) {
            using(UnitOfWork uow = CreateModificationUnitOfWork()) {
                var customer = await uow.GetObjectByKeyAsync<Customer>(oid);
                customer.Delete();
                await uow.CommitChangesAsync();
            }
        }
    }
}

Helpers

using DevExpress.Xpo;
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;
using System.Collections.Generic;
using System.ComponentModel;

namespace BlazorServerSideApplication {
    public static class ApplicationBuilderExtensions {
        public static IApplicationBuilder UseXpoDemoData(this IApplicationBuilder app) {
            using(var scope = app.ApplicationServices.GetService<IServiceScopeFactory>().CreateScope()) {
                UnitOfWork uow = scope.ServiceProvider.GetService<UnitOfWork>();
                DemoDataHelper.Seed(uow);
            }
            return app;
        }
    }

    public static class PopulateObjectHelper {
        public static void PopulateObject(Session session, XPBaseObject @object, Dictionary<string, object> values) {
            PropertyDescriptorCollection pdc = session.GetProperties(@object.ClassInfo);
            foreach(KeyValuePair<string, object> kvp in values) {
                object value = kvp.Value;
                if(value is XPBaseObject xpobj)
                    value = session.GetObjectByKey(xpobj.ClassInfo, session.GetKeyValue(xpobj));
                PropertyDescriptor prop = pdc.Find(kvp.Key, false);
                if(prop != null)
                    prop.SetValue(@object, value);
            }
        }
    }
}

Program.cs

// ...
builder.Services.AddScoped<CustomerService>();
builder.Services.AddXpoDefaultDataLayer(ServiceLifetime.Singleton, dl => dl
    .UseConnectionString(Configuration.GetConnectionString("InMemoryDataStore"))
    .UseThreadSafeDataLayer(true)
    .UseConnectionPool(false) // Remove this line if you use a database server like SQL Server, Oracle, PostgreSql, etc.
    .UseAutoCreationOption(DevExpress.Xpo.DB.AutoCreateOption.DatabaseAndSchema) // Remove this line if the database already exists
    .UseEntityTypes(typeof(Customer), typeof(Order)) // Pass all your persistent object types to this method.
);
builder.Services.AddXpoDefaultUnitOfWork();

DemoDataHelper

using DevExpress.Xpo;
using System;
using System.Collections.Generic;
using System.Linq;

namespace BlazorServerSideApplication {
    public static class DemoDataHelper {
        private static readonly string[] firstNames = new string[] {
            "Peter", "Ryan", "Richard", "Tom", "Mark", "Steve",
            "Jimmy", "Jeffrey", "Andrew", "Dave", "Bert", "Mike",
            "Ray", "Paul", "Brad", "Carl", "Jerry" };
        private static readonly string[] lastNames = new string[] {
            "Dolan", "Fischer", "Hamlett", "Hamilton", "Lee",
            "Lewis", "McClain", "Miller", "Murrel", "Parkins",
            "Roller", "Shipman", "Bailey", "Barnes", "Lucas", "Campbell" };
        private static readonly string[] productNames = new string[] {
            "Chai", "Chang", "Aniseed Syrup", "Chef Anton's Cajun Seasoning",
            "Chef Anton's Gumbo Mix", "Grandma's Boysenberry Spread",
            "Uncle Bob's Organic Dried Pears", "Northwoods Cranberry Sauce",
            "Mishi Kobe Niku", "Ikura", "Queso Cabrales", "Queso Manchego La Pastora",
            "Konbu", "Tofu", "Genen Shouyu", "Pavlova", "Alice Mutton",
            "Carnarvon Tigers", "Teatime Chocolate Biscuits",
            "Sir Rodney's Marmalade", "Sir Rodney's Scones",
            "Gustaf's Knäckebröd", "Tunnbröd", "Guaraná Fantástica",
            "NuNuCa Nuß-Nougat-Creme", "Gumbär Gummibärchen",
            "Schoggi Schokolade", "Rössle Sauerkraut", "Thüringer Rostbratwurst",
            "Nord-Ost Matjeshering", "Gorgonzola Telino", "Mascarpone Fabioli",
            "Geitost", "Sasquatch Ale", "Steeleye Stout", "Inlagd Sill",
            "Gravad lax", "Côte de Blaye", "Chartreuse verte",
            "Boston Crab Meat", "Jack's New England Clam Chowder",
            "Singaporean Hokkien Fried Mee", "Ipoh Coffee",
            "Gula Malacca", "Rogede sild", "Spegesild", "Zaanse koeken",
            "Chocolade", "Maxilaku", "Valkoinen suklaa", "Manjimup Dried Apples",
            "Filo Mix", "Perth Pasties", "Tourtière", "Pâté chinois",
            "Gnocchi di nonna Alice", "Ravioli Angelo", "Escargots de Bourgogne",
            "Raclette Courdavault", "Camembert Pierrot", "Sirop d'érable",
            "Tarte au sucre", "Vegie-spread", "Wimmers gute Semmelknödel",
            "Louisiana Fiery Hot Pepper Sauce", "Louisiana Hot Spiced Okra",
            "Laughing Lumberjack Lager", "Scottish Longbreads",
            "Gudbrandsdalsost", "Outback Lager", "Flotemysost",
            "Mozzarella di Giovanni", "Röd Kaviar", "Longlife Tofu",
            "Rhönbräu Klosterbier", "Lakkalikööri", "Original Frankfurter grüne Soße" };
        private static readonly Random Random = new Random(0);

        public static void Seed(UnitOfWork uow) {
            int ordersCnt = uow.Query<Order>().Count();
            if(ordersCnt > 0)
                return;
            var names = new KeyValuePair<string, string>[firstNames.Length * lastNames.Length];
            for(int i = 0; i < firstNames.Length * lastNames.Length; i++) {
                int j = Random.Next(i + 1);
                names[i] = names[j];
                names[j] = new KeyValuePair<string, string>(firstNames[i / lastNames.Length], lastNames[i % lastNames.Length]);
            }
            foreach(var t in names) {
                CreateCustomer(uow, t.Key, t.Value);
            }
            uow.CommitChanges();
        }

        private static void CreateCustomer(UnitOfWork uow, string firstName, string lastName) {
            Customer customer = new Customer(uow);
            customer.FirstName = firstName;
            customer.LastName = lastName;
            for(int i = 0; i < 10; i++) {
                Order order = new Order(uow);
                order.ProductName = productNames[Random.Next(productNames.Length)];
                order.OrderDate = new DateTime(Random.Next(2014, 2024), Random.Next(1, 12), Random.Next(1, 28));
                order.Freight = Random.Next(1000) / 100m;
                order.Customer = customer;
            }
        }
    }
}

Limitations

Note the following Grid-related limitations when using Server Mode and Instant Feedback data sources:

• These data sources do not work in Blazor WebAssembly applications.
• Cell editing is unavailable.
• Custom sorting/grouping is unavailable.
• Search, filter, sorting, and grouping against display text are unavailable.
• Custom summary calculation is limited. The CustomSummary event fires only once when the SummaryStage event argument is set to Finalize.
• Unbound columns are unavailable if their values are populated via the UnboundColumnData event. Create unbound columns using UnboundExpression instead.
• AllPages mode of the Select All checkbox is unavaialble.
• Sorting, filtering, or data grouping during select/deselect all processing cancels the operation.
• To call the SetFocusedDataItemAsync method, you must specify the KeyFieldName/KeyFieldNames property value.
• A data source can be reloaded automatically when it requests a portion of data from a database and finds an inconsistency (for instance, if an external process made changes to the database).
• Actions that affect all Grid rows (for instance, expand all groups) can cause performance issues and UI freezes.
• A second call to the SelectAllAsync/DeselectAllAsync method cancels the operation initiated by a previously called method.

Instant Feedback data sources also have the following specifics:

• An Instant Feedback data source loads data asynchronously in small portions (instead of the entire dataset). To ensure correct data operations, you must:

  • Call WaitForDataLoadAsync before methods that read Grid data (GetRowValue, GetTotalSummaryValue, and so on).
  • Call WaitForRemoteSourceRowLoadAsync before methods that accept a row visible index as a parameter (SelectRow, StartEditRowAsync, and so on).

• If a data source’s AreSourceRowsThreadSafe option is set to false (the default value), you cannot cast a data item and use the {DataItem.FieldName} notation. Call the GetDataItemValue(Object, String) method to obtain the data item’s field value. Note that this method does not provide access to the data source object and you cannot handle events or call methods related to the object.