URL-Codierung mit C #

Ich habe eine Anwendung, die eine POST-Anfrage an die VB-Forensoftware sendet und jemanden anmeldet (ohne Cookies oder ähnliches zu setzen).

Sobald der Benutzer angemeldet ist, erstelle ich eine Variable, die einen Pfad auf seinem lokalen Computer erstellt.

c: \ tempfolder \ date \ username

Das Problem ist, dass einige Benutzernamen die Ausnahme "Illegale Zeichen" auslösen. Wenn mein Benutzername beispielsweise wäre mas|fenix, würde dies eine Ausnahme auslösen.

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

Ich möchte es nicht aus der Zeichenfolge entfernen, aber ein Ordner mit ihrem Benutzernamen wird über FTP auf einem Server erstellt. Und das führt zu meiner zweiten Frage. Kann ich beim Erstellen eines Ordners auf dem Server die "unzulässigen Zeichen" belassen? Ich frage dies nur, weil der Server auf Linux basiert und ich nicht sicher bin, ob Linux dies akzeptiert oder nicht.

BEARBEITEN: Es scheint, dass die URL-Codierung NICHT das ist, was ich will. Folgendes möchte ich tun:

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

Wobei% xx der ASCII-Wert oder ein anderer Wert ist, der das Zeichen leicht identifizieren würde.

Bearbeiten: Beachten Sie, dass diese Antwort jetzt veraltet ist. Siehe Siarhei Kuchuks Antwort unten für eine bessere Lösung

UrlEncoding macht das, was Sie hier vorschlagen. Mit C # verwenden Sie einfach HttpUtility, wie erwähnt.

Sie können die unzulässigen Zeichen auch neu formulieren und dann ersetzen. Dies wird jedoch weitaus komplexer, da Sie eine Art Zustandsmaschine (z. B. Schalter ... Fall) benötigen, um sie durch die richtigen Zeichen zu ersetzen. Da UrlEncodedies im Vorfeld geschieht, ist es ziemlich einfach.

Was Linux im Vergleich zu Windows betrifft, gibt es einige Zeichen, die unter Linux akzeptabel sind und nicht unter Windows, aber ich würde mir darüber keine Sorgen machen, da der Ordnername durch Dekodieren der URL-Zeichenfolge mit zurückgegeben werden kann UrlDecode, sodass Sie die Zeichenfolge umgehen können Änderungen.

Ich habe mit den verschiedenen Methoden experimentiert, die .NET für die URL-Codierung bereitstellt. Vielleicht ist die folgende Tabelle nützlich (als Ausgabe einer von mir geschriebenen Test-App):

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]

Die Spalten stellen Codierungen wie folgt dar:

• UrlEncoded: HttpUtility.UrlEncode

• UrlEncodedUnicode: HttpUtility.UrlEncodeUnicode

• UrlPathEncoded: HttpUtility.UrlPathEncode

• EscapedDataString: Uri.EscapeDataString

• EscapedUriString: Uri.EscapeUriString

• HtmlEncoded: HttpUtility.HtmlEncode

• HtmlAttributeEncoded: HttpUtility.HtmlAttributeEncode

• HexEscaped: Uri.HexEscape

ANMERKUNGEN:

1. HexEscapekann nur die ersten 255 Zeichen verarbeiten. Daher wird eine ArgumentOutOfRangeAusnahme für die lateinischen A-Extended-Zeichen (z. B. Ā) ausgelöst.

2. Diese Tabelle wurde in .NET 4.0 generiert (siehe Levi Botelhos Kommentar unten, der besagt, dass die Codierung in .NET 4.5 etwas anders ist).

BEARBEITEN:

Ich habe eine zweite Tabelle mit den Codierungen für .NET 4.5 hinzugefügt. Siehe diese Antwort: https://stackoverflow.com/a/21771206/216440

EDIT 2:

Da die Leute diese Tabellen zu schätzen scheinen, dachte ich, dass Ihnen der Quellcode, der die Tabelle generiert, gefallen könnte, damit Sie selbst herumspielen können. Es ist eine einfache C # -Konsolenanwendung, die entweder auf .NET 4.0 oder 4.5 abzielen 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 einen anderen Teil der URL codieren, der möglicherweise ungültig ist. Das Codieren einer URL durch URL kann zu Problemen führen, da Folgendes der Fall ist:

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

Wird nachgeben

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

Dies wird offensichtlich nicht gut funktionieren. Stattdessen sollten Sie NUR den Wert des Schlüssel / Wert-Paares in der Abfragezeichenfolge wie folgt codieren:

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

Hoffentlich hilft das. Wie bereits erwähnt, müssen Sie außerdem sicherstellen, dass unzulässige Dateinamenzeichen entfernt werden, da sonst das Dateisystem den Pfad nicht mag.

Besser ist es zu benutzen

Uri.EscapeUriString

nicht auf das vollständige Profil von .net verweisen 4.

Seit .NET Framework 4.5 und .NET Standard 1.0 sollten Sie verwenden WebUtility.UrlEncode. Vorteile gegenüber Alternativen:

1. Es ist Teil von .NET Framework 4.5+, .NET Core 1.0+, .NET Standard 1.0+, UWP 10.0+ und allen Xamarin-Plattformen. HttpUtilityWährend es früher in .NET Framework verfügbar war (.NET Framework 1.1+), wird es viel später auf anderen Plattformen verfügbar (.NET Core 2.0+, .NET Standard 2.0+) und ist in UWP immer noch nicht verfügbar (siehe verwandte Frage ).

2. In .NET Framework befindet es sich inSystem.dll , sodass im Gegensatz zu .NET Framework keine zusätzlichen Referenzen erforderlich sind HttpUtility.

3. Im Gegensatz zu URLs werden Zeichen für URLs ordnungsgemäß ausgeblendetUri.EscapeUriString (siehe Kommentare zur Antwort von drweb86 ).

4. Im Gegensatz zu (siehe verwandte Frage ) gibt es keine Begrenzung für die Länge der Zeichenfolge , sodass sie beispielsweise für POST-Anforderungen verwendet werden kann.Uri.EscapeDataString

Levi Botelho bemerkte, dass die zuvor generierte Codierungstabelle für .NET 4.5 nicht mehr korrekt ist, da sich die Codierungen zwischen .NET 4.0 und 4.5 geringfügig geändert haben. Also habe ich die Tabelle für .NET 4.5 neu generiert:

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]

Die Spalten stellen Codierungen wie folgt dar:

• 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

ANMERKUNGEN:

1. HexEscape kann nur die ersten 255 Zeichen verarbeiten. Daher wird eine ArgumentOutOfRange-Ausnahme für die lateinischen A-Extended-Zeichen (z. B. Ā) ausgelöst.

2. Diese Tabelle wurde in .NET 4.5 generiert (siehe Antwort https://stackoverflow.com/a/11236038/216440 für die für .NET 4.0 und darunter relevanten Codierungen).

BEARBEITEN:

1. Als Ergebnis der Antwort von Discord habe ich die neuen WebUtility UrlEncode- und HtmlEncode-Methoden hinzugefügt, die in .NET 4.5 eingeführt wurden.

Die URL-Codierung ist in .NET einfach. Verwenden:

System.Web.HttpUtility.UrlEncode(string url)

Wenn dies dekodiert wird, um den Ordnernamen zu erhalten, müssen Sie weiterhin Zeichen ausschließen, die nicht in Ordnernamen verwendet werden können (*,?, / Usw.).

Wenn Sie System.Web nicht sehen können, ändern Sie Ihre Projekteinstellungen. Das Zielframework sollte ".NET Framework 4" anstelle von ".NET Framework 4-Clientprofil" sein.

Die .NET-Implementierung von UrlEncodeentspricht nicht RFC 3986.

1. Einige Zeichen sind nicht codiert, sollten es aber sein. Die !()*Zeichen werden in Abschnitt 2.2 des RFC als reservierte Zeichen aufgeführt, die codiert werden müssen, aber .NET kann diese Zeichen nicht codieren.

2. Einige Zeichen sind codiert, sollten es aber nicht sein. Die .-_Zeichen werden in Abschnitt 2.2 des RFC nicht als reserviertes Zeichen aufgeführt, das noch nicht codiert werden sollte. .NET codiert diese Zeichen fälschlicherweise.

3. Der RFC gibt an, dass Implementierungen aus Gründen der Konsistenz HEXDIG in Großbuchstaben verwenden sollten, wobei .NET HEXDIG in Kleinbuchstaben erzeugt.

Ich denke, die Leute hier wurden von der UrlEncode-Nachricht abgelenkt. URLEncoding ist nicht das, was Sie wollen - Sie möchten Dinge codieren, die auf dem Zielsystem nicht als Dateiname funktionieren.

Angenommen, Sie möchten eine gewisse Allgemeinheit - Sie können die illegalen Zeichen auf mehreren Systemen (MacOS, Windows, Linux und Unix) finden und sie zu einer Reihe von Zeichen zusammenfassen, um zu entkommen.

Für die Flucht sollte ein HexEscape in Ordnung sein (Ersetzen der Zeichen durch% XX). Konvertieren Sie jedes Zeichen in UTF-8-Bytes und codieren Sie alles> 128, wenn Sie Systeme unterstützen möchten, die keinen Unicode ausführen. Es gibt aber auch andere Möglichkeiten, z. B. die Verwendung von Schrägstrichen "\" oder HTML-Codierung "". Sie können Ihre eigenen erstellen. Alles, was ein System tun muss, ist, das nicht kompatible Zeichen zu "codieren". Mit den oben genannten Systemen können Sie das neu erstellen ursprünglicher Name - aber so etwas wie das Ersetzen der schlechten Zeichen durch Leerzeichen funktioniert auch.

Auf der gleichen Tangente wie oben ist die einzige, die verwendet werden kann

Uri.EscapeDataString

- Es codiert alles, was für OAuth benötigt wird, es codiert nicht die Dinge, die OAuth das Codieren verbietet, und codiert den Speicherplatz als% 20 und nicht als + (auch in der OATH-Spezifikation). Siehe: RFC 3986. AFAIK, dies ist das neueste URI-Spezifikation.

Ich habe eine C # -Methode geschrieben, die ALLE Symbole url-codiert:

    /// <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();
    }

Idealerweise gehören diese zu einer Klasse namens "FileNaming" oder benennen Encode einfach in "FileNameEncode" um. Hinweis: Diese sind nicht für die Verarbeitung vollständiger Pfade ausgelegt, sondern nur für die Ordner- und / oder Dateinamen. Idealerweise würden Sie zuerst Ihren vollständigen Pfad teilen ("/") und dann die Teile überprüfen. Und natürlich könnten Sie anstelle einer Vereinigung einfach das Zeichen "%" zur Liste der Zeichen hinzufügen, die in Windows nicht zulässig sind, aber ich denke, dass dies auf diese Weise hilfreicher / lesbarer / sachlicher ist. Decode () ist genau das gleiche, wechselt jedoch das Ersetzen (Uri.HexEscape (s [0]), s) mit dem Zeichen "maskiert".

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ützliche Tabelle oben!

Zusätzlich zu der Antwort von @Dan Herbert sollten Sie nur die Werte allgemein codieren.

Split hat den Parameter Parameter Split ('&', '='); Ausdruck wird zuerst durch & dann '=' geteilt, so dass ungerade Elemente alle zu codierenden Werte sind (siehe unten).

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);
        }
    }
}