TL;DR — Résumé Rapide

Apprenez à lire et utiliser les paramètres URL (query string) en ASP.NET. Couvre Web Forms, MVC, ASP.NET Core, Minimal API, la sécurité des redirections et JavaScript.

Lire les paramètres de l’URL (query string) est une tâche fondamentale dans le développement web avec ASP.NET. Cet article couvre toutes les approches modernes et classiques, de Web Forms à ASP.NET Core en passant par Minimal API.

Qu’est-ce qu’une query string ?

Une query string est la partie d’une URL qui suit le signe ?. Elle contient des paires clé-valeur séparées par & :

https://exemple.fr/rechercher?terme=asp.net&page=2&tri=date

Dans cet exemple :

  • terme = asp.net
  • page = 2
  • tri = date

ASP.NET Web Forms (classique)

Request.QueryString

// URL : https://exemple.fr/page.aspx?id=42&nom=produit

// Récupérer un seul paramètre
string id = Request.QueryString["id"];    // "42"
string nom = Request.QueryString["nom"];  // "produit"

// Vérifier l'existence avant utilisation
if (!string.IsNullOrEmpty(Request.QueryString["id"]))
{
    int produitId = int.Parse(Request.QueryString["id"]);
    // Utiliser l'ID...
}

Utilisation dans Page_Load

protected void Page_Load(object sender, EventArgs e)
{
    string categorie = Request.QueryString["cat"];
    
    if (!string.IsNullOrEmpty(categorie))
    {
        lblCategorie.Text = Server.HtmlEncode(categorie);
        ChargerProduits(categorie);
    }
}

Sécurité : Utilisez toujours Server.HtmlEncode() lors de l’affichage de valeurs de query string dans la page pour prévenir les attaques XSS (Cross-Site Scripting).

ASP.NET MVC

Liaison de modèle automatique

En MVC, le framework lie automatiquement les paramètres de l’URL aux paramètres de la méthode d’action :

// URL : /Produits/Rechercher?terme=laptop&page=1
public ActionResult Rechercher(string terme, int page = 1)
{
    // 'terme' = "laptop", 'page' = 1
    var resultats = _service.Rechercher(terme, page);
    return View(resultats);
}

Accès direct à QueryString

public ActionResult Detail()
{
    string id = Request.QueryString["id"];
    // Ou en MVC, de préférence :
    string id2 = Request["id"];
    
    return View();
}

ASP.NET Core

L’attribut [FromQuery]

// URL : /api/produits?categorie=electronique&prixMin=100&prixMax=500

[HttpGet]
public IActionResult ListerProduits(
    [FromQuery] string categorie,
    [FromQuery] decimal? prixMin,
    [FromQuery] decimal? prixMax)
{
    // Les paramètres sont liés automatiquement depuis la query string
    var produits = _repo.Filtrer(categorie, prixMin, prixMax);
    return Ok(produits);
}

Liaison avec un objet de requête

Pour de multiples paramètres, utilisez une classe :

public class FiltreProduit
{
    public string Categorie { get; set; }
    public decimal? PrixMin { get; set; }
    public decimal? PrixMax { get; set; }
    public int Page { get; set; } = 1;
    public int TaillePage { get; set; } = 20;
}

[HttpGet]
public IActionResult Lister([FromQuery] FiltreProduit filtre)
{
    // Tous les paramètres URL sont mappés aux propriétés de l'objet
    var resultats = _repo.Filtrer(filtre);
    return Ok(resultats);
}

Accès direct à HttpContext

public IActionResult Index()
{
    // Accès direct sans liaison de modèle
    string valeur = HttpContext.Request.Query["parametre"];
    
    // Vérifier l'existence
    if (HttpContext.Request.Query.ContainsKey("mode"))
    {
        string mode = HttpContext.Request.Query["mode"];
    }
    
    return View();
}

Minimal API (ASP.NET Core 6+)

var app = WebApplication.CreateBuilder(args).Build();

// Les paramètres URL sont liés automatiquement
app.MapGet("/rechercher", (string terme, int page = 1) =>
{
    return Results.Ok(new { Terme = terme, Page = page });
});

// Avec [FromQuery] explicite
app.MapGet("/filtrer", ([FromQuery] string categorie, [FromQuery] int? limite) =>
{
    return Results.Ok(new { Categorie = categorie, Limite = limite ?? 10 });
});

app.Run();

Modèle ReturnUrl (redirection après connexion)

Un cas d’utilisation très courant est l’URL de retour après la connexion :

// URL : /Compte/Connexion?ReturnUrl=%2Ftableau-de-bord%2Fparametres

[HttpPost]
public IActionResult Connexion(LoginViewModel modele, string returnUrl = null)
{
    if (ModelState.IsValid && AuthentifierUtilisateur(modele))
    {
        // IMPORTANT : Valider que l'URL est locale
        if (!string.IsNullOrEmpty(returnUrl) && Url.IsLocalUrl(returnUrl))
        {
            return Redirect(returnUrl);
        }
        
        return RedirectToAction("Index", "TableauDeBord");
    }
    
    return View(modele);
}

Prévention des redirections ouvertes

Ne jamais faire ceci :

// DANGEREUX — vulnérable aux redirections ouvertes
return Redirect(Request.QueryString["ReturnUrl"]);

Toujours valider avant de rediriger :

// SÛRE — vérifie que l'URL est locale
string returnUrl = Request.Query["ReturnUrl"];
if (Url.IsLocalUrl(returnUrl))
{
    return Redirect(returnUrl);
}
return RedirectToAction("Index", "Home");

Un attaquant pourrait utiliser ?ReturnUrl=https://site-malveillant.com pour diriger les utilisateurs vers un site de phishing.

Lecture avec JavaScript

Pour lire les paramètres URL côté client :

URLSearchParams (moderne)

// URL : https://exemple.fr/page?terme=recherche&lang=fr

const params = new URLSearchParams(window.location.search);

// Récupérer un paramètre
const terme = params.get('terme');  // "recherche"
const lang = params.get('lang');    // "fr"

// Vérifier l'existence
if (params.has('terme')) {
    console.log('Recherche :', params.get('terme'));
}

// Parcourir tous les paramètres
for (const [cle, valeur] of params) {
    console.log(`${cle} = ${valeur}`);
}

Construire des URLs avec des paramètres

const url = new URL('https://exemple.fr/api/produits');
url.searchParams.set('categorie', 'electronique');
url.searchParams.set('page', '1');
console.log(url.toString());
// "https://exemple.fr/api/produits?categorie=electronique&page=1"

Bonnes pratiques

  1. Toujours valider les paramètres d’entrée avant de les utiliser
  2. Encoder la sortie avec HtmlEncode lors de l’affichage de valeurs en HTML
  3. Utiliser des types fortement typés plutôt que des chaînes quand c’est possible
  4. Fournir des valeurs par défaut pour les paramètres optionnels
  5. Vérifier les nulls avant les conversions de type
  6. Ne jamais faire confiance aux valeurs URL pour des opérations sensibles sans validation

Dépannage

Le paramètre est toujours null

  • Vérifiez que le nom du paramètre correspond exactement (sensible à la casse)
  • Assurez-vous que le ? est présent dans l’URL
  • Confirmez qu’il n’y a pas d’erreur d’encodage sur les caractères spéciaux

Les caractères spéciaux ne sont pas lus correctement

Utilisez Uri.UnescapeDataString() pour décoder :

string valeur = Uri.UnescapeDataString(Request.Query["texte"]);

Articles connexes