Quelle est la différence entre Request.Url.Query et Request.QueryString?

Ce que vous avez indiqué comme "cassé" chaîne codée est en fait l'encodage correct selon les normes. Celui que vous avez indiqué comme "correcte" encodage à l'aide d'un non-standard de l'extension du cahier des charges afin de permettre à un format de %uXXXX (je crois que c'est censé indiquer l'encodage UTF-16).

Dans tous les cas, le "cassé" chaîne codée est ok. Vous pouvez utiliser le code suivant pour tester:

Uri uri = new Uri("http://www.example.com/test.aspx?search=heřmánek");
Console.WriteLine(uri.Query);
Console.WriteLine(HttpUtility.UrlDecode(uri.Query));

Fonctionne très bien. Mais... sur une intuition, j'ai essayé UrlDecode Latin-1 page de codes spécifiée, au lieu de la valeur par défaut UTF-8:

Console.WriteLine(HttpUtility.UrlDecode(uri.Query, 
           Encoding.GetEncoding("iso-8859-1")));

... et j'ai eu la mauvaise valeur spécifiée, 'heÅmánek'. En d'autres termes, il ressemble à l'appel à HttpContext.RewritePath() en quelque sorte des changements de l'encodage/décodage d'utiliser le Latin-1 page de codes, plutôt que de l'UTF-8, qui est l'encodage utilisé par défaut par le UrlEncode/Décoder des méthodes.

Cela ressemble à un bug, si vous me demandez. Vous pouvez regarder le RewritePath() code de réflecteur et de voir que c'est bien de jouer avec la querystring - transmettre autour de toutes sortes de chemin d'accès virtuel fonctions, et pour certains non géré IIS code.

Je me demande si quelque part le long du chemin, l'Uri au cœur de l'objet de la Requête obtient manipulé avec le mauvais code? Qui pourrait expliquer pourquoi Request.Querystring (qui n'est simplement que les premières valeurs des en-têtes HTTP) serait correct, tandis que l'Uri de l'utilisation de la mauvaise codant pour la diacriticals serait incorrect.

J'ai fait un peu de recherche au cours de la journée et je pense avoir quelques informations.

Lorsque vous utilisez la Demande.Querystring ou HttpUtility.UrlDecode (ou Coder) c'est à l'aide de l'Encodage spécifié dans l'élément (en particulier le requestEncoding attribut) du web.config (ou la .hiérarchie de configuration si vous n'avez pas spécifié) ---PAS de l'Encodage.Par défaut, qui est l'encodage par défaut de votre serveur.

Lorsque vous avez de l'encodage en UTF-8, un caractère unicode peut être codée sous la forme de 2 %xx des valeurs hexadécimales. Il sera également décodé de cette façon, lorsque compte tenu de l'ensemble de la valeur.

Si vous êtes UrlDecoding avec un Encodage différent de l'url a été codé avec, vous obtiendrez un résultat différent.

Depuis HttpUtility.UrlEncode et UrlDecode peut prendre un paramètre d'encodage, il peut être tentant d'essayer de coder à l'aide d'une page de codes ANSI, mais UTF-8 est la bonne façon de faire si vous avez la prise en charge du navigateur (apparemment les anciennes versions ne prennent pas en charge UTF-8). Vous avez juste besoin de s'assurer que la est installé correctement et que les deux parties fonctionnent bien.

UTF-8 Semble être l'encodage par défaut: (à partir de .net Système de réflecteur.Web.HttpRequest)

internal Encoding QueryStringEncoding
{
    get
    {
        Encoding contentEncoding = this.ContentEncoding;
        if (!contentEncoding.Equals(Encoding.Unicode))
        {
            return contentEncoding;
        }
        return Encoding.UTF8;
    }
}

En suivant le chemin pour trouver le.ContentEncoding vous conduit à l' (également dans HttpRequest)

public Encoding ContentEncoding
{
    get
    {
        if (!this._flags[0x20] || (this._encoding == null))
        {
            this._encoding = this.GetEncodingFromHeaders();
            if (this._encoding == null)
            {
                GlobalizationSection globalization = RuntimeConfig.GetLKGConfig(this._context).Globalization;
                this._encoding = globalization.RequestEncoding;
            }
            this._flags.Set(0x20);
        }
        return this._encoding;
    }
    set
    {
        this._encoding = value;
        this._flags.Set(0x20);
    }
}

Pour répondre à votre question sur la différence entre la Demande.Url.Quer et de la Demande.QueryString... voici comment HttpRequest construit sa Propriété Url:

public Uri Url
{
get
{
if ((this._url == null) && (this._wr != null))
{
string queryStringText = this.QueryStringText;
if (!string.IsNullOrEmpty(queryStringText))
{
queryStringText = "?" + HttpEncoder.CollapsePercentUFromStringInternal(queryStringText, this.QueryStringEncoding);
}
if (AppSettings.UseHostHeaderForRequestUrl)
{
string knownRequestHeader = this._wr.GetKnownRequestHeader(0x1c);
try
{
if (!string.IsNullOrEmpty(knownRequestHeader))
{
this._url = new Uri(this._wr.GetProtocol() + "://" + knownRequestHeader + this.Path + queryStringText);
}
}
catch (UriFormatException)
{
}
}
if (this._url == null)
{
string serverName = this._wr.GetServerName();
if ((serverName.IndexOf(':') >= 0) && (serverName[0] != '['))
{
serverName = "[" + serverName + "]";
}
this._url = new Uri(this._wr.GetProtocol() + "://" + serverName + ":" + this._wr.GetLocalPortAsString() + this.Path + queryStringText);
}
}
return this._url;
}
}

Vous pouvez le voir, il est à l'aide de la HttpEncoder classe pour faire le décodage, mais il utilise le même QueryStringEncoding valeur.

Depuis que je suis déjà poster beaucoup de code ici et n'importe qui peut l'obtenir .NET Réflecteur, je vais extrait de le reste. La propriété QueryString vient de la HttpValueCollection qui utilise FillFromEncodedBytes méthode pour finalement appeler HttpUtility.UrlDecode (avec le QueryStringEncoding valeur définie ci-dessus), qui a finalement appels de la HttpEncoder pour les décoder.
Ils ne semblent utiliser différentes méthodes pour décoder les octets de la chaîne de requête, mais l'encodage qu'ils utilisent pour le faire semble être le même.

Il est intéressant pour moi que le HttpEncoder a de nombreuses fonctions qui semblent faire la même chose, de sorte que son possible, il existe des différences dans les méthodes qui peuvent causer un problème.