# Компонент Paging View ASP.NET Core Tag Helper M SK1Part 2, PageSize)

<datetime class="hidden">2025-03-25T22:12</datetime>

<!--category-- ASP.NET Core, TagHelper, PagingTagHelper -->
# Введение

У рамках моєї постійної подорожі з допомогою мого помічника таґів я відокремив PageSize у свій власний помічник тагів. Це для того, щоб зробити помічнику таг більш гнучким і дозволити більше складних сценаріїв плагуM SK1

**Знову ж таки: МСК0 . Це всі роботи. "-", в прогресі . [до 0.9.0](https://www.nuget.org/packages/mostlylucid.pagingtaghelper#readme-body-tab) в момент написання, але використовувати на власній ризикі. Це' безкоштовно, але НЕ БЫТнє якості випуску IMHO M SK2 Я не маю [повні зразки](https://taghelpersample.mostlylucid.net/PageSizeWithHTMX) ще!)**

Подивіться [тут код для помічника ярлики](https://github.com/scottgal/mostlylucid.pagingtaghelper/blob/main/mostlylucid.pagingtaghelper/Components/PageSizeTagHelper.cs).

[TOC]

# Справка з тегом розміру сторінки

Як і в інших іменниках, це створено для використання-случай я часто стикаюсь зM SK1 як легко змінити розмір сторінки у списку результатів.
На перший погляд, це виглядає досить просто, але воно може стати TRICKY, як тільки ви додасте HTMX до суміші.

## Требування

Отже, для мого прикладу потреби були такі:

1. Дозволяє легке використання для тех-розробника ( якомога ширше конфігуроване за допомогою простої моделі сторінкиM SK1
2. Обновлення розміру сторінки за допомогою HTMX - означає, що це ' здатний відіслати назад *залишаючи всі параметри строку запиту*.
   Це важливо, бо дозволяє змінювати розмір сторінки, не втрачаючи будь-яких інших фільтрів, які вони використовували.
3. Вона має досить динамічний діапазон розмірів сторінок (включно з опцією

## Допомічник тагов

Маючи це на увазі, я спроектував TagHelper таким чином::

```html
<page-size
    hx-target="#list"
    hx-swap="innerHTML"
    model="Model">
    
</page-size>
<div id="list">
    <partial name="_ResultsList" model="Model"/>
</div>
```

Отже, в цьому випадку, знову ж таки, потрібна моя стандартна модель плагуна:

```csharp
public interface IPagingModel
{
    public int Page { get; set; }
    public int TotalItems { get; set; }
    public int PageSize { get; set; }

    public ViewType ViewType { get; set; }
    
    public string LinkUrl { get; set; }
}
```

що надає `Page`, `TotalItems`, `PageSize`, `ViewType` і `LinkUrl` для плагування.

Ви також можете визначити їх у формі атрибутів для моделі:

```html

<page-size
    hx-target="#list"
    hx-swap="innerHTML"
    total-items="100"
    page-size="10"
    view-type="DaisyAndTailwind">
</page-size>
```

Де `hx-target` ось мета для запросу HTMX і `hx-swap` є ціллю реагування.

В цьому випадку, it' використовуватиме задану `PageSize` і `TotalItems` і `ViewType` для відтворення виборця розміру сторінки.

## Дж.С. Шенаніґанс

На жаль, цього разу у мене була потреба, яку я не міг розв 'язати.
Щоб досягнути цього, у мене є два шматочки JS, які будуть завантажені в контроль залежно від того, як HTMX буде використано, а не

```csharp
@if (Model.UseHtmx)
{
@Html.HTMXPageSizeChange()
}
else
{
    @Html.PageSizeOnchangeSnippet()
}
```

Якщо HTMX вживається, він перетворює це на сторінку:

```javascript
(() => {
    if (window.__pageSizeListenerAdded) return;

    document.addEventListener('htmx:configRequest', event => {
        const { elt } = event.detail;
        if (elt?.matches('[name="pageSize"]')) {
            const params = new URLSearchParams(window.location.search);
            params.set('pageSize', elt.value); // This will update or add the pageSize param
            event.detail.parameters = Object.fromEntries(params.entries());
        }
    });
    window.__pageSizeListenerAdded = true;
})();
```

Це простий шматок JavaScript, який вводить параметри строку запиту в żądaння.

Іншими словами, якщо HTMX не включений, він відтворить це:

```javascript
(function attachPageSizeListener() {
    // Ensure we only attach once if this script is included multiple times
    if (window.__pageSizeListenerAttached) return;
    window.__pageSizeListenerAttached = true;

    // Wait for the DOM to be fully loaded
    document.addEventListener("DOMContentLoaded", () => {
        document.body.addEventListener("change", handlePageSizeChange);
    });

    function handlePageSizeChange(event) {
        // Check if the changed element is a page-size <select> inside .page-size-container
        const select = event.target.closest(".page-size-container select[name='pageSize']");
        if (!select) return;

        const container = select.closest(".page-size-container");
        if (!container) return;

        // Default to "true" if there's no .useHtmx input
        const useHtmx = container.querySelector("input.useHtmx")?.value === "true";
        if (useHtmx) {
            // If using HTMX, we do nothing—HTMX will handle the request
            return;
        }

        // Either use a linkUrl from the container or the current page URL
        const linkUrl = container.querySelector("input.linkUrl")?.value || window.location.href;
        const url = new URL(linkUrl, window.location.origin);

        // Copy existing query params from current location
        const existingParams = new URLSearchParams(window.location.search);
        for (const [key, value] of existingParams.entries()) {
            url.searchParams.set(key, value);
        }

        // If user picked the same pageSize as what's already in the URL, do nothing
        if (url.searchParams.get("pageSize") === select.value) {
            return;
        }

        // Update the pageSize param
        url.searchParams.set("pageSize", select.value);

        // Redirect
        window.location.href = url.toString();
    }
})();
```

Однією з змін, яку я зроблю, буде зміна назви zmienної 'flagM SK2 variable; `__pageSizeListenerAttached ` так як це' є надто типовим і я користуюся ним як для HTTP, так і для не HTMX

## Код

Само по собі допомічник теги досить простий, головний код просто заповнює декілька властивостей, а потім відображає вигляд компоненту.

```csharp
 public override async Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
    {
        // We want to render a <div> by default
        output.TagName = "div";

        // Remove any leftover attributes that we handle ourselves
        RemoveUnwantedAttributes(output);

        // Determine final PagerId
        var pagerId = PagerId ?? PageSizeModel?.PagerId ?? $"pager-{Guid.NewGuid():N}";
        // Assign ID to the outer div
        output.Attributes.SetAttribute("id", pagerId);
        // Build or fallback to a link URL
        var finalLinkUrl = BuildLinkUrl();
        if (string.IsNullOrEmpty(finalLinkUrl))
        {
            // If we can't build a URL, show a fallback message or short-circuit
            output.Content.SetHtmlContent(
                "<p style=\"color:red\">No valid link URL found for PageSize control.</p>");
            return;
        }

        var finalPageSize = PageSize ?? PageSizeModel?.PageSize ?? 10;
        // Clamp the page size to MaxPageSize

        var finalTotalItems = TotalItems ?? Model?.TotalItems ?? PageSizeModel?.TotalItems ?? 0;
        if (finalTotalItems == 0) throw new ArgumentNullException(nameof(finalTotalItems), "TotalItems is required");
        var maxPageSize = Math.Min(finalTotalItems, MaxPageSize);

        // Fallback to model's properties if not set
        var finalViewType = PageSizeModel?.ViewType ?? Model?.ViewType ?? ViewType;

        var pageSizeSteps = new int[] { 10, 25, 50, 75, 100, 125, 150, 200, 250, 500, 1000 };

        
        if (!string.IsNullOrEmpty(PageSizeSteps))
            pageSizeSteps = PageSizeSteps.Split(',').Select(s =>

            {
                if (int.TryParse(s, out var result))
                    return result;
                else
                {
                    throw new ArgumentException("Invalid page size step", nameof(PageSizeSteps));
                }
            }).ToArray();


        var pageSizes = CalculatePageSizes(finalTotalItems, maxPageSize, pageSizeSteps);

        var useHtmx = PageSizeModel?.UseHtmx ?? UseHtmx;
        var useLocalView = PageSizeModel?.UseLocalView ?? UseLocalView;

        // Acquire the IViewComponentHelper
        var viewComponentHelper = ViewContext.HttpContext.RequestServices
            .GetRequiredService<IViewComponentHelper>();
        ((IViewContextAware)viewComponentHelper).Contextualize(ViewContext);

        // Construct the PageSizeModel (if not provided) with final settings
        var pagerModel = new PageSizeModel
        {
            ViewType = finalViewType,
            UseLocalView = useLocalView,
            UseHtmx = useHtmx,
            PageSizes = pageSizes,
            PagerId = pagerId,
            Model = Model,
            LinkUrl = finalLinkUrl,
            MaxPageSize = maxPageSize,
            PageSize = finalPageSize,
            TotalItems = finalTotalItems
        };

        // Safely invoke the "PageSize" view component
        try
        {
            var result = await viewComponentHelper.InvokeAsync("PageSize", pagerModel);
            output.Content.SetHtmlContent(result);
        }
        catch (Exception ex)
        {
            // Optional: Log or display an error
            output.Content.SetHtmlContent(
                $"<p class=\"text-red-500\">Failed to render PageSize component: {ex.Message}</p>"
            );
        }
    }
```

Одне складне завдання - це правильно керувати `PageSizeSteps` властивість. Це список розмірів сторінок, відокремлений від кома, який пользователь може вибрати з . Або ви можете пройти в своїх власних кроках МSK2 Ви також можете визначити MaxPageSize, який є максимальною величиною сторінки, яку можна вибрати .

```csharp
    private List<int> CalculatePageSizes(int totalItems, int maxxPageSize, int[] pageSizeSteps)
    {
        var pageSizes = new List<int>();

        // 1. Include all fixed steps up to both TotalItems and MaxPageSize
        foreach (var step in pageSizeSteps)
        {
            if (step <= totalItems && step <= maxxPageSize)
                pageSizes.Add(step);
        }

        // 2. If TotalItems exceeds the largest fixed step, keep doubling
        int lastFixedStep = pageSizeSteps.Last();
        if (totalItems > lastFixedStep)
        {
            int next = lastFixedStep;
            while (next < totalItems && next < maxxPageSize)
            {
                next *= 2; // double the step
                if (next <= totalItems && next <= maxxPageSize)
                {
                    pageSizes.Add(next);
                }
            }
        }

        // 3. Include TotalItems if it's not already in the list
        if (totalItems <= maxxPageSize && !pageSizes.Contains(totalItems))
        {
            pageSizes.Add(totalItems);
        }

        pageSizes.Sort();

        return pageSizes;
    }

```

Як і для мого іншого помічника теги, я користуюсь шаблоном TagHelper->ViewComponent, щоб відтворити компонент widokуM SK1 Це дозволяє мені залишити помічник теги простим та складним, а також компонент widokа. Це також дозволяє вам змінювати погляди для різних переживань ; або навіть ввести свій власний погляд і використовувати його `use-local-view`).

```csharp

public class PageSizeViewComponent : ViewComponent
    {
        public IViewComponentResult Invoke(PageSizeModel model)
        {
            if(model.Model != null)
            {
                model.LinkUrl ??= model.Model.LinkUrl;
                
                if(model.Model is IPagingSearchModel searchModel)
                {
                    model.SearchTerm ??= searchModel.SearchTerm;
                }
            }
            
            var viewName = "Components/Pager/Default";

            var useLocalView = model.UseLocalView;

            return (useLocalView, model.ViewType) switch
            {
                (true, ViewType.Custom) when ViewExists(viewName) => View(viewName, model),
                (true, ViewType.Custom) when !ViewExists(viewName) => throw new ArgumentException("View not found: " + viewName),
                (false, ViewType.Bootstrap) => View("/Areas/Components/Views/PageSize/BootstrapView.cshtml", model),
                (false, ViewType.Plain) => View("/Areas/Components/Views/PageSize/PlainView.cshtml", model),
                (false, ViewType.TailwindAndDaisy) => View("/Areas/Components/Views/PageSize/Default.cshtml", model),
                _ => View("/Areas/Components/Views/PageSize/Default.cshtml", model)
            };

            // If the view exists in the app, use it; otherwise, use the fallback RCL view
        }
        /// <summary>
        /// Checks if a view exists in the consuming application.
        /// </summary>

        private bool ViewExists(string viewName)
        {
            var result = ViewEngine.FindView(ViewContext, viewName, false);
            return result.Success;
        }
    }
```

# На завершення

Що ж, це для PageSize helper. Я досі працюю над документацією та прикладами, але код стає кращим кожного дня.