Существует ли эквивалент 'sscanf ()' в.NET?

Question

Существует ли эквивалент 'sscanf ()' в.NET?

Подобно @ dlev, но это также обрабатывает {1,1,1,2}.ContainsSubsequence({1,1,2})

public static bool ContainsSubsequence<T>(this IEnumerable<T> parent, IEnumerable<T> target)
{
    var pattern = target.ToArray();
    var source = new LinkedList<T>();
    foreach (var element in parent) 
    {
        source.AddLast(element);
        if(source.Count == pattern.Length)
        {
            if(source.SequenceEqual(pattern))
                return true;
            source.RemoveFirst();
        }
    }
    return false;
}

15

string .net

задан doekman 29 January 2009 в 18:39

6 ответов

Другие вопросы по тегам:

string .net

Похожие вопросы:

score 15 · Answer 1

Нет такого метода, вероятно, из-за проблем, разрешающих неоднозначности:

string.Unformat("This {0} very {1}.", "This is very very funny.")
// are the parameters equal to "is" and "very funny", or "is very" and "funny"?

Регулярное выражение получение группы сделаны для этой проблемы; можно хотеть изучить их.

score 4 · Answer 2

Вы могли сделать строку [] части = строка. Разделение (''), и затем извлекает индексными частями положения [1] и частями [3] в Вашем примере.

score 5 · Answer 3

Regex с группировкой?

/This (.*?) very (.*?)./

5

ответ дан 1 December 2019 в 01:46

score 3 · Answer 4

Да. Их называют "регулярными выражениями". Тот, который сделает вещь,

This (?<M0>.+) very (?<M1>.+)\.

3

ответ дан 1 December 2019 в 01:46

score 1 · Answer 5

@mquander: Actualy, PHP решает его даже отличающийся:

$s = "This is very very funny.";
$fmt = "This %s very %s.";
sscanf($s, $fmt, $one, $two);
echo "<div>one: [$one], two: [$two]</div>\n";
//echo's: "one: [is], two: [very]"

, Но возможно Ваш комментарий регулярного выражения может помочь мне. Я просто должен переписать "This {0} very {1}." к чему-то как: new Regex(@"^This (.*) very (.*)\.$"). Это должно быть сделано программатичное, таким образом, я могу использовать одну строку формата в общедоступном интерфейсе класса.

BTW: я имею, уже имеют синтаксический анализатор для нахождения параметров: посмотрите Названный Возвращением Формата запись в блоге Phil Haack (и да, я также хочу, чтобы названные параметры работали оба пути).

score 1 · Answer 6

Я столкнулся с той же проблемой, я полагаю, что существует элегантное решение с использованием REGEX ... но в C # появилась функция "UnFormat" "это работает достаточно хорошо. Извините за отсутствие комментариев.

    /// <summary>
    /// Unformats a string using the original formating string. 
    /// 
    /// Tested Situations:
    ///    UnFormat("<nobr alt=\"1\">1<nobr>", "<nobr alt=\"{0}\">{0}<nobr>") : "1"
    ///    UnFormat("<b>2</b>", "<b>{0}</b>") : "2"
    ///    UnFormat("3<br/>", "{0}<br/>") : "3"
    ///    UnFormat("<br/>4", "<br/>{0}") : "4"
    ///    UnFormat("5", "") : "5"
    ///    UnFormat("<nobr>6<nobr>", "<nobr>{0}<nobr>") : "6"
    ///    UnFormat("<nobr>2009-10-02<nobr>", "<nobr>{0:yyyy-MM-dd}<nobr>") : "2009-10-02"
    ///    UnFormat("<nobr><nobr>", "<nobr>{0}<nobr>") : ""
    ///    UnFormat("bla", "<nobr>{0}<nobr>") : "bla"
    /// </summary>
    /// <param name="original"></param>
    /// <param name="formatString"></param>
    /// <returns>If an "unformat" is not possible the original string is returned.</returns>
    private Dictionary<int,string> UnFormat(string original, string formatString)
    {
       Dictionary<int, string> returnList = new Dictionary<int, string>();

       try{
          int index = -1;

          // Decomposes Format String
          List<string> formatDecomposed = new List<string> (formatString.Split('{'));
          for(int i = formatDecomposed.Count - 1; i >= 0; i--)
          {
             index = formatDecomposed[i].IndexOf('}') + 1;

             if (index > 0 && (formatDecomposed[i].Length - index) > 0)
             {
                formatDecomposed.Insert(i + 1, formatDecomposed[i].Substring(index, formatDecomposed[i].Length - index));
                formatDecomposed[i] = formatDecomposed[i].Substring(0, index);
             }
             else
                //Finished
                break;
          }

          // Finds and indexes format parameters
          index = 0;
          for (int i = 0; i < formatDecomposed.Count; i++)
          {
             if (formatDecomposed[i].IndexOf('}') < 0)
             {
                index += formatDecomposed[i].Length;
             }
             else
             {
                // Parameter Index
                int parameterIndex;
                if (formatDecomposed[i].IndexOf(':')< 0)
                   parameterIndex = Convert.ToInt16(formatDecomposed[i].Substring(0, formatDecomposed[i].IndexOf('}')));
                else
                   parameterIndex = Convert.ToInt16(formatDecomposed[i].Substring(0, formatDecomposed[i].IndexOf(':')));

                // Parameter Value
                if (returnList.ContainsKey(parameterIndex) == false)
                {
                   string parameterValue;

                   if (formatDecomposed.Count > i + 1)
                      if (original.Length > index)
                         parameterValue = original.Substring(index, original.IndexOf(formatDecomposed[i + 1], index) - index);
                      else
                         // Original String not valid
                         break;
                else
                   parameterValue = original.Substring(index, original.Length - index);

                returnList.Add(parameterIndex, parameterValue);
                index += parameterValue.Length;
             }
             else
                index += returnList[parameterIndex].Length;

             }
          }

          // Fail Safe #1
          if (returnList.Count == 0) returnList.Add(0, original);
       } 
       catch
       {
          // Fail Safe #2
          returnList = new Dictionary<int, string>();
          returnList.Add(0, original);
       }

       return returnList;
    }