# HTMX avec ASP.Partiaux de base du NET:Le serveurM SK2Renaissance côtière

<datetime class="hidden">2025-11-28T12:00</datetime>

<!--category-- HTMX, ASP.NET Core, Web Development, HTMX.NET -->
## Introduction

Si vous ' avez construit des applications ASP traditionnellesM SK1NET Core MVC, vous connaissez le problème qui plaisait : lorsque les utilisateurs naviguent entre les pagesMSC6 Rechargement de la page entière~, le chrome du navigateur s'éclaire~, le contenu bougeant autour à mesure que la nouvelle page se traduit~M SK9 Il fonctionne~MST10 mais il ne l'est pasMST11t *esprit d'entreprise* Moderne.

La technique de retour des fragments HTML partiels du serveur et d'échanger ceux-ci dans le DOM permet de résoudre ce problème - et il n'est pas nouveauM SK1 . I' j'ai utilisé ce modèle depuis les jours de jQueryMSC4 et même avant cela avec JavaScript vanilla et `XMLHttpRequest`. Ce qui a changé, c’est comment *élégante* il' est devenu avec HTMX.

HTMX nous fournit une façon déclarative de faire ce que nous avons toujours fait.

> **Article conjoint:** Cet article met l’accent sur les aspects d’intégration ASP.NET Core. Pour une profonde immersion dans les événements HTMXM SK2 cycle de vie , et extensions personnaliséesMSC4 voir mon article conjoint [Un tour de Whistle-stop des extensions HTMX et l'utilisation d'HTMX avec ASP.NET Core](/blog/htmxandaspnetcore).

Dans cet article, je vous montrerai comment HTMX s’intègre parfaitement avec ASP. **HTMX.NET** la bibliothèque le rend encore meilleur, et comment mon [mostlylucid.pagingtaghelper](https://github.com/scottgal/mostlylucid.pagingtaghelper) Le paquet NuGet utilise HTMX et offre une pagerie puissante avec configuration minimale.

L’approche est cadre-agnostique aussi - Django a ajouté des fragments de gabarit dans la version 6.0, Rails a Turbo FramesMSC3 et l’écosystème Web plus large intégre HTMLM SK4overMST5theMS-wire patternsMSP7 C’est un bon moment pour bâtir un serveurMSS9rendered applicationsMSSS10

[TOC]

## Qu'est-ce que HTMX?

HTMX est une bibliothèque qui vous permet d'accéder aux fonctionnalités modernes du navigateur directement à partir de HTML, plutôt que d'écrire JavaScript . Elle étend le HTML avec des attributs qui vous permettent de faire des demandes AJAXM SK2 échanger les contenus, et créer des interactions riches MSC4 tout sans laisser votre marquage

Les attributs clés que vous utiliserez le plus souvent'

- `hx-get`, `hx-post`, `hx-put`, `hx-delete` - Faire des demandes HTTP
- `hx-target` - Indiquer où placer la réponse
- `hx-swap` - Contrôle de la façon dont le contenu est remplacé.
- `hx-trigger` - Définir ce qui déclenche la requête
- `hx-push-url` - Mise à jour de l’URL du navigateur sans recharger la page entière

Voici ce qui en est le plus beau: :, vous, ', vous écrivez toujours un serveur; -, code de côté;,, serveur de retour; M SK5, HTML rendu; ., aucun API JSON; MSC7, client n'existe; MNK8, modèles de côtés; MRK9, pipelines ne sont pas construits.

## Un modèle aussi vieux que AJAX lui-même

Avant HTMX, nous avons atteint le même effet avec beaucoup plus de cérémonies . ici' ce que les mises à jour partielles semblaient dans l’ère jQueryM SK3

```javascript
// jQuery circa 2010
$('#load-more').click(function() {
    $.ajax({
        url: '/posts/page/' + currentPage,
        success: function(html) {
            $('#posts-container').append(html);
            currentPage++;
        }
    });
});
```

Et plus tôt encore, avec JavaScript de vanille:

```javascript
// Vanilla JS circa 2005
var xhr = new XMLHttpRequest();
xhr.onreadystatechange = function() {
    if (xhr.readyState === 4 && xhr.status === 200) {
        document.getElementById('content').innerHTML = xhr.responseText;
    }
};
xhr.open('GET', '/partial-content', true);
xhr.send();
```

HTMX passe simplement cette logique de JavaScript en attributs HTML.

ASP.Les développeurs du NET le font depuis des années.Panels de mise à jour dans les formulaires Web M SK2 `PartialView()` en MVC depuis le premier jour, `Html.RenderAction()` pour les fragments composables - la capacité a toujours été là . Ce qui nous manquait était une façon élégante de l’établir sur le côté client

L’industrie plus large a également redécouverte ces modèles.. Des termes comme "SSRM SK2 (ServerMSC4Side RenderingMska5 |"hybrid renderingMske7 et "islands ArchitectureMsko9 décrivent essentiellement ce que le serveurMski10side frameworks ont toujours fait, mais avec des yeux neufsMsky12 C’est la validation de l’approche qu’a exercée le serveur(-rendered approach scales),Mskie16 et Mskie17 avec les outils appropriés.

## Configuration de HTMX dans ASP.NET Core

Premièrement, inclure HTMX dans votre planche de travail. Vous pouvez utiliser un CDN ou le servir localement :

```html
<script src="https://unpkg.com/htmx.org@2.0.0"></script>
```

Que'c'est ce qu'il estM SK1 Aucune étape de construction , pas d'installation npm, pas de configuration webpackMST4 Just drop in a script tag and youMSC5re off to the racesMSL6

## Alpine.jsM SK1 Le client-Component arrière

Pour le client-réactivité latérale (affichage /éléments cachésM SK3 états de togglageMSC4 état local d'interfaceMNK5 [Alpine.js](https://alpinejs.dev/) HTMX se complète parfaitement. À seulement M SK1KB gzipped , il fournit Vue/ReactMSC4une réactivité déclarationnelle similaire sans bloatMNK5

```html
<script defer src="https://cdn.jsdelivr.net/npm/alpinejs@3.x.x/dist/cdn.min.js"></script>
```

Voici comment ils travaillent ensemble.

```razor
<div x-data="{ open: false }">
    <button x-on:click="open = !open">Toggle</button>
    <div x-show="open" x-transition>
        <button hx-get="/api/data" hx-target="#results">Load Data</button>
    </div>
</div>
```

Alpine gère l'interface locale (la toggle),HTMX gère les appels de serveur (le téléchargement des donnéesM SK3 Tout au long de cet articleMska4 vousM Ska5verez ce modèle mska6 Alpine pour la réactivité du clientMka7 HTMX pour les interactions avec le serveurMSKA8

## La bibliothèque HTMX.NET

[Khalid Abuhakmeh](https://khalidabuhakmeh.com/about)'s [HTMX.NET](https://github.com/khalidabuhakmeh/Htmx.Net) library provides first-class ASP.NET Core integrationM SK2 Disponible comme `Htmx` et `Htmx.TagHelpers` NuGet packages, il se sent natif à .NET et rend le travail avec HTMX un plaisir absolu . VousM SK3 trouverez plus de KhalidMSC4 son excellent openMST5source work sur sa [GitHub](https://github.com/khalidabuhakmeh).

### Installation

```bash
dotnet add package Htmx
dotnet add package Htmx.TagHelpers
```

Dans votre `_ViewImports.cshtml`:

```razor
@addTagHelper *, Htmx.TagHelpers
```

### Méthode d'extension IsHtmx()

La fonctionnalité la plus utile est `Request.IsHtmx()` méthode d'extension, qui vous indique si la demande vient de HTMX. Cela vous permet de retourner soit une vue complète, soit seulement partielle

```csharp
[HttpGet]
public async Task<IActionResult> Index(int page = 1, int pageSize = 20)
{
    var posts = await blogViewService.GetPagedPosts(page, pageSize);

    if (Request.IsHtmx())
        return PartialView("_BlogSummaryList", posts);

    return View("Index", posts);
}
```

Ce modèle est absolument brillant. Une action de contrôle unique sert les deux

- La page entière est chargée ( lorsque les utilisateurs naviguent directement ou rafraîchissent la page)
- Mise à jour partielle (when HTMX makes the request)

Aucune interface API distincte, aucune logique dupliquée , aucun surcoût de serialisation JSON.

> **Une erreur courante:** De nombreux développeurs ASP.NET pensent que vous avez besoin du `_` Préfixe (comme `_BlogSummaryList.cshtml`) pour obtenir une répartition partielle de l’image `PartialView()` la méthode elle-même dit à ASP.NET Core de passer par le layout M SK1 il's disant "forget the layoutMST4 just render this bitM ST5 Vous pouvez utiliser `return PartialView("SearchResults", model)` avec un fichier de vue ordinaire et il fonctionne parfaitement. La convention sous-jacente provient d’ASP.NET Web Pages M SK2WebMatrix ) où elle a empêché que les fichiers soient servis directement par l’intermédiaire d’un URL - mais MVC a toujours protégé toutes les vues contre l’accès direct en tout état de cause. *objet* en tant que parties.

### HTMX.NET Aides à l'étiquetage

HTMX.NET fournit des aides à l'étiquetage qui rendent le travail avec les contrôleurs plus propre.

```razor
<button
    hx-controller="Comment"
    hx-action="GetCommentForm"
    hx-post
    hx-target="#commentform">
    Reply
</button>
```

Cela génère la route appropriée à l'aide d' ASP.NET Core's routing system . Si vous rebaptisez votre contrôleur ou actionM SK3 votre IDE l'obtiendra~. Bien mieux que les chaînes magiquesMSC5

Voici un exemple réel de ce blog:

```razor
<button
    class="btn btn-outline btn-sm mb-4"
    hx-action="Comment"
    hx-controller="Comment"
    hx-post
    hx-vals
    x-on:click.prevent="window.mostlylucid.comments.setValues($event)"
    hx-on="htmx:afterSwap: window.scrollTo({top: 0, behavior: 'smooth'})"
    hx-swap="outerHTML"
    hx-target="#commentform">
    Comment
</button>
```

Notez comment HTMX joue bien avec Alpine.js M SK1`x-on:click.prevent`) pour les bits occasionnels du client-interopérabilité des côtésM SK2

### Autres aides HTMX.NET

La bibliothèque fournit également:

- `Request.IsHtmxNonBoosted()` - Vérifiez s’il est une demande de HTMX mais pas stimulée
- `Request.IsHtmxRefresh()` - Vérifier s’il est une demande de restauration de l’historique '
- Outils d'aide à la réponse pour les en-têtes HTMX (triggersM SK1 redirections , etc.)

## Real-Exemple mondial: Recherche avec les parties

Voici le contrôleur de recherche de ce blog.

```csharp
[HttpGet]
[OutputCache(Duration = 3600, VaryByHeaderNames = new[] { "hx-request", "pagerequest" })]
public async Task<IActionResult> Search(
    string? query,
    int page = 1,
    int pageSize = 10,
    [FromHeader] bool pagerequest = false)
{
    var searchModel = await BuildSearchModel(query, page, pageSize);

    if (pagerequest && Request.IsHtmx())
        return PartialView("_SearchResultsPartial", searchModel.SearchResults);

    if (Request.IsHtmx())
        return PartialView("SearchResults", searchModel);

    return View("SearchResults", searchModel);
}
```

Trois voies de retour pour trois scénarios:

1. Demandes de pagination - minimal partiel (juste la liste des résultatsM SK2
2. Changements des filtres - section partielle (résultats avec les filtresM SK2
3. Navigation directe - page entière (marchage + toutMSC3

La vue partielle (`_SearchResultsPartial.cshtml`) utilise l'aide à la balise de messagerie

```razor
@model Mostlylucid.Models.Blog.PostListViewModel
<div class="pt-2" id="content">
    @if (Model.Data?.Any() is true)
    {
        <div class="inline-flex w-full items-center justify-center pb-4">
            @if (Model.TotalItems > Model.PageSize)
            {
                <pager
                    x-ref="pager"
                    link-url="@Model.LinkUrl"
                    hx-boost="true"
                    hx-target="#content"
                    hx-swap="show:none"
                    page="@Model.Page"
                    page-size="@Model.PageSize"
                    total-items="@Model.TotalItems"
                    hx-headers='{"pagerequest": "true"}'>
                </pager>
            }
        </div>
        @foreach (var post in Model.Data)
        {
            <partial name="_ListPost" model="post"/>
        }
    }
</div>
```

Débrouillage de l'aide à la balise du navigateur:

- `hx-boost="true"` - Intercepte les liens, convert en AJAX
- `hx-target="#content"` - Où injecter la réponse
- `hx-headers='{"pagerequest": "true"}'` - Intitulé personnalisé indique au contrôleur la page de '
- Le contrôleur vérifie `Request.IsHtmx() && pagerequest` pour retourner seulement la partie minimale

## Le paquet d'aide pour les balises de navigation plus claire.

J'ai écrit [mostlylucid.pagingtaghelper](https://github.com/scottgal/mostlylucid.pagingtaghelper) pour éviter la pagerie répétitive code. Il 's HTMX-première mais fonctionne sans JavaScript aussiM SK3

### Installation

```bash
dotnet add package mostlylucid.pagingtaghelper
```

Ajouter à `_ViewImports.cshtml`:

```razor
@addTagHelper *, mostlylucid.pagingtaghelper
```

### Faits clés

Mise en œuvre `IPagingModel<T>` et vous 'êtes terminés :

```csharp
public class BasePagingModel<T> : IPagingModel<T> where T : class
{
    public int Page { get; set; }
    public int TotalItems { get; set; }
    public int PageSize { get; set; }
    public string LinkUrl { get; set; }
    public List<T> Data { get; set; }
}
```

**Ce que vous obtiendrez:**

- Configuration zéro requise
- Plusieurs cadres d'interface (TailwindCSS + DaisyUI, Bootstrap 5, vues personnaliséesM SK4
- Soutien en mode foncé
- 8 langues construites
- Headers sortables, sélecteurs de la taille des pages
- Amélioration progressive ( fonctionne sans JavaScript)
- Soutien du symbole de continuité pour les bases de données NoSQL

L'aide à l'étiquetage génère des liens qui préservent les chaînes de demande, appuient les titres personnalisés, et s'intègrent sans fil avec HTMX (voir l'exemple ci-dessus

## Diagramme de flux HTMX

Voici la façon dont l’ensemble du système s’intègre.

```mermaid
graph TB
    A[Browser] -->|"Initial page load"| B[Controller Action]
    B -->|"Request.IsHtmx() = false"| C[Return Full View]
    C --> D[Render Layout + Partial]

    A -->|"User clicks pagination/filter"| E[HTMX Request]
    E -->|"hx-get with headers"| F[Same Controller Action]
    F -->|"Request.IsHtmx() = true"| G{Check Headers}
    G -->|"pagerequest header"| H[Return Minimal Partial]
    G -->|"No special header"| I[Return Section Partial]

    H --> J[Swap Content in Target]
    I --> J

    J -->|"User clicks another link"| E

    style B stroke:#333,stroke-width:2px
    style F stroke:#333,stroke-width:2px
    style C stroke:#0066cc,stroke-width:2px
    style H stroke:#00cc66,stroke-width:2px
    style I stroke:#00cc66,stroke-width:2px
```

## Comparaison avec d'autres cadres

### Fragments de gabarit Django

Django a ajouté des renders partiels de modèles appropriés dans la version 6.0 (Décembre ♫2024) avec fragments de templates ♫ . Avant cela ♫ `PartialView()` depuis la version 1.0 dans 2016

### Fermes Turbo

Ruby on Rails a des cadres turbo (partie de Hotwire), qui est similaire dans l'espritM SK2

```erb
<%= turbo_frame_tag "posts" do %>
  <%= render @posts %>
<% end %>
```

La différence est que Turbo requiert des marqueurs de cadre spécifiques à la fois sur demande et sur réponse. HTMX est plus souple - tout point final peut retourner n’importe quel HTML , et vous décidez où il va avec `hx-target`.

### Phoenix LiveView

Elixir's Phoenix LiveView adopte une approche différente avec des connexions WebSocket persistantes et un serveur

```elixir
def handle_event("load_more", _params, socket) do
  {:noreply, assign(socket, posts: load_more_posts())}
end
```

LiveView est brillante pour les applications réelles-time, mais elle requiert une infrastructure WebSocket et un mémoire de serveur pour les connexions . HTMX utilise l'ancienne simple HTTP M SK3 instauréeMNK4 cacheableMRK5 scalable MNK6 Pour un blogMKK7 ce quiMCK8est parfaitMZK9

## Considérations relatives au rendement

**Cache de sortie**: Le `OutputCache` l'attribut varie par `hx-request` header, cacher séparément les pages complètes et les parties partielles

```csharp
[OutputCache(Duration = 3600, VaryByHeaderNames = new[] { "hx-request", "pagerequest" })]
```

**Efficacité du réseau**: ServeurM SK1 HTML transmis est souvent plus petit que JSON + client- gabarits côtésMSC4 nécessite moins de voyages d’accouplementMST5 et caches correctementMst6

**Taille du colis**: HTMX (14KBM SK2 + optionnel Alpine.js (15KB+) \+ assistant de balisage d'affichage de messagerie M(0KB=, serveurMSC10sideMNK11 |= en bas de la page R30KB totalMRK14 Comparez-le à une application React typique P(200KB~+).

## Paramètres avancés

**Optimistes mises à jour de l'interface** - Combinez HTMX et Alpine pour une rétroaction instantanée

```razor
<div x-data="{ count: @Model.CommentCount }">
    <button hx-post="/comment/like" x-on:click="count++" hx-on::after-request="count = $event.detail.xhr.response">
        Likes: <span x-text="count"></span>
    </button>
</div>
```

Le compte est mis à jour immédiatement (optimiste), puis synchronisé avec la réponse du serveurM SK2

**Outre-of-Band Swaps** - Mettre à jour plusieurs sections de page d’une seule réponse

```razor
<div id="main-content"><!-- Main response --></div>
<div id="notification-count" hx-swap-oob="true"><span>5 new</span></div>
```

Perfect pour les badges de notification, le nombre de carts , etcM SK2 Je couvre ce modèle en profondeur dans [Afficher Toast et Swapping avec HTMX](/blog/showingtoastandswappingwithhtmx).

**Client-Side Templates with WebAPI** - Parfois, vous voulez une expérience d'accès à l'intérieur de -un serveur :un HTML transmis pour la plupart des choses, mais JSON provenant d'une API Web pour un contenu dynamique particulier. [client-side-extension des modèles](https://htmx.org/extensions/client-side-templates/) permet de faire exactement ce qui suit:

```html
<script src="https://unpkg.com/htmx-ext-client-side-templates@2.0.0/client-side-templates.js"></script>
<script src="https://unpkg.com/mustache@latest"></script>

<div hx-ext="client-side-templates">
    <template id="post-template" type="text/mustache">
        {{#posts}}
        <div class="post">
            <h3>{{title}}</h3>
            <p>{{excerpt}}</p>
        </div>
        {{/posts}}
    </template>

    <button hx-get="/api/posts"
            hx-target="#post-list"
            mustache-template="post-template">
        Load Posts
    </button>
    <div id="post-list"></div>
</div>
```

Cette approche fonctionne avec Mustache, Les barres de manœuvre , ou les modèles Nunjucks. Votre WebAPI retourne JSONM SK3 mais HTMX gère le client de renderingMSC4sideMNK5 Il est particulièrement utileMRK6 lorsque vous avez une API existante ou que vous avez besoin de partager des données avec des applications mobiles. [l'article conjoint](/blog/htmxandaspnetcore).

## Gotchas & Conseils

**Outil de débugging:** Installer le [Extension de débugger HTMX](https://chromewebstore.google.com/detail/htmx-debugger/) - il montre toutes les demandes, réponseM SK2 et échange en temps réel

### Tokens du CSRF

ASP.NET Core'les tokens antiforgery ont besoin d'une manipulation spéciale avec AJAX . HTMXM SK3NET fournit plusieurs options nettes `HtmxAntiforgeryScriptEndpoint`:

```csharp
// In Program.cs
app.MapHtmxAntiforgeryScript();
```

```html
<!-- In your layout head -->
<script src="@HtmxAntiforgeryScriptEndpoints.Path" defer></script>
```

Or use the tag helper: `<meta name="htmx-config" includeAspNetAntiforgeryToken="true" />`. Voir [Khalid's article sur HTMX Anti-Forgery Tokens](https://khalidabuhakmeh.com/htmx-requests-with-aspnet-core-anti-forgery-tokens) pour plus de détails.

### Alpine.js M SK1 Shorthand in Razor

Alpine's `@click` conflits courtois avec Razor's `@` syntax. Utilisez le formulaire explicite en remplacement

```razor
<button x-on:click="doSomething()">Click me</button>  <!-- Instead of @click -->
<div x-bind:class="isOpen ? 'block' : 'hidden'"></div>  <!-- Instead of :class -->
```

Ou évacuer avec `@@click`, mais la syntaxe explicite est plus claire

### Gestion de l'histoire

**Contrôle des entrées de l'histoire:** Par défaut, HTMX fait passer chaque demande à l'historique. Pour la pagenageM SK2 filtres où vous ne voulez pas ' ne désirez pas polluer l'histoireMSC4

```razor
<paging model="@Model" hx-push-url="false">  <!-- Don't add history entries -->
```

Ou utiliser `hx-replace-url="true"` pour mettre à jour l'URL sans ajouter des entrées.

**Le problème partiel du fantôme:** Retour du navigateur/suite ne montre qu’un fragment partiel sans layout. Fix avec `hx-history-elt` sur votre contenant de contenu:

```html
<div class="container mx-auto" id="contentcontainer" hx-history-elt>
    @RenderBody()
</div>
```

Cela indique à HTMX quel élément faire une prise de vue instantanée, préservant le plan entourant lors du rétablissement de l'historique.

### Cache CDN (Cloudflare, etcM SK2

**Symptôme:** HTMX fonctionne localement mais se démarque derrière un CDN - le contenu erroné est caché

**Cause profonde:** Les CDN ignorent les `HX-Request` header. Votre serveur retourne des contenus différents en fonction de ce titreM SK1 mais le CDN les cache identiquement.

**ASP.NET Core fix:** Utilisation `VaryByHeaderNames`:

```csharp
[OutputCache(Duration = 3600, VaryByHeaderNames = new[] { "hx-request" })]
```

**CDN fix:** Configurer les règles de cache à inclure `HX-Request` dans la clé de cache. Pour Cloudflare: Tableau d'affichage M SK2 Cache → Règles de cache → clé de cache personnalisée M→ Entêtes m→ Inclure `HX-Request`.

### Le débat de haut niveau hx-

[`hx-boost`](https://htmx.org/attributes/hx-boost/) convert les liens normaux en demandes AJAX. Le [HTMX quirks page](https://htmx.org/quirks/) Note que certains membres de l’équipe centrale recommandent d’éviter cette situation (discards `<head>` content, affecte la localité du comportementM SK1 tandis que d’autres trouvent qu’il est bon pour des victoires rapides.

```razor
<div hx-boost="true" hx-target="#contentcontainer">
    <a asp-action="Show" asp-route-slug="@post.Slug">Read More</a>
</div>
```

Ce blog l’utilise de façon étendue. Lorsqu’il vise des conteneurs spécifiques, explicitement `hx-get` est plus claire, mais `hx-boost` fonctionne si vous 'êtes cohérents . désactivez sélectivement avec `hx-boost="false"` sur les éléments d’enfant.

## Conclusion

HTMX avec ASP.NET Parties de base représentent un retour au serveur- simplicité sur le côté sans sacrifier l'UX moderne . Vous obtiendrez

- Interactions dynamiques, SPAM SK1 similaires
- Serveur-réalisation des côtés M SK1excellent pour SEO)
- Cache HTTP appropriée
- JavaScript minimal
- Amélioration progressive
- Type-routage sécuritaire avec HTMX.NET
- Zero-config pagination avec mostlylucid.pagingtaghelper

L’approche du serveur-rended a fait l’objet d’un test de temps , et avec HTMX, il a enfin le client élégantM SK3outils côtés qu’il mériteMSC4 Vous pouvez construire des applications Web robustesMNK5 performantes en utilisant des modèles qui ont fonctionné pendant des décennies MMK6 ilsMRK7on vient juste d’attendre l’outil approprié pour les faire briller de nouveauMEK8

## Articles connexes sur ce blog

### Article de compagne

Cet article fait partie d’une série de deux parties sur HTMX avec ASP

1. **Cet article** - Concentration sur l'ASP.Intégration du noyau NET , vues partiellesM SK3 HTMXMST4NETMSC5 et pagination
2. **[A Whistle-stop Tour des extensions HTMX](/blog/htmxandaspnetcore)** - Immersion profonde dans les événements de l'HTMX , cycle de vie

### Autres articles HTMX

- [Ajouter le messagerie avec HTMX](/blog/addpagingwithhtmx) - L'article original sur la mise en œuvre de la pagination avec l'ancienne PaginationTagHelper
- [ASP.Net Caching Core avec HTMX](/blog/aspnetcachingwithhtmx) - Étude approfondie des stratégies de cache pour les demandes HTMX
- [Auto-refresh avec Alpine et HTMX](/blog/autorefreshwithalpineandhtmx) - Combiner Alpine.js avec HTMX pour les composants réactifs
- [Faire votre site plus SPA-comme avec HTMX](/blog/htmxtomakeyoursitemorespalike) - SPA- navigation similaire sans cadres JavaScript
- [Utilisation de SweetAlert pour les indicateurs HX](/blog/usingsweetalertforhxindicators) - Pièces indicateurs de chargement avec HTMX
- [Afficher Toast et Swapping avec HTMX](/blog/showingtoastandswappingwithhtmx) - Server-notifications de toast trigées

## Autres lectures

**Documentation officielle:**

- [Documentation HTMX](https://htmx.org/docs/) - La documentation officielle de l'HTMX
- [Exemples HTMX](https://htmx.org/examples/) - Exemples pratiques de modèles HTMX
- [Extensions HTMX](https://htmx.org/extensions/) - Extensions officielles de l'HTMX
- [Alpine.js Documentation](https://alpinejs.dev/) - Docs officiels de l’AlpineM SK1js
- [Alpine.js Exemples](https://alpinejs.dev/examples) - Modèles alpins pratiquesM SK1js
- [ASP.NET Vues partielles du noyau](https://learn.microsoft.com/en-us/aspnet/core/mvc/views/partial) - Microsoft's guide aux vues partielles
- [ASP.Net Caching des sorties de base](https://learn.microsoft.com/en-us/aspnet/core/performance/caching/output) - Documentation officielle de cache

**Bibliothèques & Outils:**

- [HTMX.NET GitHub](https://github.com/khalidabuhakmeh/Htmx.Net) - Code source de la bibliothèque HTMX.NET
- [NuGet HTMX](https://www.nuget.org/packages/Htmx/) - HTMX.NET sur NuGet
- [Htmx.TagHelpers NuGet](https://www.nuget.org/packages/Htmx.TagHelpers/) - HTMX Tag Helpers sur NuGet
- [Site Web de Khalid Abuhakmeh](https://khalidabuhakmeh.com/) - Créateur de HTMX.NETM SK2 avec des excellents articles sur le blog
- [Khalid Abuhakmeh's GitHub](https://github.com/khalidabuhakmeh) - Plus brillants projets ouverts-source .NET
- [mostlylucid.pagingtaghelper GitHub](https://github.com/scottgal/mostlylucid.pagingtaghelper) - Mon code source de l'aide à la balise d'affichage
- [mostlylucid.pagingtaghelper NuGet](https://www.nuget.org/packages/mostlylucid.pagingtaghelper/) - Le paquet sur NuGet

**Ressources communautaires:**

- [HTMX Discord](https://htmx.org/discord) - Soutien communautaire actif
- [HTMX Essays](https://htmx.org/essays/) - Articles réfléchis sur la philosophie de l'HTMX
- [Hypermedia Systems Book](https://hypermedia.systems/) - Livre en ligne gratuit sur la construction d'applications hypermédia