URL编码使用c#

我有一个应用程序，发送一个POST请求到VB论坛软件，并登录某人(没有设置cookie或任何东西)。

一旦用户登录，我就创建一个变量，在他们的本地机器上创建一个路径。

c: \ tempfolder \ \用户名

问题是一些用户名抛出“非法字符”异常。例如，如果我的用户名是mas|fenix，它会抛出一个异常。

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

我不想从字符串中删除它，但是通过FTP在服务器上创建了一个具有其用户名的文件夹。这就引出了我的第二个问题。如果我在服务器上创建一个文件夹，我可以留下“非法字符”吗?我问这个问题是因为服务器是基于Linux的，我不确定Linux是否接受它。

编辑:似乎URL编码不是我想要的..这就是我想做的:

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

其中%xx是ASCII值或任何其他容易识别字符的值。

785181 次浏览
小开

Url编码在。net中很容易。使用:

System.Web.HttpUtility.UrlEncode(string url)

如果要对其进行解码以获得文件夹名称，则仍然需要排除文件夹名称中不能使用的字符(*、?、/等)。

小开
最佳答案

编辑:注意，这个答案现在已经过时了。参见Siarhei Kuchuk的回答

UrlEncoding会做你在这里建议的事情。在c#中，你只需使用HttpUtility，如上所述。

您还可以Regex非法字符，然后进行替换，但这变得更加复杂，因为您必须有某种形式的状态机(switch…用正确的字符替换。因为UrlEncode预先做了这个，所以相当简单。

至于Linux和windows，有一些字符在Linux中是可接受的，但在windows中是不可接受的，但我不担心这一点，因为文件夹名可以通过解码Url字符串返回，使用UrlDecode，所以你可以往返更改。

小开

您应该只对用户名或URL中可能无效的其他部分进行编码。URL编码URL可能会导致这样的问题:

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

将产生

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

这显然不会有很好的效果。相反，你应该在查询字符串中只编码键/值对的值，就像这样:

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

希望这有帮助。另外，正如teedyay所提到的，你仍然需要确保非法文件名字符被删除，否则文件系统不会喜欢这个路径。

小开

如果你看不见系统。Web，更改项目设置。目标框架应该是。NET Framework 4“代替”。NET Framework 4客户端配置文件

小开

更好的方法是使用

Uri.EscapeUriString

不引用。net 4的完整配置文件。

小开

我一直在试验。net为URL编码提供的各种方法。也许下面的表格会有用(作为我写的测试应用程序的输出):

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]

列表示编码如下:

  • < p > UrlEncoded: HttpUtility.UrlEncode

  • < p > UrlEncodedUnicode: HttpUtility.UrlEncodeUnicode

  • < p > UrlPathEncoded: HttpUtility.UrlPathEncode

  • < p > EscapedDataString: Uri.EscapeDataString

  • < p > EscapedUriString: Uri.EscapeUriString

  • < p > HtmlEncoded: HttpUtility.HtmlEncode

  • < p > HtmlAttributeEncoded: HttpUtility.HtmlAttributeEncode

  • < p > HexEscaped: Uri.HexEscape

注:

  1. HexEscape只能处理前255个字符。因此，它会对拉丁A-Extended字符抛出ArgumentOutOfRange异常(例如Ā)。

  2. 该表是在。net 4.0中生成的(参见下面Levi Botelho的评论，他说。net 4.5中的编码略有不同)。

编辑:

我添加了第二个带有。net 4.5编码的表。请看这个答案:https://stackoverflow.com/a/21771206/216440

编辑2:

由于人们似乎很喜欢这些表，我认为您可能会喜欢生成表的源代码，这样您就可以自己玩了。这是一个简单的c#控制台应用程序，它可以针对。net 4.0或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();
}
}
}
}

点击这里在dotnetfiddle.net上运行代码

小开
理想情况下，这些将进入一个名为“FileNaming”的类中，或者可能只是将Encode重命名为“FileNameEncode”。注意:这些不是设计来处理全路径的，只是文件夹和/或文件名。理想情况下，您应该首先拆分(“/”)您的完整路径，然后检查片段。 显然，你可以将“%”字符添加到Windows中不允许的字符列表中，而不是一个联合字符，但我认为这样更有帮助/可读/更符合事实。 Decode()是完全相同的，但会切换Replace(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;
}

感谢@simon-tewsi提供的非常有用的表格!

小开
除了@Dan Herbert的回答， 我们应该只编码一般的值

Split有参数Split('&'，'=');表达式首先被&然后是'='，因此奇数元素都是要编码的值，如下所示。

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

UrlEncode的. net实现不符合RFC 3986。

  1. 有些字符没有编码，但应该编码。!()*字符在RFC的章节2.2中被列为必须被编码的保留字符，然而。net未能对这些字符进行编码。

  2. 有些字符被编码了，但不应该被编码。.-_字符在RFC的2.2节中没有作为保留字符列出，还不应该进行编码。net错误地对这些字符进行编码。

  3. RFC指定为了保持一致，实现应该使用大写的HEXDIG，而. net生成小写的HEXDIG。

小开

因为.NET Framework 4.5和.NET标准1.0，你应该使用WebUtility.UrlEncode。相对于其他选择的优势:

  1. 它是. net Framework 4.5+， . net Core 1.0+， . net Standard 1.0+， UWP 10.0+和所有Xamarin平台的一部分。HttpUtility，而之前在. net Framework中可用(。NET Framework 1.1+)，在很久以后才可以在其他平台上使用(。NET Core 2.0+， .NET Standard 2.0+)，在UWP中仍然不可用(参见相关问题)。

  2. 在. net框架中，它驻留在System.dll中，因此它不需要任何额外的引用，不像HttpUtility。

  3. 它正确地转义url 的字符，不像Uri.EscapeUriString(参见注释到drweb86的答案)。

  4. 它对的字符串长度没有任何限制，不像Uri.EscapeDataString(参见相关问题)，因此它可以用于POST请求，例如。

小开

Levi Botelho评论说，以前生成的编码表对于。net 4.5来说不再准确了，因为在。net 4.0和4.5之间，编码发生了轻微的变化。因此，我重新生成了。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              &quot;      &quot;               &quot;                %22
#         %23        %23               #              %23                  %23               #                #           #                    #                     %23
$         %24        %24               $              %24                  %24               $                $           $                    $                     %24
%         %25        %25               %              %25                  %25               %25              %           %                    %                     %25
&         %26        %26               &              %26                  %26               &                &amp;       &amp;                &amp;                 %26
'         %27        %27               '              %27                  %27               '                &#39;       &#39;                &#39;                 %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]

列表示编码如下:

  • 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

注:

  1. HexEscape只能处理前255个字符。因此，它对拉丁a扩展字符抛出ArgumentOutOfRange异常(例如Ā)。

  2. 该表是在。net 4.5中生成的(有关。net 4.0及以下版本的编码，请参见答案https://stackoverflow.com/a/11236038/216440)。

编辑:

  1. 作为Discord回答的结果，我添加了新的WebUtility UrlEncode和HtmlEncode方法，这是在。net 4.5中引入的。
小开

我写了一个对所有符号进行url编码的c#方法:

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

我觉得这里的人被UrlEncode信息转移了注意力。URLEncoding是你想要的不——你想要编码在目标系统上不能作为文件名的东西。

假设你想要一些通用性——随意地在几个系统(MacOS, Windows, Linux和Unix)上找到非法字符，将它们联合起来形成一组字符来转义。

至于转义，一个HexEscape应该是好的(替换字符%XX)。如果您想支持不使用unicode的系统，则将每个字符转换为UTF-8字节并将所有内容编码为>128。但也有其他方法，比如使用反斜杠“\”或HTML编码“"”。你可以自己创建。任何系统所要做的就是把不兼容的字符“编码”掉。上面的系统允许您重新创建原来的名称，但用空格替换坏字符之类的方法也可以。

与上面相同的是，唯一可以使用的是

Uri。EscapeDataString

-它编码OAuth需要的所有东西，它不编码OAuth禁止编码的东西，并将空格编码为%20而不是+(也在OATH规范中)参见:RFC 3986。AFAIK，这是最新的URI规范。


提交答案