Оценить экранированную строку

Question

У меня есть несколько строк в файле, которые уже экранированы.Таким образом, содержимое файла выглядит следующим образом:

Hello\nWorld. This is\tGreat.

Когда я читаю файл, я получаю \n как два разных символа вместо одного.

Как я могу преобразовать экранированныйстрока в неэкранированный?

Answer 1

на основе кода @deAtog, я сделал несколько незначительных дополнений

• Поддержка символов формата \ U00000000

• несколько упрощает шестнадцатеричные преобразования

  string UnEscape(string s)
  {
      StringBuilder sb = new StringBuilder();
      Regex r = new Regex("\\\\[abfnrtv?\"'\\\\]|\\\\[0-3]?[0-7]{1,2}|\\\\u[0-9a-fA-F]{4}|\\\\U[0-9a-fA-F]{8}|.");
      MatchCollection mc = r.Matches(s, 0);
  
      foreach (Match m in mc)
      {
          if (m.Length == 1)
          {
              sb.Append(m.Value);
          }
          else
          {
              if (m.Value[1] >= '0' && m.Value[1] <= '7')
              {
                  int i = Convert.ToInt32(m.Value.Substring(1), 8);
                  sb.Append((char)i);
              }
              else if (m.Value[1] == 'u')
              {
                  int i = Convert.ToInt32(m.Value.Substring(2), 16);
                  sb.Append((char)i);
              }
              else if (m.Value[1] == 'U')
              {
                  int i = Convert.ToInt32(m.Value.Substring(2), 16);
                  sb.Append(char.ConvertFromUtf32(i));
              }
              else
              {
                  switch (m.Value[1])
                  {
                      case 'a':
                          sb.Append('\a');
                          break;
                      case 'b':
                          sb.Append('\b');
                          break;
                      case 'f':
                          sb.Append('\f');
                          break;
                      case 'n':
                          sb.Append('\n');
                          break;
                      case 'r':
                          sb.Append('\r');
                          break;
                      case 't':
                          sb.Append('\t');
                          break;
                      case 'v':
                          sb.Append('\v');
                          break;
                      default:
                          sb.Append(m.Value[1]);
                          break;
                  }
              }
          }
      }
  
      return sb.ToString();
  }
  

Answer 2

Вы можете попробовать использовать System.Text.RegularExpressions.Regex.Unescape .

На форумах MSDN также есть запись .

См. Также Как я могу строки Unescape и Reescape в .net? .

Answer 3

Как и вам, я не смог найти достойного решения этой проблемы.Хотя вы, конечно, можете использовать String.Replace, производительность и скорость этого решения просто ужасны.Кроме того, с помощью этого метода трудно поддерживать восьмеричные и юникодные escape-последовательности.Гораздо лучшая альтернатива - использовать простой парсер RegEx.Вот метод, который будет правильно экранировать любую заданную строку.Он поддерживает стандартные escape-последовательности, восьмеричные escape-последовательности и escape-последовательности unicode.

string UnEscape(string s) {
    StringBuilder sb = new StringBuilder();
    Regex r = new Regex("\\\\[abfnrtv?\"'\\\\]|\\\\[0-3]?[0-7]{1,2}|\\\\u[0-9a-fA-F]{4}|.");
    MatchCollection mc = r.Matches(s, 0);

    foreach (Match m in mc) {
        if (m.Length == 1) {
            sb.Append(m.Value);
        } else {
            if (m.Value[1] >= '0' && m.Value[1] <= '7') {
                int i = 0;

                for (int j = 1; j < m.Length; j++) {
                    i *= 8;
                    i += m.Value[j] - '0';
                }

                sb.Append((char)i);
            } else if (m.Value[1] == 'u') {
                int i = 0;

                for (int j = 2; j < m.Length; j++) {
                    i *= 16;

                    if (m.Value[j] >= '0' && m.Value[j] <= '9') {
                        i += m.Value[j] - '0';
                    } else if (m.Value[j] >= 'A' && m.Value[j] <= 'F') {
                        i += m.Value[j] - 'A' + 10;
                    } else if (m.Value[j] >= 'a' && m.Value[j] <= 'f') {
                        i += m.Value[j] - 'a' + 10;
                    }
                }

                sb.Append((char)i);
            } else {
                switch (m.Value[1]) {
                    case 'a':
                        sb.Append('\a');
                        break;
                    case 'b':
                        sb.Append('\b');
                        break;
                    case 'f':
                        sb.Append('\f');
                        break;
                    case 'n':
                        sb.Append('\n');
                        break;
                    case 'r':
                        sb.Append('\r');
                        break;
                    case 't':
                        sb.Append('\t');
                        break;
                    case 'v':
                        sb.Append('\v');
                        break;
                    default:
                        sb.Append(m.Value[1]);
                        break;
                }
            }
        }
    }

    return sb.ToString();
}

Answer 4

вы можете сделать что-то вроде:

string str = str.Replace(@"\n","\n");

Обновление:

Очевидно, что это обходной путь, поскольку сценарий сам по себе "неестественен". Решение Regex.Unescape здесь неприменимо, поскольку оно предназначено для использования для неэкранированных управляющих символов регулярного выражения, а не для новых строк и т. Д.

Для поддержки других соответствующих символов можно написать заменяющую функцию, подобную этой:

public string ReEscapeControlCharacters(string str) {
   return str.Replace(@"\n","\n").Replace(@"\r","\r").Replace(@"\t","\t");
}

Answer 5

Попробуйте:

String replaced = startstring.Replace(System.Environment.NewLine, desirevalue);

Это должно быть допустимо только для "\ n".