Encodage d'URL en utilisant C #
J'ai une application qui envoie une demande POST au logiciel de forum VB et connecte quelqu'un (sans configurer de cookies ni quoi que ce soit).
Une fois que l'utilisateur est connecté, je crée une variable qui crée un chemin sur sa machine locale.
c:\tempfolder\date\nom d'utilisateur
Le problème est que certains noms d'utilisateurs génèrent une exception "Illegal chars". Par exemple, si mon nom d'utilisateur était mas|fenix, une exception serait levée.
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è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 suis pas sûr que Linux l’accepte ou non.
EDIT: Il semble que l'encodage 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 permettant d'identifier facilement le caractère.
Edit: Notez que cette réponse est maintenant obsolète. Voir La réponse de Siarhei Kuchuk ci-dessous pour une meilleure solution
UrlEncoding fera ce que vous suggérez ici. Avec C #, vous utilisez simplement HttpUtility, comme mentionné.
Vous pouvez aussi utiliser Regex les caractères illégaux, puis les remplacer, mais cela devient beaucoup plus complexe, car vous devrez utiliser une machine d'état (casse switch ..., par exemple) pour la remplacer par les caractères corrects. Puisque UrlEncode le fait à l’avance, c’est plutôt facile.
En ce qui concerne Linux par rapport à Windows, certains caractères acceptables sous Linux ne le sont pas sous Windows, mais je ne m'inquiète pas pour autant. Le nom du dossier peut être renvoyé en décodant la chaîne Url, à l'aide de UrlDecode, afin que vous puissiez effectuer un aller-retour. les changements.
J'ai déjà expérimenté différentes méthodes .NET pour l'encodage d'URL. Peut-être que le tableau suivant sera utile (comme 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 < < %3C
= %3d %3d = %3D = = = %3D
> %3e %3e > %3E %3E > > %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.UrlEncodeUrlEncodedUnicode:
HttpUtility.UrlEncodeUnicodeUrlPathEncoded:
HttpUtility.UrlPathEncodeEscapedDataString:
Uri.EscapeDataStringEscapedUriString:
Uri.EscapeUriStringHtmlEncoded:
HttpUtility.HtmlEncodeHtmlAttributeEncoded:
HttpUtility.HtmlAttributeEncodeHexEscaped:
Uri.HexEscape
REMARQUES:
HexEscapene peut gérer que les 255 premiers caractères. Par conséquent, il lève une exceptionArgumentOutOfRangepour les caractères latins A étendus (par exemple, Â).Ce tableau a été généré dans .NET 4.0 (voir le commentaire de Levi Botelho ci-dessous indiquant que le codage dans .NET 4.5 est légèrement différent).
MODIFIER:
J'ai ajouté un deuxième tableau avec les encodages pour .NET 4.5. Voir cette réponse: https://stackoverflow.com/a/21771206/216440
EDIT 2:
Comme les gens semblent apprécier ces tables, j'ai pensé que vous aimeriez peut-être le code source qui génère la table, afin que vous puissiez vous amuser. C'est une simple application console C #, qui peut cibler .NET 4.0 ou 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 ne devez encoder que le nom d'utilisateur ou une autre partie de l'URL qui pourrait être invalide. Le codage d’URL d’une URL peut entraîner des problèmes puisque quelque chose comme ceci:
string url = HttpUtility.UrlEncode("http://www.google.com/search?q=Example");
Va céder
http% 3a% 2f% 2fwww.google.com% 2fsearch% 3fq% 3dExample
Cela ne va évidemment pas bien fonctionner. Au lieu de cela, vous devriez 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");
Espérons que cela aide. De plus, comme indiqué dans 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'appréciera pas le chemin.
Une meilleure façon est d'utiliser
ne pas faire référence au 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:
Il fait partie de .NET Framework 4.5+, .NET Core 1.0+, .NET Standard 1.0+, UWP 10.0+ et de toutes les plateformes Xamarin.
HttpUtility, alors qu’il était disponible dans .NET Framework plus tôt (.NET Framework 1.1+), deviendra disponible sur d’autres plates-formes bien plus tard (.NET Core 2.0+, .NET Standard 2.0+) et ne sera toujours pas disponible dans UWP (voir question liée ).Dans .NET Framework, il réside dans
System.dll, de sorte qu'il ne nécessite aucune référence supplémentaire, contrairement àHttpUtility.Il échappe correctement aux caractères pour les URL, contrairement à
Uri.EscapeUriString(voir les commentaires sur la réponse de drweb86 ).Il n'a pas de limite de longueur, contrairement à
Uri.EscapeDataString(voir related related ), il peut donc être utilisé pour les demandes POST, par exemple.
Levi Botelho a fait remarquer que la table des codages générée précédemment n’était plus exacte pour .NET 4.5, car les codages avaient 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 < < < %3C
= %3d %3d = %3D %3D = = = = %3D
> %3e %3e > %3E %3E %3E > > > %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:
HexEscape ne peut gérer que les 255 premiers caractères. Par conséquent, une exception ArgumentOutOfRange est générée pour les caractères latins A étendus (par exemple, Â).
Ce tableau a été généré dans .NET 4.5 (voir la réponse https://stackoverflow.com/a/11236038/216440 pour connaître les codages pertinents pour .NET 4.0 et versions ultérieures).
MODIFIER:
- Suite à la réponse de Discord, j'ai ajouté les nouvelles méthodes WebUtility UrlEncode et HtmlEncode, introduites dans .NET 4.5.
Le codage d'URL est facile dans .NET. Utilisation:
System.Web.HttpUtility.UrlEncode(string url)
Si cela sera 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 dossiers (*,?, /, Etc.).
Si vous ne voyez pas System.Web, modifiez les paramètres de votre projet. L'infrastructure cible doit être ".NET Framework 4" au lieu de ".NET Framework 4 Client Profile".
L'implémentation .NET de UrlEncode n'est pas conforme à RFC 3986.
Certains caractères ne sont pas encodés mais devraient l'être. Les caractères
!()*sont répertoriés dans la section 2.2 de la RFC en tant que caractères réservés qui doivent être codés, mais .NET ne parvient pas à coder ces caractères.Certains caractères sont codé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 encodé. NET encode par erreur ces caractères.Le RFC spécifie que, pour être cohérent, les implémentations doivent utiliser HEXDIG en majuscule, où .NET produit un HEXDIG en minuscule.
Idéalement, ceux-ci iraient dans une classe appelée "FileNaming" ou simplement renommer Encode en "FileNameEncode". Remarque: ils ne sont pas conçus pour gérer les chemins d'accès complets, mais uniquement les noms de dossiers et/ou de fichiers. Idéalement, vous scindiez ("/") votre chemin complet en premier, puis vérifiez les pièces . Et bien é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 bascule le caractère Remplacer (Uri.HexEscape (s [0]), s).
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!
J'ai écrit une méthode C # qui code l'URL pour tous les symboles:
/// <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();
}
En plus de la réponse de @Dan Herbert, .__, vous devez coder uniquement les valeurs en général.
Split a le paramètre params Split ('&', '='); Les expressions d'abord divisées par & then '=', les éléments impairs sont toutes les valeurs à coder, comme indiqué 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);
}
}
}
Je pense que les gens ici ont été distraits par le message UrlEncode. URLEncoding est pas ce que vous voulez - vous voulez encoder des choses qui ne fonctionneront pas comme un nom de fichier sur le système cible.
En supposant que vous souhaitiez avoir une certaine généralité - n'hésitez pas à rechercher les caractères non autorisés sur plusieurs systèmes (MacOS, Windows, Linux et Unix), réunissez-les pour former un ensemble de caractères à échapper.
En ce qui concerne l’échappement, un HexEscape devrait suffire (remplacement des caractères par% XX). Convertissez chaque caractère en octets UTF-8 et encodez tout ce qui est> 128 si vous souhaitez prendre en charge des systèmes qui ne font pas unicode. Mais il existe d'autres moyens, tels que l'utilisation de barres obliques inverses "\" ou d'un codage HTML "" ". Vous pouvez créer le vôtre. Tout ce que tout système a à faire est de" coder "le caractère incompatible à l'extérieur. Les systèmes ci-dessus vous permettent de recréer le nom original - mais quelque chose comme remplacer les mauvais caractères par des espaces fonctionne aussi.
Sur la même tangente que ci-dessus, le seul à utiliser est
Uri.EscapeDataString
- Il code tout ce qui est nécessaire pour OAuth, il ne code pas les éléments interdits par OAuth, et code l'espace en tant que% 20 et non + (également dans la spécification OATH). Voir: RFC 3986. AFAIK, il s'agit du dernière spécification d'URI.