Encodage d'URL à l'aide de C #

J'ai une application qui envoie une demande POST au logiciel de forum VB et connecte quelqu'un (sans paramétrer les cookies ou quoi que ce soit).

Une fois l'utilisateur connecté, je crée une variable qui crée un chemin sur sa machine locale.

c: \ dossier temporaire \ date \ nom d'utilisateur

Le problème est que certains noms d'utilisateur lèvent l'exception "caractères illégaux". Par exemple, si mon nom d'utilisateur était, mas|fenixil déclencherait une exception.

Path.Combine( _      
  Environment.GetFolderPath(System.Environment.SpecialFolder.CommonApplicationData), _
  DateTime.Now.ToString("ddMMyyhhmm") + "-" + form1.username)

Je ne veux pas le supprimer de la chaîne, mais un dossier avec leur nom d'utilisateur est créé via FTP sur un serveur. Et cela m'amène à ma deuxième question. Si je crée un dossier sur le serveur, puis-je laisser les "caractères illégaux" dans? Je ne pose cette question que parce que le serveur est basé sur Linux, et je ne sais pas si Linux l'accepte ou non.

EDIT: Il semble que le codage URL n'est PAS ce que je veux .. Voici ce que je veux faire:

old username = mas|fenix
new username = mas%xxfenix

Où% xx est la valeur ASCII ou toute autre valeur qui identifierait facilement le caractère.

Edit: Notez que cette réponse est désormais obsolète. Voir la réponse de Siarhei Kuchuk ci-dessous pour une meilleure solution

UrlEncoding fera ce que vous proposez ici. Avec C #, vous utilisez simplement HttpUtility, comme mentionné.

Vous pouvez également Regex les caractères illégaux puis les remplacer, mais cela devient beaucoup plus complexe, car vous devrez avoir une certaine forme de machine d'état (commutateur ... cas, par exemple) pour remplacer par les bons caractères. Comme UrlEncodecela se fait d'avance, c'est plutôt facile.

En ce qui concerne Linux par rapport à Windows, certains caractères acceptables sous Linux ne le sont pas, mais je ne m'inquiéterais pas à ce sujet, car le nom du dossier peut être renvoyé en décodant la chaîne Url, en utilisant UrlDecode, afin que vous puissiez aller-retour le changements.

J'ai expérimenté les différentes méthodes que .NET fournit pour le codage d'URL. Peut-être que le tableau suivant sera utile (en tant que sortie d'une application de test que j'ai écrite):

Unencoded UrlEncoded UrlEncodedUnicode UrlPathEncoded EscapedDataString EscapedUriString HtmlEncoded HtmlAttributeEncoded HexEscaped
A         A          A                 A              A                 A                A           A                    %41
B         B          B                 B              B                 B                B           B                    %42

a         a          a                 a              a                 a                a           a                    %61
b         b          b                 b              b                 b                b           b                    %62

0         0          0                 0              0                 0                0           0                    %30
1         1          1                 1              1                 1                1           1                    %31

[space]   +          +                 %20            %20               %20              [space]     [space]              %20
!         !          !                 !              !                 !                !           !                    %21
"         %22        %22               "              %22               %22              "      "               %22
#         %23        %23               #              %23               #                #           #                    %23
$         %24        %24               $              %24               $                $           $                    %24
%         %25        %25               %              %25               %25              %           %                    %25
&         %26        %26               &              %26               &                &       &                %26
'         %27        %27               '              '                 '                '       '                %27
(         (          (                 (              (                 (                (           (                    %28
)         )          )                 )              )                 )                )           )                    %29
*         *          *                 *              %2A               *                *           *                    %2A
+         %2b        %2b               +              %2B               +                +           +                    %2B
,         %2c        %2c               ,              %2C               ,                ,           ,                    %2C
-         -          -                 -              -                 -                -           -                    %2D
.         .          .                 .              .                 .                .           .                    %2E
/         %2f        %2f               /              %2F               /                /           /                    %2F
:         %3a        %3a               :              %3A               :                :           :                    %3A
;         %3b        %3b               ;              %3B               ;                ;           ;                    %3B
<         %3c        %3c               <              %3C               %3C              &lt;        &lt;                 %3C
=         %3d        %3d               =              %3D               =                =           =                    %3D
>         %3e        %3e               >              %3E               %3E              &gt;        >                    %3E
?         %3f        %3f               ?              %3F               ?                ?           ?                    %3F
@         %40        %40               @              %40               @                @           @                    %40
[         %5b        %5b               [              %5B               %5B              [           [                    %5B
\         %5c        %5c               \              %5C               %5C              \           \                    %5C
]         %5d        %5d               ]              %5D               %5D              ]           ]                    %5D
^         %5e        %5e               ^              %5E               %5E              ^           ^                    %5E
_         _          _                 _              _                 _                _           _                    %5F
`         %60        %60               `              %60               %60              `           `                    %60
{         %7b        %7b               {              %7B               %7B              {           {                    %7B
|         %7c        %7c               |              %7C               %7C              |           |                    %7C
}         %7d        %7d               }              %7D               %7D              }           }                    %7D
~         %7e        %7e               ~              ~                 ~                ~           ~                    %7E

Ā         %c4%80     %u0100            %c4%80         %C4%80            %C4%80           Ā           Ā                    [OoR]
ā         %c4%81     %u0101            %c4%81         %C4%81            %C4%81           ā           ā                    [OoR]
Ē         %c4%92     %u0112            %c4%92         %C4%92            %C4%92           Ē           Ē                    [OoR]
ē         %c4%93     %u0113            %c4%93         %C4%93            %C4%93           ē           ē                    [OoR]
Ī         %c4%aa     %u012a            %c4%aa         %C4%AA            %C4%AA           Ī           Ī                    [OoR]
ī         %c4%ab     %u012b            %c4%ab         %C4%AB            %C4%AB           ī           ī                    [OoR]
Ō         %c5%8c     %u014c            %c5%8c         %C5%8C            %C5%8C           Ō           Ō                    [OoR]
ō         %c5%8d     %u014d            %c5%8d         %C5%8D            %C5%8D           ō           ō                    [OoR]
Ū         %c5%aa     %u016a            %c5%aa         %C5%AA            %C5%AA           Ū           Ū                    [OoR]
ū         %c5%ab     %u016b            %c5%ab         %C5%AB            %C5%AB           ū           ū                    [OoR]

Les colonnes représentent les encodages comme suit:

• UrlEncoded: HttpUtility.UrlEncode

• UrlEncodedUnicode: HttpUtility.UrlEncodeUnicode

• UrlPathEncoded: HttpUtility.UrlPathEncode

• EscapedDataString: Uri.EscapeDataString

• EscapedUriString: Uri.EscapeUriString

• HtmlEncoded: HttpUtility.HtmlEncode

• HtmlAttributeEncoded: HttpUtility.HtmlAttributeEncode

• HexEscaped: Uri.HexEscape

REMARQUES:

1. HexEscapene peut gérer que les 255 premiers caractères. Par conséquent, il lève une ArgumentOutOfRangeexception pour les caractères latins A étendus (par exemple, Ā).

2. Ce tableau a été généré dans .NET 4.0 (voir le commentaire de Levi Botelho ci-dessous qui dit que l'encodage dans .NET 4.5 est légèrement différent).

ÉDITER:

J'ai ajouté une deuxième table avec les encodages pour .NET 4.5. Voir cette réponse: https://stackoverflow.com/a/21771206/216440

EDIT 2:

Puisque les gens semblent apprécier ces tables, j'ai pensé que vous pourriez aimer le code source qui génère la table, afin que vous puissiez jouer autour de vous. Il s'agit d'une simple application console C #, qui peut cibler soit .NET 4.0 soit 4.5:

using System;
using System.Collections.Generic;
using System.Text;
// Need to add a Reference to the System.Web assembly.
using System.Web;

namespace UriEncodingDEMO2
{
    class Program
    {
        static void Main(string[] args)
        {
            EncodeStrings();

            Console.WriteLine();
            Console.WriteLine("Press any key to continue...");
            Console.Read();
        }

        public static void EncodeStrings()
        {
            string stringToEncode = "ABCD" + "abcd"
            + "0123" + " !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~" + "ĀāĒēĪīŌōŪū";

            // Need to set the console encoding to display non-ASCII characters correctly (eg the 
            //  Latin A-Extended characters such as ĀāĒē...).
            Console.OutputEncoding = Encoding.UTF8;

            // Will also need to set the console font (in the console Properties dialog) to a font 
            //  that displays the extended character set correctly.
            // The following fonts all display the extended characters correctly:
            //  Consolas
            //  DejaVu Sana Mono
            //  Lucida Console

            // Also, in the console Properties, set the Screen Buffer Size and the Window Size 
            //  Width properties to at least 140 characters, to display the full width of the 
            //  table that is generated.

            Dictionary<string, Func<string, string>> columnDetails =
                new Dictionary<string, Func<string, string>>();
            columnDetails.Add("Unencoded", (unencodedString => unencodedString));
            columnDetails.Add("UrlEncoded",
                (unencodedString => HttpUtility.UrlEncode(unencodedString)));
            columnDetails.Add("UrlEncodedUnicode",
                (unencodedString => HttpUtility.UrlEncodeUnicode(unencodedString)));
            columnDetails.Add("UrlPathEncoded",
                (unencodedString => HttpUtility.UrlPathEncode(unencodedString)));
            columnDetails.Add("EscapedDataString",
                (unencodedString => Uri.EscapeDataString(unencodedString)));
            columnDetails.Add("EscapedUriString",
                (unencodedString => Uri.EscapeUriString(unencodedString)));
            columnDetails.Add("HtmlEncoded",
                (unencodedString => HttpUtility.HtmlEncode(unencodedString)));
            columnDetails.Add("HtmlAttributeEncoded",
                (unencodedString => HttpUtility.HtmlAttributeEncode(unencodedString)));
            columnDetails.Add("HexEscaped",
                (unencodedString
                    =>
                    {
                        // Uri.HexEscape can only handle the first 255 characters so for the 
                        //  Latin A-Extended characters, such as A, it will throw an 
                        //  ArgumentOutOfRange exception.                       
                        try
                        {
                            return Uri.HexEscape(unencodedString.ToCharArray()[0]);
                        }
                        catch
                        {
                            return "[OoR]";
                        }
                    }));

            char[] charactersToEncode = stringToEncode.ToCharArray();
            string[] stringCharactersToEncode = Array.ConvertAll<char, string>(charactersToEncode,
                (character => character.ToString()));
            DisplayCharacterTable<string>(stringCharactersToEncode, columnDetails);
        }

        private static void DisplayCharacterTable<TUnencoded>(TUnencoded[] unencodedArray,
            Dictionary<string, Func<TUnencoded, string>> mappings)
        {
            foreach (string key in mappings.Keys)
            {
                Console.Write(key.Replace(" ", "[space]") + " ");
            }
            Console.WriteLine();

            foreach (TUnencoded unencodedObject in unencodedArray)
            {
                string stringCharToEncode = unencodedObject.ToString();
                foreach (string columnHeader in mappings.Keys)
                {
                    int columnWidth = columnHeader.Length + 1;
                    Func<TUnencoded, string> encoder = mappings[columnHeader];
                    string encodedString = encoder(unencodedObject);

                    // ASSUMPTION: Column header will always be wider than encoded string.
                    Console.Write(encodedString.Replace(" ", "[space]").PadRight(columnWidth));
                }
                Console.WriteLine();
            }
        }
    }
}

Vous devez encoder uniquement le nom d'utilisateur ou une autre partie de l'URL qui pourrait être invalide. L'URL encodant une URL peut entraîner des problèmes car quelque chose comme ceci:

string url = HttpUtility.UrlEncode("http://www.google.com/search?q=Example");

Rendra

http% 3a% 2f% 2fwww.google.com% 2fsearch% 3fq% 3dExample

Cela ne fonctionnera évidemment pas bien. Au lieu de cela, vous devez encoder UNIQUEMENT la valeur de la paire clé / valeur dans la chaîne de requête, comme ceci:

string url = "http://www.google.com/search?q=" + HttpUtility.UrlEncode("Example");

J'espère que cela aide. De plus, comme l' a mentionné teedyay , vous devrez toujours vous assurer que les caractères de nom de fichier illégaux sont supprimés, sinon le système de fichiers n'aimera pas le chemin.

La meilleure façon est d'utiliser

Uri.EscapeUriString

pour ne pas référencer le profil complet de .net 4.

Depuis .NET Framework 4.5 et .NET Standard 1.0, vous devez utiliser WebUtility.UrlEncode. Avantages par rapport aux alternatives:

1. Il fait partie de .NET Framework 4.5+, .NET Core 1.0+, .NET Standard 1.0+, UWP 10.0+ et de toutes les plates-formes Xamarin. HttpUtility, tout en étant disponible dans .NET Framework plus tôt (.NET Framework 1.1+), devient disponible sur d'autres plateformes beaucoup plus tard (.NET Core 2.0+, .NET Standard 2.0+) et il n'est toujours pas disponible dans UWP (voir la question connexe ).

2. Dans .NET Framework, il réside dansSystem.dll , il ne nécessite donc pas de références supplémentaires, contrairement à HttpUtility.

3. Il échappe correctement les caractères pour les URL , contrairement à Uri.EscapeUriString(voir les commentaires de la réponse de drweb86 ).

4. Il n'a pas de limite sur la longueur de la chaîne , contrairement à Uri.EscapeDataString(voir question connexe ), il peut donc être utilisé pour les requêtes POST, par exemple.

Levi Botelho a indiqué que le tableau des encodages précédemment généré n'est plus précis pour .NET 4.5, car les encodages ont légèrement changé entre .NET 4.0 et 4.5. J'ai donc régénéré la table pour .NET 4.5:

Unencoded UrlEncoded UrlEncodedUnicode UrlPathEncoded WebUtilityUrlEncoded EscapedDataString EscapedUriString HtmlEncoded HtmlAttributeEncoded WebUtilityHtmlEncoded HexEscaped
A         A          A                 A              A                    A                 A                A           A                    A                     %41
B         B          B                 B              B                    B                 B                B           B                    B                     %42

a         a          a                 a              a                    a                 a                a           a                    a                     %61
b         b          b                 b              b                    b                 b                b           b                    b                     %62

0         0          0                 0              0                    0                 0                0           0                    0                     %30
1         1          1                 1              1                    1                 1                1           1                    1                     %31

[space]   +          +                 %20            +                    %20               %20              [space]     [space]              [space]               %20
!         !          !                 !              !                    %21               !                !           !                    !                     %21
"         %22        %22               "              %22                  %22               %22              "      "               "                %22
#         %23        %23               #              %23                  %23               #                #           #                    #                     %23
$         %24        %24               $              %24                  %24               $                $           $                    $                     %24
%         %25        %25               %              %25                  %25               %25              %           %                    %                     %25
&         %26        %26               &              %26                  %26               &                &       &                &                 %26
'         %27        %27               '              %27                  %27               '                '       '                '                 %27
(         (          (                 (              (                    %28               (                (           (                    (                     %28
)         )          )                 )              )                    %29               )                )           )                    )                     %29
*         *          *                 *              *                    %2A               *                *           *                    *                     %2A
+         %2b        %2b               +              %2B                  %2B               +                +           +                    +                     %2B
,         %2c        %2c               ,              %2C                  %2C               ,                ,           ,                    ,                     %2C
-         -          -                 -              -                    -                 -                -           -                    -                     %2D
.         .          .                 .              .                    .                 .                .           .                    .                     %2E
/         %2f        %2f               /              %2F                  %2F               /                /           /                    /                     %2F
:         %3a        %3a               :              %3A                  %3A               :                :           :                    :                     %3A
;         %3b        %3b               ;              %3B                  %3B               ;                ;           ;                    ;                     %3B
<         %3c        %3c               <              %3C                  %3C               %3C              &lt;        &lt;                 &lt;                  %3C
=         %3d        %3d               =              %3D                  %3D               =                =           =                    =                     %3D
>         %3e        %3e               >              %3E                  %3E               %3E              &gt;        >                    &gt;                  %3E
?         %3f        %3f               ?              %3F                  %3F               ?                ?           ?                    ?                     %3F
@         %40        %40               @              %40                  %40               @                @           @                    @                     %40
[         %5b        %5b               [              %5B                  %5B               [                [           [                    [                     %5B
\         %5c        %5c               \              %5C                  %5C               %5C              \           \                    \                     %5C
]         %5d        %5d               ]              %5D                  %5D               ]                ]           ]                    ]                     %5D
^         %5e        %5e               ^              %5E                  %5E               %5E              ^           ^                    ^                     %5E
_         _          _                 _              _                    _                 _                _           _                    _                     %5F
`         %60        %60               `              %60                  %60               %60              `           `                    `                     %60
{         %7b        %7b               {              %7B                  %7B               %7B              {           {                    {                     %7B
|         %7c        %7c               |              %7C                  %7C               %7C              |           |                    |                     %7C
}         %7d        %7d               }              %7D                  %7D               %7D              }           }                    }                     %7D
~         %7e        %7e               ~              %7E                  ~                 ~                ~           ~                    ~                     %7E

Ā         %c4%80     %u0100            %c4%80         %C4%80               %C4%80            %C4%80           Ā           Ā                    Ā                     [OoR]
ā         %c4%81     %u0101            %c4%81         %C4%81               %C4%81            %C4%81           ā           ā                    ā                     [OoR]
Ē         %c4%92     %u0112            %c4%92         %C4%92               %C4%92            %C4%92           Ē           Ē                    Ē                     [OoR]
ē         %c4%93     %u0113            %c4%93         %C4%93               %C4%93            %C4%93           ē           ē                    ē                     [OoR]
Ī         %c4%aa     %u012a            %c4%aa         %C4%AA               %C4%AA            %C4%AA           Ī           Ī                    Ī                     [OoR]
ī         %c4%ab     %u012b            %c4%ab         %C4%AB               %C4%AB            %C4%AB           ī           ī                    ī                     [OoR]
Ō         %c5%8c     %u014c            %c5%8c         %C5%8C               %C5%8C            %C5%8C           Ō           Ō                    Ō                     [OoR]
ō         %c5%8d     %u014d            %c5%8d         %C5%8D               %C5%8D            %C5%8D           ō           ō                    ō                     [OoR]
Ū         %c5%aa     %u016a            %c5%aa         %C5%AA               %C5%AA            %C5%AA           Ū           Ū                    Ū                     [OoR]
ū         %c5%ab     %u016b            %c5%ab         %C5%AB               %C5%AB            %C5%AB           ū           ū                    ū                     [OoR]

Les colonnes représentent les encodages comme suit:

• UrlEncoded: HttpUtility.UrlEncode
• UrlEncodedUnicode: HttpUtility.UrlEncodeUnicode
• UrlPathEncoded: HttpUtility.UrlPathEncode
• WebUtilityUrlEncoded: WebUtility.UrlEncode
• EscapedDataString: Uri.EscapeDataString
• EscapedUriString: Uri.EscapeUriString
• HtmlEncoded: HttpUtility.HtmlEncode
• HtmlAttributeEncoded: HttpUtility.HtmlAttributeEncode
• WebUtilityHtmlEncoded: WebUtility.HtmlEncode
• HexEscaped: Uri.HexEscape

REMARQUES:

1. HexEscape ne peut gérer que les 255 premiers caractères. Par conséquent, il lève une exception ArgumentOutOfRange pour les caractères latins A étendus (par exemple, Ā).

2. Ce tableau a été généré dans .NET 4.5 (voir la réponse https://stackoverflow.com/a/11236038/216440 pour les encodages pertinents pour .NET 4.0 et ci-dessous).

ÉDITER:

1. À la suite de la réponse de Discord, j'ai ajouté les nouvelles méthodes WebUtility UrlEncode et HtmlEncode, qui ont été introduites dans .NET 4.5.

L'encodage d'URL est facile dans .NET. Utilisation:

System.Web.HttpUtility.UrlEncode(string url)

Si cela va être décodé pour obtenir le nom du dossier, vous devrez toujours exclure les caractères qui ne peuvent pas être utilisés dans les noms de dossier (*,?, /, Etc.)

Si vous ne voyez pas System.Web, modifiez les paramètres de votre projet. Le cadre cible doit être ".NET Framework 4" au lieu de ".NET Framework 4 Client Profile"

L'implémentation .NET de UrlEncoden'est pas conforme à la RFC 3986.

1. Certains caractères ne sont pas codés mais devraient l'être. Les !()*caractères sont répertoriés dans la section 2.2 du RFC en tant que caractères réservés qui doivent être codés mais .NET ne parvient pas à coder ces caractères.

2. Certains caractères sont encodés mais ne devraient pas l'être. Les .-_caractères ne sont pas répertoriés dans la section 2.2 de la RFC en tant que caractère réservé qui ne doit pas encore être codé .NET code à tort ces caractères.

3. Le RFC spécifie que pour être cohérent, les implémentations doivent utiliser HEXDIG en majuscules, où .NET produit HEXDIG en minuscules.

Je pense que les gens ici ont été détournés par le message UrlEncode. L'URLEncoding n'est pas ce que vous voulez - vous voulez encoder des choses qui ne fonctionneront pas comme nom de fichier sur le système cible.

En supposant que vous vouliez une généralité - n'hésitez pas à trouver les caractères illégaux sur plusieurs systèmes (MacOS, Windows, Linux et Unix), réunissez-les pour former un ensemble de caractères à échapper.

Quant à l'évasion, un HexEscape devrait être bien (Remplacement des caractères par% XX). Convertissez chaque caractère en octets UTF-8 et encodez tout> 128 si vous souhaitez prendre en charge les systèmes qui ne font pas unicode. Mais il existe d'autres moyens, tels que l'utilisation de barres obliques inverses "\" ou d'encodage HTML "" ". Vous pouvez créer le vôtre. Tout système doit tout simplement" coder "le caractère incompatible. Les systèmes ci-dessus vous permettent de recréer le nom d'origine - mais quelque chose comme remplacer les mauvais caractères par des espaces fonctionne également.

Sur la même tangente que ci-dessus, la seule à utiliser est

Uri.EscapeDataString

- Il code tout ce qui est nécessaire pour OAuth, il ne code pas les choses que OAuth interdit de coder, et code l'espace en% 20 et non + (également dans la spécification OATH) Voir: RFC 3986. AFAIK, c'est le dernière spécification d'URI.

J'ai écrit une méthode C # qui encode tous les symboles par URL:

    /// <summary>
    /// !#$345Hf} → %21%23%24%33%34%35%48%66%7D
    /// </summary>
    public static string UrlEncodeExtended( string value )
    {
        char[] chars = value.ToCharArray();
        StringBuilder encodedValue = new StringBuilder();
        foreach (char c in chars)
        {
            encodedValue.Append( "%" + ( (int)c ).ToString( "X2" ) );
        }
        return encodedValue.ToString();
    }

Idéalement, ceux-ci iraient dans une classe appelée "FileNaming" ou peut-être simplement renommer Encode en "FileNameEncode". Remarque: ceux-ci ne sont pas conçus pour gérer les chemins d'accès complets, uniquement les noms de dossier et / ou de fichier. Idéalement, vous diviseriez ("/") votre chemin complet en premier, puis vérifieriez les morceaux. Et évidemment, au lieu d'une union, vous pouvez simplement ajouter le caractère "%" à ​​la liste des caractères non autorisés dans Windows, mais je pense que c'est plus utile / lisible / factuel de cette façon. Decode () est exactement le même mais commute le Replace (Uri.HexEscape (s [0]), s) "échappé" avec le caractère.

public static List<string> urlEncodedCharacters = new List<string>
{
  "/", "\\", "<", ">", ":", "\"", "|", "?", "%" //and others, but not *
};
//Since this is a superset of urlEncodedCharacters, we won't be able to only use UrlEncode() - instead we'll use HexEncode
public static List<string> specialCharactersNotAllowedInWindows = new List<string>
{
  "/", "\\", "<", ">", ":", "\"", "|", "?", "*" //windows dissallowed character set
};

    public static string Encode(string fileName)
    {
        //CheckForFullPath(fileName); // optional: make sure it's not a path?
        List<string> charactersToChange = new List<string>(specialCharactersNotAllowedInWindows);
        charactersToChange.AddRange(urlEncodedCharacters.
            Where(x => !urlEncodedCharacters.Union(specialCharactersNotAllowedInWindows).Contains(x)));   // add any non duplicates (%)

        charactersToChange.ForEach(s => fileName = fileName.Replace(s, Uri.HexEscape(s[0])));   // "?" => "%3f"

        return fileName;
    }

Merci @ simon-tewsi pour le tableau très utile ci-dessus!

En plus de la réponse de @Dan Herbert, vous nous devriez encoder uniquement les valeurs en général.

Split a le paramètre params Split ('&', '='); expression d'abord divisée par & puis '=' donc les éléments impairs sont toutes les valeurs à encoder indiquées ci-dessous.

public static void EncodeQueryString(ref string queryString)
{
    var array=queryString.Split('&','=');
    for (int i = 0; i < array.Length; i++) {
        string part=array[i];
        if(i%2==1)
        {               
            part=System.Web.HttpUtility.UrlEncode(array[i]);
            queryString=queryString.Replace(array[i],part);
        }
    }
}