URL-Codierung mit C #
https://stackoverflow.com/questions/575440
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianFrage
Ich habe eine Anwendung, die eine POST-Anfrage an die VB-Forum-Software sendet und meldet sich jemand in (ohne Cookies oder irgendetwas einstellen).
Sobald der Benutzer angemeldet ist ich eine Variable erstellen, die einen Pfad auf ihrem lokalen Rechner erstellt.
c: \ TempFolder \ date \ Benutzername
Das Problem ist, dass einige Benutzernamen „Illegal Zeichen“ Ausnahme werfen. Zum Beispiel, wenn wurde mein Benutzername mas|fenix wäre es eine Ausnahme werfen ..
Path.Combine( _
Environment.GetFolderPath(System.Environment.SpecialFolder.CommonApplicationData), _
DateTime.Now.ToString("ddMMyyhhmm") + "-" + form1.username)
Ich will nicht, es aus der Zeichenfolge entfernen, aber ein Ordner mit ihrem Benutzername wird über FTP auf einem Server erstellt. Und das führt zu meiner zweiten Frage. Wenn ich einen Ordner auf dem Server erschaffe kann ich verlassen die „illegalen Zeichen“ in? Ich dies nur fragen, weil der Server Linux basiert, und ich bin nicht sicher, ob Linux es akzeptiert oder nicht.
EDIT: Es scheint, dass URL kodieren nicht das, was ich will .. Hier ist, was ich tun möchte:
old username = mas|fenix
new username = mas%xxfenix
Dabei steht% xx ist der ASCII-Wert oder einen anderen Wert, der den Charakter leicht erkennen würde.
Lösung
Edit: Beachten Sie, dass diese Antwort jetzt nicht mehr aktuell ist. Siehe Siarhei Kuchuk Antwort unten für eine bessere fix
urlencoding tun, was Sie vorschlagen hier. Mit C #, verwenden Sie einfach HttpUtility, wie erwähnt.
Sie können auch die ungültigen Zeichen Regex und dann ersetzen, aber das wird sehr viel komplexer, als Sie irgendeine Form von Zustandsmaschine haben, werden (Schalter ... Fall, zum Beispiel) mit den richtigen Zeichen zu ersetzen. Da UrlEncode dies tut vorne, es ist ziemlich einfach.
Wie bei Linux im Vergleich zu Windows gibt es einige Zeichen, die in Linux akzeptabel sind, die nicht in Windows verfügbar ist, aber ich würde darüber keine Sorgen machen, da die Ordnernamen durch Dekodieren des URL-String zurückgegeben werden können, UrlDecode verwenden, so dass Sie Reise um die Änderungen können.
Andere Tipps
Ich habe mit den verschiedenen Methoden experimentiert für URL-Codierung bieten .NET. Vielleicht ist die folgende Tabelle wird nützlich sein (als Ausgabe von einem Test-app ich schrieb):
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]
Die Spalten repräsentieren Kodierungen wie folgt:
-
UrlEncoded:
HttpUtility.UrlEncode -
UrlEncodedUnicode:
HttpUtility.UrlEncodeUnicode -
UrlPathEncoded:
HttpUtility.UrlPathEncode -
EscapedDataString:
Uri.EscapeDataString -
EscapedUriString:
Uri.EscapeUriString -
Htmlencoded:
HttpUtility.HtmlEncode -
HtmlAttributeEncoded:
HttpUtility.HtmlAttributeEncode -
HexEscaped:
Uri.HexEscape
NOTES:
-
HexEscapekönnen nur die ersten 255 Zeichen verarbeiten. Daher wirft sie eineArgumentOutOfRangeAusnahme für die Latin A-Extended-Zeichen (zB A). -
Diese Tabelle erzeugt wurde .NET 4.0 in (unten sehen, dass Levi Botelho Kommentar sagt der Codierung in .NET 4.5 ist etwas anders).
EDIT:
Ich habe eine zweite Tabelle mit den Codierungen für .NET 4.5 hinzugefügt. Sehen Sie diese Antwort: https://stackoverflow.com/a/21771206/216440
EDIT 2:
Da die Menschen diese Tabellen zu schätzen scheinen, ich dachte, Sie den Quellcode vielleicht gefallen, der die Tabelle erzeugt, so dass Sie sich um sich selbst zu spielen. Es ist eine einfache C # Konsole-Anwendung, die entweder .NET 4.0 oder 4.5 Ziel kann:
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();
}
}
}
}
Sie sollten nur den Benutzernamen oder einem anderen Teil der URL codieren, die ungültig sein könnte. URL eine URL-Codierung zu Problemen, da so etwas wie dies führen kann:
string url = HttpUtility.UrlEncode("http://www.google.com/search?q=Example");
Wird ergeben
http% 3a% 2f% 2fwww.google.com% 2fsearch% 3fq% 3dExample
Das wird natürlich nicht gut funktionieren. Stattdessen sollten Sie nur den Wert des Schlüssel / Wert-Paar in die Query-String kodieren, wie folgt aus:
string url = "http://www.google.com/search?q=" + HttpUtility.UrlEncode("Example");
Hoffentlich hilft. Auch, wie teedyay erwähnt, werden Sie immer noch sicher, dass illegale Datei vornehmen müssen -name Zeichen werden entfernt oder auch das Dateisystem den Pfad nicht mögen.
Da .NET Framework 4.5 und .NET Standard 1.0 Sie sollten WebUtility.UrlEncode . Vorteile gegenüber Alternativen:
-
Es ist ein Teil von .NET Framework 4.5+, .NET-Core 1.0+, .NET Standard-1.0+, UWP 10.0+ und alle auch Xamarin-Plattformen.
HttpUtility, während in .NET Framework zur Verfügung stehen früher (.NET Framework 1.1+), auf anderen Plattformen verfügbar wird viel später (.NET Kern 2.0+, .NET Standard-2.0+) und es in UWP noch nicht verfügbar (siehe bezogene Frage ). -
In .NET Framework, es befindet sich in
System.dll, so dass es keine weiteren Referenzen benötigt, im Gegensatz zuHttpUtility. -
richtig kodierter Zeichen für URLs , im Gegensatz zu
Uri.EscapeUriString(siehe Kommentare zu antworten der drweb86). -
Es hat keine Grenzen für die Länge der Zeichenfolge , im Gegensatz zu
Uri.EscapeDataString(siehe damit verbundene Frage ), so kann es für POST-Anfragen verwendet wird, zum Beispiel.
Levi Botelho kommentierte, dass die Tabelle der Codierungen, die zuvor erzeugt wurde, ist nicht mehr genau für .NET 4.5, da die Codierungen leicht zwischen .NET 4.0 und 4.5 geändert. Also habe ich die Tabelle regeneriert für .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]
Die Spalten repräsentieren Kodierungen wie folgt:
- 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
NOTES:
-
HexEscape können nur die ersten 255 Zeichen verarbeiten. Daher wirft sie eine ArgumentOutOfRange Ausnahme für die Latin A-Extended-Zeichen (zB A).
-
Diese Tabelle wurde erstellt in .NET 4.5 (siehe Antwort https://stackoverflow.com/a/11236038/216440 für die Codierungen relevant zu .NET 4.0 und unten).
EDIT:
- Als Ergebnis der Zwietracht Antwort habe ich die neuen WebUtility UrlEncode und Htmlencode Methoden, die 4,5 .NET in eingeführt wurden.
Die URL-Codierung ist in .NET einfach. Verwendung:
System.Web.HttpUtility.UrlEncode(string url)
Wenn das decodiert werden werde die Ordnernamen zu bekommen, werden Sie noch Zeichen ausschließen müssen, die nicht in Ordnernamen verwendet werden kann (*,?, / Etc.)
Wenn Sie nicht System.Web sehen können, Ihre Projekteinstellungen ändern. Der Zielrahmen sollte ".NET Framework 4" anstelle von" .NET Framework 4 Client Profile "sein
Die .NET-Implementierung von UrlEncode nicht entspricht RFC 3986.
-
Einige Zeichen nicht codiert, sondern sollte. Die
!()*Zeichen werden in den RFCs Abschnitt 2.2 als reservierte Zeichen aufgelistet, die noch codiert werden müssen .NET nicht diese Zeichen kodieren. -
Einige Zeichen codiert sind, aber nicht sein sollte. Die
.-_Zeichen nicht in den RFCs Abschnitt 2.2 als reserviertes Zeichen aufgeführt sind, die noch nicht codiert werden sollte .NET codiert fälschlicherweise diese Zeichen. -
Die RFC dass konsistent zu sein gibt, sollten Implementierungen verwenden Groß- HEXDIG, wo .NET Klein HEXDIG produziert.
Ich habe eine C # Methode geschrieben, die URL-kodiert alle Symbole:
/// <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();
}
Im Idealfall in einer Klasse gehen würde diese „Dateibenennungs“ genannt oder vielleicht auch nur Encode umbenennen zu „FileNameEncode“. Hinweis: dies sind nicht in volle Pfade zu behandeln entworfen, einfach den Ordner und / oder Dateinamen. Im Idealfall würden Sie Split ( „/“) Ihren vollständigen Pfad zuerst und dann die Stücke prüfen. Und natürlich statt einer Vereinigung, können Sie fügen Sie einfach die Zeichen „%“ in die Liste der Zeichen in Windows nicht erlaubt, aber ich denke, es ist hilfreicher / lesbar / sachlich auf diese Weise. Decode () ist genau die gleiche, aber schaltet die Replace (Uri.HexEscape (s [0]), s) "entkommen" mit dem Charakter.
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;
}
Danke @ simon-tewsi für die sehr nützlich Tabelle oben!
Neben @ Dan Herbert Antwort, Sie wir sollten in der Regel nur die Werte kodieren.
Split hat params Parameter Split ( '&', '='); Expression zunächst geteilt durch & Then ‚=‘ so ungeradee Elemente sind alle Werte unten gezeigt codiert werden.
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);
}
}
}
Ich glaube, die Leute hier durch die UrlEncode Nachricht abgelenkt wurde. Urlencoding ist nicht , was Sie wollen -. Sie stopfen kodieren möchten, die auf dem Zielsystem als Dateiname wird nicht funktionieren
Unter der Annahme, dass Sie einige Allgemeinheit wollen -. Frei fühlen, die ungültigen Zeichen auf mehreren Systemen (MacOS, Windows, Linux und Unix) zu finden, die Vereinigung sie eine Reihe von Zeichen zu bilden, zu entkommen
Wie für die Flucht, sollte ein HexEscape in Ordnung sein (Ersetzen der Zeichen als% XX). Konvertieren Sie jedes Zeichen in UTF-8-Bytes und kodieren alles> 128, wenn Sie Systeme unterstützen möchten, die nicht Unicode tun. Aber es gibt auch andere Möglichkeiten, wie zum Beispiel Schrägstriche mit back „\“ oder HTML-Codierung „““. Sie selbst erstellen können. Alle jedes System tun muss, sind‚codieren‘der uncompatible Charakter entfernt. Die obigen Systeme ermöglichen es Ihnen, die neu zu erstellen ursprünglicher Name -. aber so etwas wie die schlechten Zeichen mit Leerzeichen ersetzen funktioniert auch
Auf der gleichen Tangente, wie oben, die nur eine zu verwenden ist
Uri.EscapeDataString
- Es alles kodiert, das für OAuth benötigt wird, ist es nicht die Dinge, kodieren, dass OAuth Codierung verbietet und codiert den Raum als% 20 und nicht + (auch in der OATH Spec) Siehe auch: RFC 3986. AFAIK, dies ist die aktuelle URI spec.
