La Codifica URL utilizzando C#
https://stackoverflow.com/questions/575440
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianDomanda
Ho un'applicazione che invia una richiesta POST di VB forum software e registri di qualcuno (senza impostare i cookie o altro).
Una volta che l'utente è connesso, ho creato una variabile che crea un percorso sul computer locale.
c: empfolder\date\username
Il problema è che alcuni nomi sono di lancio "Illegale chars" eccezione.Per esempio se il mio nome utente è stato mas|fenix genererà un'eccezione..
Path.Combine( _
Environment.GetFolderPath(System.Environment.SpecialFolder.CommonApplicationData), _
DateTime.Now.ToString("ddMMyyhhmm") + "-" + form1.username)
Non voglio rimuoverlo dalla stringa, ma una cartella con il suo nome utente viene creato tramite FTP su un server.E questo porta alla mia seconda domanda.Se io sono la creazione di una cartella sul server posso lasciare il "illegale chars" in?Chiedo solo questo, perché il server è basato su Linux, e non so se Linux accetta o no.
EDIT:Sembra che la URL encode NON è quello che voglio..Ecco cosa voglio fare:
old username = mas|fenix
new username = mas%xxfenix
Dove %xx è il valore ASCII o qualsiasi altro valore che sarebbe facilmente identificare il personaggio.
Soluzione
Modifica: Si noti che questa risposta è ormai fuori moda. Vedi la risposta di Siarhei Kuchuk sotto per una correzione migliore
urlencoding farà quello che si sta suggerendo qui. Con C #, è sufficiente utilizzare HttpUtility, come detto.
È anche possibile regex i caratteri non validi e quindi sostituire, ma questo diventa molto più complesso, in quanto si dovrà avere una qualche forma di macchina a stati (interruttore ... caso, per esempio) per sostituirli con i caratteri corretti. Dal momento che UrlEncode fa su questo fronte, è piuttosto facile.
Per quanto riguarda Linux contro Windows, ci sono alcuni personaggi che sono accettabili in Linux che non sono in Windows, ma io non mi preoccuperei che, come il nome della cartella può essere restituito decodificando la stringa URL, utilizzando UrlDecode, in modo da può Round Trip le modifiche.
Altri suggerimenti
Ho avuto modo di sperimentare con i vari metodi di .NET fornire per la codifica URL. Forse la tabella che segue sarà utile (come uscita da un applicazione di test che ho scritto):
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]
Le colonne rappresentano codifiche come segue:
-
urlencoded:
HttpUtility.UrlEncode -
UrlEncodedUnicode:
HttpUtility.UrlEncodeUnicode -
UrlPathEncoded:
HttpUtility.UrlPathEncode -
EscapedDataString:
Uri.EscapeDataString -
EscapedUriString:
Uri.EscapeUriString -
HtmlEncoded:
HttpUtility.HtmlEncode -
HtmlAttributeEncoded:
HttpUtility.HtmlAttributeEncode -
HexEscaped:
Uri.HexEscape
Note:
-
HexEscapepuò gestire solo i primi 255 caratteri. Quindi viene generata un'eccezioneArgumentOutOfRangeper i personaggi latina A-estesi (ad esempio A). -
Questa tabella è stata generata in .NET 4.0 (vedi il commento di Levi Botelho sotto che dice la codifica in .NET 4.5 è leggermente diverso).
Modifica
Ho una seconda tabella con le codifiche per .NET 4.5. Vedere questa risposta: https://stackoverflow.com/a/21771206/216440
EDIT 2:
Dal momento che le persone sembrano apprezzare queste tabelle, ho pensato che ti avrebbe fatto piacere il codice sorgente che genera il tavolo, in modo da poter giocare voi stessi. Si tratta di una semplice applicazione console C #, che può avere come bersaglio sia .NET 4.0 o 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();
}
}
}
}
Si dovrebbe codificare solo il nome utente o dell'altra parte dell'URL che potrebbe non essere valido.La codifica URL un URL può portare a dei problemi, in quanto qualcosa di simile a questo:
string url = HttpUtility.UrlEncode("http://www.google.com/search?q=Example");
Verrà resa
http%3a%2f%2fwww.google.com%2fsearch%3fq%3dExample
Questo è, ovviamente, non sta andando a lavorare bene.Invece, si dovrebbe codificare SOLO il valore della coppia chiave/valore nella stringa di query come questa:
string url = "http://www.google.com/search?q=" + HttpUtility.UrlEncode("Example");
Spero che aiuta.Inoltre, come teedyay detto, è comunque necessario assicurarsi di file illegali-i caratteri del nome rimosso o altro file di sistema non piace il percorso.
Da .NET Framework 4.5 e .NET standard 1.0 è necessario utilizzare WebUtility.UrlEncode . Vantaggi rispetto alternative:
-
E 'parte del .NET Framework 4.5+, .NET Nucleo 1.0+, .NET standard 1.0+, UWP 10.0+ e tutte le piattaforme Xamarin pure.
HttpUtility, pur essendo disponibili in .NET Framework in precedenza (.NET Framework 1.1 +), diventa disponibile su altre piattaforme molto più tardi (NET Nucleo 2.0+, NET standard 2.0 +) ed è ancora disponibile in UWP (vedere Relativo alla domanda ). -
In .NET Framework, è risiede in
System.dll, in modo che non richiede alcuna ulteriori riferimenti, a differenzaHttpUtility. -
sfugge correttamente i caratteri per gli URL , a differenza
Uri.EscapeUriString(vedi commenti di risposta di drweb86 ). -
non ha limiti alla lunghezza della stringa , a differenza
Uri.EscapeDataString(vedi domanda relativa ), in modo che possa essere utilizzato per le richieste POST, per esempio.
modo migliore è quello di utilizzare
di non fare riferimento Profilo completa di .NET 4.
Levi Botelho ha commentato che la tabella di codifiche che è stato precedentemente generato non è più accurata è per .NET 4.5, dal momento che le codifiche cambiati leggermente tra .NET 4.0 e 4.5. Così ho rigenerato la tavola per .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]
Le colonne rappresentano codifiche come segue:
- 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
Note:
-
HexEscape può gestire solo i primi 255 caratteri. Quindi viene generata un'eccezione ArgumentOutOfRange per i personaggi latina A-estesi (ad esempio A).
-
Questa tabella è stata generata in .NET 4.5 (vedi risposta https://stackoverflow.com/a/11236038/216440 per le codifiche rilevanti per .NET 4.0 e sotto).
Modifica
- A seguito della risposta di Discord ho aggiunto i nuovi metodi WebUtility URLEncode e HTMLEncode, che sono state introdotte in .NET 4.5.
URL codifica è facile in .NET. Usa:
System.Web.HttpUtility.UrlEncode(string url)
Se che sarà decodificato per ottenere il nome della cartella, sarà ancora bisogno di escludere caratteri che non possono essere utilizzati nei nomi delle cartelle (*,?, /, Ecc.)
Se non riesci a vedere System.Web, modificare le impostazioni del progetto. Il framework di destinazione dovrebbe essere ".NET Framework 4" invece di" .NET Framework 4 Client Profile "
L'applicazione .NET di UrlEncode non è conforme RFC 3986.
-
Alcuni caratteri non sono codificati, ma dovrebbero essere. I caratteri
!()*sono elencati nella sezione della RFC 2.2 come caratteri riservati che devono essere codificati ancora .NET non riesce a codificare questi caratteri. -
Alcuni caratteri sono codificati, ma non dovrebbe essere. I caratteri
.-_non sono elencati nella sezione della RFC 2.2 come un carattere riservato che non dovrebbe essere ancora codificato NET codifica erroneamente questi personaggi. -
Il RFC specifica che, per essere coerente, implementazioni dovrebbe in maiuscolo HEXDIG, dove NET produce minuscole HEXDIG.
Ho scritto un metodo C # che url-codifica tutti i simboli:
/// <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();
}
Idealmente questi sarebbe andato in una classe denominata "filenaming" o forse solo rinominare Codifica "FileNameEncode". Nota: queste non sono progettati per gestire percorsi completi, solo la cartella e / o nomi di file. Idealmente si dovrebbe Split ( "/") il percorso completo e poi controllare i pezzi. E ovviamente invece di un sindacato, si può solo aggiungere il carattere "%" per l'elenco dei caratteri non consentiti in Windows, ma penso che sia più utile / leggibile / fatti in questo modo. Decode () è esattamente la stessa, ma cambia Sostituisci (Uri.HexEscape (s [0]), s) "scappati" con il carattere.
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;
}
Grazie @ Simon-tewsi per la tabella molto utile sopra!
In aggiunta alla risposta di @ Dan Herbert, Si abbiamo codificare solo i valori in generale.
Spalato ha params parametro Split ( '&', '='); espressione dapprima diviso da e quindi '=' elementi in modo dispari sono tutti i valori da codificare mostrati di seguito.
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);
}
}
}
Credo che la gente qui stati distratti dal messaggio UrlEncode. URLEncoding è non quello che vuoi -. Si vuole codificare roba che non funziona come un nome di file sul sistema di destinazione
Supponendo che si desidera qualche generalità -. Sentitevi liberi di trovare i personaggi illegali su diversi sistemi (MacOS, Windows, Linux e Unix), loro unione per formare un insieme di caratteri per sfuggire
Per quanto riguarda la fuga, un HexEscape dovrebbe andare bene (sostituendo i caratteri con% XX). Convertire ogni personaggio in UTF-8 byte e codificare tutto> 128 se si desidera supportare i sistemi che non fanno unicode. Ma ci sono altri modi, ad esempio utilizzando indietro barre "\" o HTML codifica """. È possibile creare il proprio. Tutto qualsiasi sistema deve fare è 'codifica' il personaggio uncompatible via. I sistemi di cui sopra consentono di ricreare il nome originale -. ma qualcosa di simile sostituendo i cattivi caratteri con spazi funziona anche
Lo stesso tangente come sopra, l'unico ad usare è
Uri.EscapeDataString
- Codifica tutto ciò che è necessario per OAuth, che non codifica le cose che OAuth vieta la codifica e codifica lo spazio come% 20 + e non (anche nel Spec GIURAMENTO) Vedi: RFC 3986. AFAIK, questa è l'ultima specifica URI.
