public byte[] EscapeToBytes(byte[] data, UrlEscapeFlags flags) { #if HAS_SYSTEM_WEB if (_allowNativeConversion && flags == UrlEscapeFlags.LikeUrlEncode) { return(HttpUtility.UrlEncodeToBytes(data)); } #endif var hexChars = ((flags & UrlEscapeFlags.LowerCaseHexCharacters) != UrlEscapeFlags.Default) ? s_hexCharsLow : s_hexCharsUp; var allowedBytesIndex = flags & UrlEscapeFlags.AllowMask; ISet <byte> allowedBytes; if (!s_allowedBytes.TryGetValue(allowedBytesIndex, out allowedBytes)) { allowedBytes = s_allowedBytes[UrlEscapeFlags.Default]; } var builderVariant = flags & UrlEscapeFlags.BuilderVariantMask; EscapeBuilderDelegate builder; if (!s_escapeBuilders.TryGetValue(builderVariant, out builder)) { builder = EscapeToBytes2; } return(builder(data, flags, hexChars, allowedBytes)); }
/// <summary> /// Compute length of the data after escaping its values /// </summary> /// <param name="data">The data to escape</param> /// <param name="flags">The flags to modify the behavior</param> /// <param name="allowedBytes">The bytes that don't need to be escaped</param> /// <returns>The escaped data</returns> private static long ComputeLength(byte[] data, UrlEscapeFlags flags, ISet <byte> allowedBytes) { var escapeSpaceAsPlus = (flags & UrlEscapeFlags.EscapeSpaceAsPlus) == UrlEscapeFlags.EscapeSpaceAsPlus; long computedLength = 0; var len = data.Length; for (var i = 0; i != len; ++i) { var v = data[i]; if (allowedBytes.Contains(v)) { computedLength += 1; } else if (v == 0x20) { if (escapeSpaceAsPlus) { computedLength += 1; } else { computedLength += 3; } } else { computedLength += 3; } } return(computedLength); }
/// <summary> /// URL escape /// </summary> /// <param name="data">The data to escape</param> /// <param name="encoding">The encoding to use to convert the string to a byte array</param> /// <param name="flags">The flags to modify the behavior</param> /// <returns>The escaped data</returns> public static string Escape(string data, Encoding encoding, UrlEscapeFlags flags) { if (flags == UrlEscapeFlags.LikeEscapeDataString && string.Equals(encoding.WebName, "utf-8", StringComparison.OrdinalIgnoreCase)) { return(EscapeDataString(data)); } return(ConvertEscapedBytesToString(EscapeToBytes(data, encoding, flags))); }
/// <summary> /// URL escape /// </summary> /// <param name="data">The data to escape</param> /// <param name="flags">The flags to modify the behavior</param> /// <returns>The escaped data</returns> public string Escape(string data, UrlEscapeFlags flags) { #if HAS_SYSTEM_WEB if (_allowNativeConversion && flags == UrlEscapeFlags.LikeUrlEncode) { return(HttpUtility.UrlEncode(data)); } #endif return(Escape(data, s_defaultEncoding, flags)); }
/// <summary> /// URL escape for bytes /// </summary> /// <param name="data">The data to escape</param> /// <param name="flags">The flags to modify the behavior</param> /// <returns>The escaped data</returns> public string Escape(byte[] data, UrlEscapeFlags flags) { #if HAS_SYSTEM_WEB if (_allowNativeConversion && flags == UrlEscapeFlags.LikeUrlEncode) { return(HttpUtility.UrlEncode(data)); } #endif return(ConvertEscapedBytesToString(EscapeToBytes(data, flags))); }
/// <summary> /// URL escape /// </summary> /// <param name="data">The data to escape</param> /// <param name="encoding">The encoding to use to convert the string to a byte array</param> /// <param name="flags">The flags to modify the behavior</param> /// <returns>The escaped data</returns> public byte[] EscapeToBytes(string data, Encoding encoding, UrlEscapeFlags flags) { #if HAS_SYSTEM_WEB if (_allowNativeConversion && flags == UrlEscapeFlags.LikeUrlEncode) { return(HttpUtility.UrlEncodeToBytes(data, encoding)); } #endif return(EscapeToBytes(encoding.GetBytes(data), flags)); }
public void TestEscapeDataStringComplianceASCII() { const UrlEscapeFlags flags = UrlEscapeFlags.BuilderVariantListByteArray; var chars = new string(Enumerable.Range(32, 95).Select(x => (char)x).ToArray()); var expected = Uri.EscapeDataString(chars); var test = _utility.Escape(chars, flags); Assert.Equal(expected, test); Assert.Equal(expected.Length, UrlEscapeUtility.ComputeLength(chars, flags)); }
public void TestEscapeDataStringComplianceUmlaut() { const UrlEscapeFlags flags = UrlEscapeFlags.BuilderVariantListByteArray; const string chars = "äöüßÄÖÜ\u007F"; var expected = Uri.EscapeDataString(chars); var test = _utility.Escape(chars, flags); Assert.Equal(expected, test); Assert.Equal(expected.Length, UrlEscapeUtility.ComputeLength(chars, flags)); }
/// <summary> /// Compute length of the data after escaping its values /// </summary> /// <param name="data"></param> /// <param name="flags"></param> /// <returns></returns> public long ComputeLength(byte[] data, UrlEscapeFlags flags) { var allowedBytesIndex = (flags & UrlEscapeFlags.AllowMask); ISet <byte> allowedBytes; if (!s_allowedBytes.TryGetValue(allowedBytesIndex, out allowedBytes)) { allowedBytes = s_allowedBytes[UrlEscapeFlags.Default]; } return(ComputeLength(data, flags, allowedBytes)); }
public void TestUrlEncodeComplianceUmlaut() { const UrlEscapeFlags flags = UrlEscapeFlags.LikeUrlEncode | UrlEscapeFlags.BuilderVariantListByteArray; const string chars = "äöüßÄÖÜ\u007F"; var expected = HttpUtility.UrlEncode(chars); Assert.NotNull(expected); var test = _utility.Escape(chars, flags); Assert.Equal(expected, test); Assert.Equal(expected.Length, UrlEscapeUtility.ComputeLength(chars, flags)); }
public void TestUrlEncodeComplianceASCII() { const UrlEscapeFlags flags = UrlEscapeFlags.LikeUrlEncode | UrlEscapeFlags.BuilderVariantListByteArray; var chars = new string(Enumerable.Range(32, 95).Select(x => (char)x).ToArray()); var expected = HttpUtility.UrlEncode(chars); Assert.NotNull(expected); var test = UrlEscapeUtility.Escape(chars, flags); Assert.Equal(expected, test); Assert.Equal(expected.Length, UrlEscapeUtility.ComputeLength(chars, flags)); }
/// <summary> /// URL escape /// </summary> /// <param name="data">The data to escape</param> /// <param name="encoding">The encoding to use to convert the string to a byte array</param> /// <param name="flags">The flags to modify the behavior</param> /// <returns>The escaped data</returns> public string Escape(string data, Encoding encoding, UrlEscapeFlags flags) { #if HAS_SYSTEM_WEB if (_allowNativeConversion && flags == UrlEscapeFlags.LikeUrlEncode) { return(HttpUtility.UrlEncode(data, encoding)); } #endif if (_allowNativeConversion && (flags == UrlEscapeFlags.LikeEscapeDataString) && string.Equals(encoding.WebName, "utf-8", StringComparison.OrdinalIgnoreCase)) { return(EscapeDataString(data)); } return(ConvertEscapedBytesToString(EscapeToBytes(data, encoding, flags))); }
/// <summary> /// Variant 1 of EscapeToBytes /// </summary> /// <remarks> /// This variant uses a list of bytes. /// </remarks> /// <param name="data">The data to escape</param> /// <param name="flags">The flags to modify the behavior</param> /// <param name="hexChars">The HEX characters used to write the output</param> /// <param name="allowedBytes">The bytes that don't need to be escaped</param> /// <returns>The escaped data</returns> private static byte[] EscapeToBytes1(byte[] data, UrlEscapeFlags flags, byte[] hexChars, ISet <byte> allowedBytes) { var encodedByte = new byte[3]; encodedByte[0] = (byte)'%'; var escapeSpaceAsPlus = (flags & UrlEscapeFlags.EscapeSpaceAsPlus) == UrlEscapeFlags.EscapeSpaceAsPlus; var output = new List <byte>(data.Length); var len = data.Length; var escapeByte = false; for (var i = 0; i != len; ++i) { var v = data[i]; if (allowedBytes.Contains(v)) { output.Add(v); } else if (v == 0x20) { if (escapeSpaceAsPlus) { output.Add((byte)'+'); } else { escapeByte = true; } } else { escapeByte = true; } if (escapeByte) { escapeByte = false; var hiByte = (v >> 4) & 0x0F; var loByte = v & 0x0F; encodedByte[1] = hexChars[hiByte]; encodedByte[2] = hexChars[loByte]; output.AddRange(encodedByte); } } return(output.ToArray()); }
/// <summary> /// URL escape for bytes /// </summary> /// <param name="data">The data to escape</param> /// <param name="flags">The flags to modify the behavior</param> /// <returns>The escaped data</returns> public static byte[] EscapeToBytes(byte[] data, UrlEscapeFlags flags) { var hexChars = ((flags & UrlEscapeFlags.LowerCaseHexCharacters) != UrlEscapeFlags.Default) ? s_hexCharsLow : s_hexCharsUp; var allowedBytesIndex = flags & UrlEscapeFlags.AllowMask; ISet <byte> allowedBytes; if (!s_allowedBytes.TryGetValue(allowedBytesIndex, out allowedBytes)) { allowedBytes = s_allowedBytes[UrlEscapeFlags.Default]; } var builderVariant = flags & UrlEscapeFlags.BuilderVariantMask; EscapeBuilderDelegate builder; if (!s_escapeBuilders.TryGetValue(builderVariant, out builder)) { builder = EscapeToBytes2; } return(builder(data, flags, hexChars, allowedBytes)); }
/// <summary> /// Compute length of the data after escaping its values /// </summary> /// <param name="data">The data to compute the escaped length for</param> /// <param name="flags">The flags to modify the escaping behavior</param> /// <returns>Returns the length of the escaped data</returns> public static long ComputeLength(byte[] data, UrlEscapeFlags flags) { return(UrlEscapeUtility.ComputeLength(data, flags)); }
/// <summary> /// URL escape for bytes /// </summary> /// <param name="data">The data to escape</param> /// <param name="flags">The flags to modify the escaping behavior</param> /// <returns>Returns the escaped data</returns> public static string Escape(byte[] data, UrlEscapeFlags flags) { return(s_defaultEscapeUtility.Escape(data, flags)); }
/// <summary> /// URL escape for bytes /// </summary> /// <param name="data">The data to escape</param> /// <param name="flags">The flags to modify the escaping behavior</param> /// <returns>Returns the escaped data</returns> public static byte[] EscapeToBytes(byte[] data, UrlEscapeFlags flags) { return(s_defaultEscapeUtility.EscapeToBytes(data, flags)); }
/// <summary> /// Variant 2 of EscapeToBytes /// </summary> /// <remarks> /// This variant uses a list of byte arrays /// </remarks> /// <param name="data">The data to escape</param> /// <param name="flags">The flags to modify the behavior</param> /// <param name="hexChars">The HEX characters used to write the output</param> /// <param name="allowedBytes">The bytes that don't need to be escaped</param> /// <returns>The escaped data</returns> private static byte[] EscapeToBytes2(byte[] data, UrlEscapeFlags flags, byte[] hexChars, ISet <byte> allowedBytes) { var escapeSpaceAsPlus = (flags & UrlEscapeFlags.EscapeSpaceAsPlus) == UrlEscapeFlags.EscapeSpaceAsPlus; var output = new List <byte[]>(); var outputEscaped = new List <byte>(); var outputSize = 0; var len = data.Length; var afterLastValid = 0; var escapeByte = false; for (var i = 0; i != len; ++i) { var v = data[i]; if (allowedBytes.Contains(v)) { continue; } var validBytes = i - afterLastValid; if (validBytes != 0) { if (outputEscaped.Count != 0) { var tempEscaped = outputEscaped.ToArray(); outputSize += tempEscaped.Length; output.Add(tempEscaped); outputEscaped = new List <byte>(); } var temp = new byte[validBytes]; Array.Copy(data, afterLastValid, temp, 0, validBytes); output.Add(temp); outputSize += validBytes; } if (v == 0x20) { if (escapeSpaceAsPlus) { outputEscaped.Add((byte)'+'); } else { escapeByte = true; } } else { escapeByte = true; } if (escapeByte) { escapeByte = false; var hiByte = (v >> 4) & 0x0F; var loByte = v & 0x0F; outputEscaped.Add((byte)'%'); outputEscaped.Add(hexChars[hiByte]); outputEscaped.Add(hexChars[loByte]); } afterLastValid = i + 1; } if (outputEscaped.Count != 0) { var tempEscaped = outputEscaped.ToArray(); outputSize += tempEscaped.Length; output.Add(tempEscaped); } { var validBytes = len - afterLastValid; if (validBytes != 0) { var temp = new byte[validBytes]; Array.Copy(data, afterLastValid, temp, 0, validBytes); output.Add(temp); outputSize += validBytes; } } var result = new byte[outputSize]; var destOffset = 0; foreach (var part in output) { var length = part.Length; Array.Copy(part, 0, result, destOffset, length); destOffset += length; } return(result); }
/// <summary> /// Compute length of the data after escaping its values /// </summary> /// <param name="data">The data to escape</param> /// <param name="encoding">The encoding to use to convert the string to a byte array</param> /// <param name="flags">The flags to modify the behavior</param> /// <returns>The escaped data</returns> public static long ComputeLength(string data, Encoding encoding, UrlEscapeFlags flags) { return(ComputeLength(encoding.GetBytes(data), flags)); }
/// <summary> /// URL escape /// </summary> /// <param name="data">The data to escape</param> /// <param name="flags">The flags to modify the behavior</param> /// <returns>The escaped data</returns> public byte[] EscapeToBytes(string data, UrlEscapeFlags flags) { return(EscapeToBytes(data, s_defaultEncoding, flags)); }
/// <summary> /// URL escape /// </summary> /// <param name="data">The data to escape</param> /// <param name="flags">The flags to modify the behavior</param> /// <returns>The escaped data</returns> public static string Escape(string data, UrlEscapeFlags flags) { return(Escape(data, s_defaultEncoding, flags)); }
/// <summary> /// URL escape /// </summary> /// <param name="data">The data to escape</param> /// <param name="encoding">The encoding to use to convert the string to a byte array</param> /// <param name="flags">The flags to modify the behavior</param> /// <returns>The escaped data</returns> public byte[] EscapeToBytes(string data, Encoding encoding, UrlEscapeFlags flags) { #if HAS_SYSTEM_WEB if (_allowNativeConversion && flags == UrlEscapeFlags.LikeUrlEncode) return HttpUtility.UrlEncodeToBytes(data, encoding); #endif return EscapeToBytes(encoding.GetBytes(data), flags); }
public byte[] EscapeToBytes(byte[] data, UrlEscapeFlags flags) { #if HAS_SYSTEM_WEB if (_allowNativeConversion && flags == UrlEscapeFlags.LikeUrlEncode) return HttpUtility.UrlEncodeToBytes(data); #endif var hexChars = ((flags & UrlEscapeFlags.LowerCaseHexCharacters) != UrlEscapeFlags.Default) ? s_hexCharsLow : s_hexCharsUp; var allowedBytesIndex = flags & UrlEscapeFlags.AllowMask; ISet<byte> allowedBytes; if (!s_allowedBytes.TryGetValue(allowedBytesIndex, out allowedBytes)) allowedBytes = s_allowedBytes[UrlEscapeFlags.Default]; var builderVariant = flags & UrlEscapeFlags.BuilderVariantMask; EscapeBuilderDelegate builder; if (!s_escapeBuilders.TryGetValue(builderVariant, out builder)) builder = EscapeToBytes2; return builder(data, flags, hexChars, allowedBytes); }
/// <summary> /// URL escape for bytes /// </summary> /// <param name="data">The data to escape</param> /// <param name="flags">The flags to modify the behavior</param> /// <returns>The escaped data</returns> public string Escape(byte[] data, UrlEscapeFlags flags) { #if HAS_SYSTEM_WEB if (_allowNativeConversion && flags == UrlEscapeFlags.LikeUrlEncode) return HttpUtility.UrlEncode(data); #endif return ConvertEscapedBytesToString(EscapeToBytes(data, flags)); }
/// <summary> /// URL escape /// </summary> /// <param name="data">The data to escape</param> /// <param name="flags">The flags to modify the behavior</param> /// <returns>The escaped data</returns> public byte[] EscapeToBytes(string data, UrlEscapeFlags flags) { return EscapeToBytes(data, s_defaultEncoding, flags); }
/// <summary> /// URL escape /// </summary> /// <param name="data">The data to escape</param> /// <param name="encoding">The encoding to use to convert the string to a byte array</param> /// <param name="flags">The flags to modify the behavior</param> /// <returns>The escaped data</returns> public string Escape(string data, Encoding encoding, UrlEscapeFlags flags) { #if HAS_SYSTEM_WEB if (_allowNativeConversion && flags == UrlEscapeFlags.LikeUrlEncode) return HttpUtility.UrlEncode(data, encoding); #endif if (_allowNativeConversion && (flags == UrlEscapeFlags.LikeEscapeDataString) && string.Equals(encoding.WebName, "utf-8", StringComparison.OrdinalIgnoreCase)) return EscapeDataString(data); return ConvertEscapedBytesToString(EscapeToBytes(data, encoding, flags)); }
/// <summary> /// URL escape /// </summary> /// <param name="data">The data to escape</param> /// <param name="flags">The flags to modify the behavior</param> /// <returns>The escaped data</returns> public string Escape(string data, UrlEscapeFlags flags) { #if HAS_SYSTEM_WEB if (_allowNativeConversion && flags == UrlEscapeFlags.LikeUrlEncode) return HttpUtility.UrlEncode(data); #endif return Escape(data, s_defaultEncoding, flags); }
/// <summary> /// Compute length of the data after escaping its values /// </summary> /// <param name="data">The data to escape</param> /// <param name="flags">The flags to modify the behavior</param> /// <returns>The escaped data</returns> public static long ComputeLength(byte[] data, UrlEscapeFlags flags) { var allowedBytesIndex = flags & UrlEscapeFlags.AllowMask; ISet<byte> allowedBytes; if (!s_allowedBytes.TryGetValue(allowedBytesIndex, out allowedBytes)) allowedBytes = s_allowedBytes[UrlEscapeFlags.Default]; return ComputeLength(data, flags, allowedBytes); }
/// <summary> /// Compute length of the data after escaping its values /// </summary> /// <param name="data">The data to compute the escaped length for</param> /// <param name="flags">The flags to modify the escaping behavior</param> /// <returns>Returns the length of the escaped data</returns> public static long ComputeLength(byte[] data, UrlEscapeFlags flags) { return UrlEscapeUtility.ComputeLength(data, flags); }
/// <summary> /// Compute length of the data after escaping its values /// </summary> /// <param name="data">The data to escape</param> /// <param name="flags">The flags to modify the behavior</param> /// <param name="allowedBytes">The bytes that don't need to be escaped</param> /// <returns>The escaped data</returns> private static long ComputeLength(byte[] data, UrlEscapeFlags flags, ISet<byte> allowedBytes) { var escapeSpaceAsPlus = (flags & UrlEscapeFlags.EscapeSpaceAsPlus) == UrlEscapeFlags.EscapeSpaceAsPlus; long computedLength = 0; #if PCL || SILVERLIGHT long len = data.Length; #else var len = data.LongLength; #endif for (long i = 0; i != len; ++i) { var v = data[i]; if (allowedBytes.Contains(v)) computedLength += 1; else if (v == 0x20) { if (escapeSpaceAsPlus) computedLength += 1; else computedLength += 3; } else computedLength += 3; } return computedLength; }
/// <summary> /// URL escape /// </summary> /// <param name="data">The data to escape</param> /// <param name="encoding">The encoding to use to convert the string to a byte array</param> /// <param name="flags">The flags to modify the behavior</param> /// <returns>The escaped data</returns> public static byte[] EscapeToBytes(string data, Encoding encoding, UrlEscapeFlags flags) { return(EscapeToBytes(encoding.GetBytes(data), flags)); }
/// <summary> /// URL escape /// </summary> /// <param name="data">The data to escape</param> /// <param name="flags">The flags to modify the escaping behavior</param> /// <returns>Returns the escaped data</returns> public static byte[] EscapeToBytes(string data, UrlEscapeFlags flags) { return(UrlEscapeUtility.EscapeToBytes(data, flags)); }
/// <summary> /// URL escape for bytes /// </summary> /// <param name="data">The data to escape</param> /// <param name="flags">The flags to modify the behavior</param> /// <returns>The escaped data</returns> public static string Escape(byte[] data, UrlEscapeFlags flags) { return(ConvertEscapedBytesToString(EscapeToBytes(data, flags))); }
/// <summary> /// Variant 2 of EscapeToBytes /// </summary> /// <remarks> /// This variant uses a list of byte arrays /// </remarks> /// <param name="data">The data to escape</param> /// <param name="flags">The flags to modify the behavior</param> /// <param name="hexChars">The HEX characters used to write the output</param> /// <param name="allowedBytes">The bytes that don't need to be escaped</param> /// <returns>The escaped data</returns> private static byte[] EscapeToBytes2(byte[] data, UrlEscapeFlags flags, byte[] hexChars, ISet<byte> allowedBytes) { var escapeSpaceAsPlus = (flags & UrlEscapeFlags.EscapeSpaceAsPlus) == UrlEscapeFlags.EscapeSpaceAsPlus; var output = new List<byte[]>(); var outputEscaped = new List<byte>(); var outputSize = 0; var len = data.Length; var afterLastValid = 0; var escapeByte = false; for (var i = 0; i != len; ++i) { var v = data[i]; if (allowedBytes.Contains(v)) continue; var validBytes = i - afterLastValid; if (validBytes != 0) { if (outputEscaped.Count != 0) { var tempEscaped = outputEscaped.ToArray(); outputSize += tempEscaped.Length; output.Add(tempEscaped); outputEscaped = new List<byte>(); } var temp = new byte[validBytes]; Array.Copy(data, afterLastValid, temp, 0, validBytes); output.Add(temp); outputSize += validBytes; } if (v == 0x20) { if (escapeSpaceAsPlus) { outputEscaped.Add((byte)'+'); } else { escapeByte = true; } } else { escapeByte = true; } if (escapeByte) { escapeByte = false; var hiByte = (v >> 4) & 0x0F; var loByte = v & 0x0F; outputEscaped.Add((byte)'%'); outputEscaped.Add(hexChars[hiByte]); outputEscaped.Add(hexChars[loByte]); } afterLastValid = i + 1; } if (outputEscaped.Count != 0) { var tempEscaped = outputEscaped.ToArray(); outputSize += tempEscaped.Length; output.Add(tempEscaped); } { var validBytes = len - afterLastValid; if (validBytes != 0) { var temp = new byte[validBytes]; Array.Copy(data, afterLastValid, temp, 0, validBytes); output.Add(temp); outputSize += validBytes; } } var result = new byte[outputSize]; var destOffset = 0; foreach (var part in output) { var length = part.Length; Array.Copy(part, 0, result, destOffset, length); destOffset += length; } return result; }
/// <summary> /// URL escape /// </summary> /// <param name="data">The data to escape</param> /// <param name="encoding">The encoding to use to convert the string into a byte array</param> /// <param name="flags">The flags to modify the escaping behavior</param> /// <returns>Returns the escaped data</returns> public static byte[] EscapeToBytes(string data, Encoding encoding, UrlEscapeFlags flags) { return s_defaultEscapeUtility.EscapeToBytes(data, encoding, flags); }
/// <summary> /// Compute length of the data after escaping its values /// </summary> /// <param name="data">The data to escape</param> /// <param name="flags">The flags to modify the behavior</param> /// <returns>The escaped data</returns> public static long ComputeLength(string data, UrlEscapeFlags flags) { return ComputeLength(data, s_defaultEncoding, flags); }
/// <summary> /// Compute length of the data after escaping its values /// </summary> /// <param name="data">The data to escape</param> /// <param name="flags">The flags to modify the behavior</param> /// <returns>The escaped data</returns> public static long ComputeLength(string data, UrlEscapeFlags flags) { return(ComputeLength(data, s_defaultEncoding, flags)); }
/// <summary> /// Compute length of the data after escaping its values /// </summary> /// <param name="data">The data to escape</param> /// <param name="encoding">The encoding to use to convert the string to a byte array</param> /// <param name="flags">The flags to modify the behavior</param> /// <returns>The escaped data</returns> public static long ComputeLength(string data, Encoding encoding, UrlEscapeFlags flags) { return ComputeLength(encoding.GetBytes(data), flags); }
/// <summary> /// URL escape /// </summary> /// <param name="data">The data to escape</param> /// <param name="encoding">The encoding to use to convert the string into a byte array</param> /// <param name="flags">The flags to modify the escaping behavior</param> /// <returns>Returns the escaped data</returns> public static string Escape(string data, Encoding encoding, UrlEscapeFlags flags) { return(s_defaultEscapeUtility.Escape(data, encoding, flags)); }
/// <summary> /// URL escape /// </summary> /// <param name="data">The data to escape</param> /// <param name="flags">The flags to modify the escaping behavior</param> /// <returns>Returns the escaped data</returns> public static string Escape(string data, UrlEscapeFlags flags) { return(UrlEscapeUtility.Escape(data, flags)); }
/// <summary> /// URL escape /// </summary> /// <param name="data">The data to escape</param> /// <param name="encoding">The encoding to use to convert the string into a byte array</param> /// <param name="flags">The flags to modify the escaping behavior</param> /// <returns>Returns the escaped data</returns> public static byte[] EscapeToBytes(string data, Encoding encoding, UrlEscapeFlags flags) { return(s_defaultEscapeUtility.EscapeToBytes(data, encoding, flags)); }
/// <summary> /// URL escape for bytes /// </summary> /// <param name="data">The data to escape</param> /// <param name="flags">The flags to modify the escaping behavior</param> /// <returns>Returns the escaped data</returns> public static string Escape(byte[] data, UrlEscapeFlags flags) { return s_defaultEscapeUtility.Escape(data, flags); }
/// <summary> /// Compute length of the data after escaping its values /// </summary> /// <param name="data">The data to compute the escaped length for</param> /// <param name="encoding">The encoding to use to convert the string into a byte array</param> /// <param name="flags">The flags to modify the escaping behavior</param> /// <returns>Returns the length of the escaped data</returns> public static long ComputeLength(string data, Encoding encoding, UrlEscapeFlags flags) { return(UrlEscapeUtility.ComputeLength(data, encoding, flags)); }
/// <summary> /// URL escape for bytes /// </summary> /// <param name="data">The data to escape</param> /// <param name="flags">The flags to modify the escaping behavior</param> /// <returns>Returns the escaped data</returns> public static byte[] EscapeToBytes(byte[] data, UrlEscapeFlags flags) { return s_defaultEscapeUtility.EscapeToBytes(data, flags); }
/// <summary> /// Compute length of the data after escaping its values /// </summary> /// <param name="data"></param> /// <param name="flags"></param> /// <returns></returns> public static long ComputeLength(string data, UrlEscapeFlags flags) { return(s_defaultEscapeUtility.ComputeLength(data, flags)); }
/// <summary> /// Compute length of the data after escaping its values /// </summary> /// <param name="data">The data to compute the escaped length for</param> /// <param name="encoding">The encoding to use to convert the string into a byte array</param> /// <param name="flags">The flags to modify the escaping behavior</param> /// <returns>Returns the length of the escaped data</returns> public static long ComputeLength(string data, Encoding encoding, UrlEscapeFlags flags) { return UrlEscapeUtility.ComputeLength(data, encoding, flags); }
/// <summary> /// Variant 1 of EscapeToBytes /// </summary> /// <remarks> /// This variant uses a list of bytes. /// </remarks> /// <param name="data">The data to escape</param> /// <param name="flags">The flags to modify the behavior</param> /// <param name="hexChars">The HEX characters used to write the output</param> /// <param name="allowedBytes">The bytes that don't need to be escaped</param> /// <returns>The escaped data</returns> private static byte[] EscapeToBytes1(byte[] data, UrlEscapeFlags flags, byte[] hexChars, ISet<byte> allowedBytes) { var encodedByte = new byte[3]; encodedByte[0] = (byte)'%'; var escapeSpaceAsPlus = (flags & UrlEscapeFlags.EscapeSpaceAsPlus) == UrlEscapeFlags.EscapeSpaceAsPlus; var output = new List<byte>(data.Length); var len = data.Length; var escapeByte = false; for (var i = 0; i != len; ++i) { var v = data[i]; if (allowedBytes.Contains(v)) { output.Add(v); } else if (v == 0x20) { if (escapeSpaceAsPlus) { output.Add((byte)'+'); } else { escapeByte = true; } } else { escapeByte = true; } if (escapeByte) { escapeByte = false; var hiByte = (v >> 4) & 0x0F; var loByte = v & 0x0F; encodedByte[1] = hexChars[hiByte]; encodedByte[2] = hexChars[loByte]; output.AddRange(encodedByte); } } return output.ToArray(); }
/// <summary> /// URL escape /// </summary> /// <param name="data">The data to escape</param> /// <param name="encoding">The encoding to use to convert the string into a byte array</param> /// <param name="flags">The flags to modify the escaping behavior</param> /// <returns>Returns the escaped data</returns> public static string Escape(string data, Encoding encoding, UrlEscapeFlags flags) { return s_defaultEscapeUtility.Escape(data, encoding, flags); }