Как Парсинг строки между [STX] и [ETX], используя C # - Разделить / Добавить вывод, используя Regex или String Функции - PullRequest
1 голос
/ 27 сентября 2010

Язык = C # .NET

Все, что находится между [STX] и [ETX] должно быть принято, остальные вещи должны быть отклонены.

string startparam = "[STX]";
string endparam = "[ETX]";

String str1 = "[STX]some string 1[ETX]"; //Option 1
String str2 = "sajksajsk [STX]some string 2 [ETX] saksla"; //Option 2
String str3 = "[ETX] dksldkls [STX]some string 3 [ETX]ds ds"; //Option 3
String str4 = "dksldkls [STX]some string 4.1[ETX]ds ds [STX] some string 4.2[ETX] jdskjd"; //Option 4

/* the various strings can be appended and converted to a single 
   string using string builder or treat them as different strings*/

ProcessString (string str , string startparam , string endparam)
{
   //What To Write here using RegEX or String Functions in c#

}

/* The output after passing these to a ProcessString () */     
/* Append Output To a TextBox or Append it to a String using For Loop.*/

/* Output Required */

some string 1 
some string 2
some string 3
some string 4.1 
some string 4.2

=============================================== ==============================

РЕДАКТИРОВАТЬ 2

Language = C#

string str = "
[STX]some string 1[ETX]
sajksajsk [STX]some string 2 [ETX] saksla
[ETX] dksldkls [STX]some string 3 [ETX]ds ds
dksldk[STX]ls [STX]some st[ETX]ring 4.1[ETX]ds ds [STX]some string 4.2[ETX] jdskjd";

Как получить такой же вывод, если массив строк представляет собой одну строку

/* output */
some string 1 
some string 2
some string 3
some string 4.1 
some string 4.2


/*case 1*/ 
the above string can be "[STX] djkdsj [STX]dskd1[ETX] dsnds[ETX]" 
the output should be just "dskd1"

/*case 2*/ 
the above string can be "[STX] djkdsj [STX]dskd1[ETX] ddd" 
the output should be just "dskd1"

/*case 3*/ 
the above string can be " kdsj [STX]dskd1[ETX] dsnds[ETX]" 
the output should be just "dskd1"

/*case 4*/ 
the above string can be "[STX] djk[STX]dsj [STX]dskd2[ETX] ddd" 
the output should be just "dskd2"

The real problem comes when [STX] followed by [STX] i want to consider the newer [STX] and start string processing from the newer [STX] occurance. Eg. Case 2 above

=============================================== ==============================

РЕДАКТИРОВАТЬ 3: Новый запрос

Язык = C #

Если я хочу, чтобы данные между [STX] и [STX] также могли быть выполнены.

Новый RegEx, который будет извлекать данные между 1. [STX] некоторые данные [STX] 2. [STX] некоторые данные [ETX]

Например.

/* the above string can be */
"[STX] djk[STX]dsj [STX]dskd2[ETX] ddd" 
/* the output should be just */
djk
dsj
dskd2

Поскольку [STX] означает, что передача была начата, я хочу также извлечь данные между STX.

Ответы [ 4 ]

5 голосов
/ 25 октября 2012

Это работает для меня:

string[] sepValues = input.Split(new char[] {'\u0002', '\u0003'},
                                 StringSplitOptions.RemoveEmptyEntries);
1 голос
/ 28 сентября 2010
(?<=\[STX\])(?:(?!\[STX\]).)*?(?=\[ETX\])

соответствует любому тексту (кроме новых строк) между [STX] и [ETX]:

(?<=\[STX\])  # Are we right after [STX]? If so,...
(?:           # match 0 or more of the following:
 (?!\[STX\])  # (as long as it's not possible to match [STX] here)
 .            # exactly one character
 )*?          # repeat as needed until...
(?=\[ETX\])   # there is a [ETX] ahead.

Это всегда будет соответствовать somestring в каждом из следующего:

blah blah [STX]somestring[ETX] blah blah
[STX]somestring[ETX] blah [STX]somestring[ETX] (hey, two matches here!)
[STX] not this! [STX]somestring[ETX] not this either! [ETX]
blah [ETX] [STX]somestring[ETX] [STX] bla bla

Полная справка о положительных / отрицательных утверждениях lookbehind и lookahead (три из которых используются в этом регулярном выражении) может быть найдена в превосходном руководстве по регулярным выражениям Яна Гойваэрта по адресу http://www.regular -expressions.info / lookaround.html.

0 голосов
/ 28 сентября 2010

РЕДАКТИРОВАТЬ: , чтобы соответствовать вашим обновленным требованиям, вы должны использовать этот шаблон, который использует обходные пути, чтобы пропустить все группы STX, кроме последней, которая имеет ETX после него:

string pattern = @"(?<=\[STX])?.*\[STX]\s*(.+?)\s*\[ETX].*?";

Вот полный пример:

string input = @"[STX]some string 1[ETX]
sajksajsk [STX]some string 2 [ETX] saksla
[ETX] dksldkls [STX]some string 3 [ETX]ds ds
dksldkls [STX]some string 4.1[ETX]ds ds [STX] some string 4.2[ETX] jdskjd
[STX] djkdsj [STX]dskd1[ETX] dsnds[ETX]
[STX] djkdsj [STX]dskd1[ETX] ddd
kdsj [STX]dskd1[ETX] dsnds[ETX] 
[STX] djk[STX]dsj [STX]dskd2[ETX] ddd";

string pattern = @"(?<=\[STX])?.*\[STX]\s*(.+?)\s*\[ETX].*?";

foreach(Match m in Regex.Matches(input, pattern))
{
    // result will be in first group
    Console.WriteLine(m.Groups[1].Value);
}

Я также добавил \s* между группировкой, чтобы устранить лишние пробелы. При этом вам больше не нужно использовать Trim(), как я предложил в моем предыдущем ответе ниже.


ПРЕДЫДУЩИЙ ОТВЕТ

Этот шаблон должен соответствовать: "\[STX](.+?)\[ETX]"

Обратите внимание, что открывающая скобка, [, должна быть экранирована, чтобы ее нельзя было интерпретировать как класс символов в регулярном выражении. Закрывающую скобку ] не нужно экранировать. (.+?) является группой захвата (из-за круглых скобок) и соответствует по крайней мере одному символу без жадности (через ?). Будучи не жадным, он предотвращает жадное сопоставление обработчиком регулярных выражений нескольких вхождений и содержимого до последнего вхождения «[ETX]». Удалите ?, и вы поймете, что я имею в виду в вашем str4 примере. Поскольку в вашем последнем примере есть несколько вхождений, вы можете использовать метод Matches .

string[] inputs =
{
    "[STX]some string 1[ETX]",
    "sajksajsk [STX]some string 2 [ETX] saksla",
    "[ETX] dksldkls [STX]some string 3 [ETX]ds ds",
    "dksldkls [STX]some string 4.1[ETX]ds ds [STX] some string 4.2[ETX] jdskjd"
};

string pattern = @"\[STX](.+?)\[ETX]";

foreach (string input in inputs)
{
    Console.WriteLine("Input: " + input);
    foreach(Match m in Regex.Matches(input, pattern))
    {
        // result will be in first group
        Console.WriteLine(m.Groups[1].Value);
    }

      Console.WriteLine();
}

Вы можете использовать Trim() для обрезки лишних пробелов (m.Groups[1].Value.Trim()). Это возможно сделать по шаблону, но усложняет его без необходимости. Используйте перегрузку, которая принимает RegexOptions.IgnoreCase, если вам нужно игнорировать регистр текста "STX" и "ETX" (если они не всегда в верхнем регистре).

0 голосов
/ 27 сентября 2010

Попробуйте это:

Regex regex = new Regex(@"\[STX\](.*?)\[ETX\]", RegexOptions.IgnoreCase);

А затем просто выберите группу, чтобы получить строку между тегами

...