ListView

An item's content. Without it, ItemText, ItemDescription and ItemIcon draw a row.

The default row's text. Defaults to the item's string form.

The default row's muted second line, such as an email address or a date.

The default row's icon, at its start.

Names an item for screen readers, in its link or button. Defaults to ItemText, then the ItemKey.

Makes each item a link, such as to its details page. The whole item is clickable; links, buttons and fields inside it still work on their own.

The item for what the page is showing, such as the one whose details are beside the list: drawn as selected, and marked aria-current (on its link with ItemHref).

Content at the end of each item, after its text: icon buttons, a switch, a badge or a time. Its controls work on their own above the item's link. Name each for its item, such as "Star report.pdf"; keep it to one or two, and put the rest in ItemMenu. On a narrow item they go under its text, at the end.

With ItemActions or ItemMenu, Enter in another field of the form submits it with no button's name or value, rather than pressing the first item's button.

Each item's menu, of MenuItems, opened by a ⋯ button at the item's end, named "Actions for" and the item's label. Items that link or post work on static pages and with JavaScript off. When the fragment writes nothing for an item (an @if around its items), that item has no ⋯ button.

Dims an item and leaves it without its link or button; its ItemActions and ItemMenu stay.

Orientation.Vertical (the default) lists the items top to bottom; Orientation.Horizontal side by side, wrapping when space runs out.

Lays the items out as cards in this many columns (2 to 6) on screens 640px and wider, such as a gallery of products. Phones get one. Defaults to 1, a list.

A height limit: the items scroll inside the list's box, with Load more after the last one. With DataPaging.LoadOnScroll, the next page loads as the last item scrolls into view.

Draws each item as a card, with space between them rather than lines, such as the tasks in a board's columns. Columns over 1 always draws cards.

A line between items in a list. Defaults to true.

A rounded border around the list. Defaults to false.

Item spacing and text size. Defaults to ControlSize.Md.

Names the list for screen readers, when the text around it doesn't.

Lets the user reorder the items: each gets a handle to drag, which also opens a menu (Move up, Move down, Move to top, Move to bottom) for moving without dragging; with DragWholeItem and an ItemMenu, the moves go in each item's ⋯ menu instead, and the item drags from anywhere. Needs an ItemKey and every item shown: no paging and no ItemsProvider. On interactive pages bind the order with @bind-Items; on static pages give it a Name inside a form and pass the posted ListOrder back as Order.

For a Reorderable list on a static page, the prefix of the fields it posts: {Name}.Keys and {Name}.Move, bound as a ListOrder. Without it, a static page shows no handles.

For a Reorderable list on a static page, what the form posted: the list shows the posted order with the move applied, and focuses the moved item's handle (or ⋯ button).

For a Reorderable list on a static page with script, posts the form after each move, for pages that save every move. Otherwise moves stay in the page until the form is submitted. With JavaScript off, each move from an item's menu posts anyway.

For a Reorderable list, lets a drag start anywhere on an item, not only on its handle: with a mouse after a small move, on touch after a long press (so a swipe still scrolls the page). Links, buttons and fields in the item keep their presses; the item's own link (ItemHref) or button (OnItemClick) still works on a click. With an ItemMenu there are no handles: each item's ⋯ menu ends with a Move submenu (Move up, Move down, Move to top, Move to bottom); without one, the handle stays as the menu of moves.

Makes the list a zone of the DropZoneGroup<T> around it: it shows the group's items whose zone is this one, and items move here from the group's other zones. Name each zone with AriaLabel, which also names it in the menu of moves.

For a Zone, which items may move here from other zones, such as t => t.Reviewed.

For a Zone, how many items it holds at most; a full zone takes no more from the others.

The items. A list is paged in memory; an IQueryable (such as an EF Core query) is paged by the database.

Loads the items yourself, in place of Items: the request has the range (and in a Table the sort, the filter and the columns as fields), so request.ToResultAsync(query, ...) or request.Apply(query) does the work. An exception it throws shows "Couldn't load the rows." with Retry (and is logged); a request that was canceled is ignored.

Items per page. Leave it out to show every item.

Sizes to choose from in a "Rows per page" menu in the footer, such as new[] { 10, 25, 50 }. The URL carries the choice (?size=25); only these sizes are accepted from it. PageSize is the default (the first option when not set).

The page, from 1. Binding it (@bind-Page) on an interactive page keeps it in the component instead of the URL. Set it back to 1 when your filters change.

How it moves through its pages when it has a PageSize: numbered pages (DataPaging.Pages, the default, which needs a total), or by cursor, with no total needed: First, Previous and Next (DataPaging.NextPrevious), a "Load more" button after the items (DataPaging.LoadMore, ListView only), or loading as the last item comes into view (DataPaging.LoadOnScroll).

The "Load more" button's text, such as "Load earlier". Defaults to "Load more".

The cursor of the page shown when paging by cursor (Paging); null for the first page. Binding it (@bind-Cursor) on an interactive page keeps it in the component instead of the URL; Page is then the page's position.

Prefix for its query-string keys, so several can share a page: QueryPrefix="orders-" uses ?orders-page= (and a Table's ?orders-sort=).

Shown when there are no items. Defaults to EmptyText.

The text when there are no items. Defaults to "No items".

Shown in place of "Couldn't load the rows." when loading fails, before the Retry button.

A unique, stable key for each item, such as its id. Selection posts and binds these keys. Defaults to the item's string form.

Shows it as loading: items dim, or placeholders show while there are none. Set automatically while an ItemsProvider loads on interactive pages.

Whether items can be selected: one (a radio button on each) or several (a checkbox on each). Inside a form, the selected items post their ItemKey under SelectionName; bind Selection to follow them.

The form field name the selection posts under, read back as a Selection with [SupplyParameterFromForm(Name = ...)]. Defaults to "{QueryPrefix}selected": give two selectable views in one form a QueryPrefix (or a name) each.

The selected items: keys on any page, or every item matching the filter except some. On a static page pass back the posted one. Selecting all that match is cleared when the filter or search changes.

Whether an item can be selected; others show a disabled, unchecked box, and selecting the page or a range leaves them out. "Select all" (every matching item) can't know this rule: leave them out of the query you apply the Selection to.

What the select-all checkbox selects: the items on this page, or every item the filters match, on any page. Those aren't loaded, so act on them with Selection.Apply. With virtual rows, SelectAllMode.Page reaches only the rows drawn.

Actions on the selection, in a bar above the items, disabled until something is selected (on a DataGrid with a toolbar, the bar takes the toolbar's place while something is). Submit buttons in the surrounding form post the selection. A link can't be disabled, so it stays live. Without these there's no bar.

The select-all checkbox's name for screen readers. Defaults to "Select all rows".

The start of each item checkbox's name for screen readers, before the item's label. Defaults to "Select".

Makes each item a button that runs this, on interactive pages. Items with an ItemHref are links instead.

Runs before a move changes the list, on interactive pages: save it here, or set Cancel to keep the item where it was. A dragged item stays where it was dropped while this runs, for up to 3 seconds; moves made meanwhile are ignored.

Loads the items again, such as after an edit. With DataPaging.LoadMore it starts over from the page the list began at, dropping the pages added since.