C# - Sortieren von Daten in/aus ListBoxen mit Regex

Question

Ich habe eine Datei mit Daten darin, die ich in drei verschiedene ListBoxen aufteilen möchte. Die erste ListBox soll alle Daten enthalten (ein neues Listenelement für jede Zeile der aus dem Textdokument gelesenen Daten).

Haupt-ListBox:

D1
D2
C9
R7
R1
C130
D99
Q9

Zweite ListBox: (nachdem ein Regex verwendet wurde, um Werte abzugleichen, die mit D )

D1
D2
D99

Dritte ListBox: (nachdem ein Regex verwendet wurde, um Werte abzugleichen, die mit C )

C9
C130

Nach dem Abgleich dieser Werte mit den SECOND y DRITTES ListBoxen, die

Neu Haupt-ListBox wird wie folgt aussehen:

R7
R1
Q9  

---

CODE

    static List<string> findPackagePlacementOneType(List<string> list)
    {
        // Creates a new list to return with new format.
        var result = new List<string>();

        // Checks each line in the list.
        foreach (var line in list)
        {
            // PLACEMENT ONE Regex
            Match regexRES = Regex.Match(line, @"^.+(RES)");
            Match regex0402 = Regex.Match(line, @"^.+(0402)");
            Match regex0201 = Regex.Match(line, @"^.+(0201)");
            Match regex0603 = Regex.Match(line, @"^.+(0603)");
            Match regex0805 = Regex.Match(line, @"^.+(0805)");
            Match regex1206 = Regex.Match(line, @"^.+(1206)");
            Match regex1306 = Regex.Match(line, @"^.+(1306)");
            Match regex1608 = Regex.Match(line, @"^.+(1608)");
            Match regex3216 = Regex.Match(line, @"^.+(3216)");
            Match regex2551 = Regex.Match(line, @"^.+(2551)");
            Match regex1913 = Regex.Match(line, @"^.+(1913)");
            Match regex1313 = Regex.Match(line, @"^.+(1313)");
            Match regex2513 = Regex.Match(line, @"^.+(2513)");
            Match regex5125 = Regex.Match(line, @"^.+(5125)");
            Match regex2525 = Regex.Match(line, @"^.+(2525)");
            Match regex5619 = Regex.Match(line, @"^.+(5619)");
            Match regex3813 = Regex.Match(line, @"^.+(3813)");
            Match regex1508 = Regex.Match(line, @"^.+(1508)");
            Match regex6431 = Regex.Match(line, @"^.+(6431)");
            Match regex2512 = Regex.Match(line, @"^.+(2512)");
            Match regex1505 = Regex.Match(line, @"^.+(1505)");
            Match regex2208 = Regex.Match(line, @"^.+(2208)");
            Match regex1005 = Regex.Match(line, @"^.+(1005)");
            Match regex1010 = Regex.Match(line, @"^.+(1010)");
            Match regex2010 = Regex.Match(line, @"^.+(2010)");
            Match regex0505 = Regex.Match(line, @"^.+(0505)");
            Match regex0705 = Regex.Match(line, @"^.+(0705)");
            Match regex1020 = Regex.Match(line, @"^.+(1020)");
            Match regex1812 = Regex.Match(line, @"^.+(1812)");
            Match regex2225 = Regex.Match(line, @"^.+(2225)");
            Match regex5764 = Regex.Match(line, @"^.+(5764)");
            Match regex4532 = Regex.Match(line, @"^.+(4532)");
            Match regex1210 = Regex.Match(line, @"^.+(1210)");
            Match regex0816 = Regex.Match(line, @"^.+(0816)");
            Match regex0363 = Regex.Match(line, @"^.+(0363)");
            Match regexSOT = Regex.Match(line, @"^.+(SOT)");

            if (regexRES.Success || regex0402.Success || regex0201.Success || regex0603.Success ||
                regex0805.Success || regex1206.Success || regex1306.Success || regex1608.Success ||
                regex3216.Success || regex2551.Success || regex1913.Success || regex1313.Success ||
                regex2513.Success || regex5125.Success || regex2525.Success || regex5619.Success ||
                regex3813.Success || regex1508.Success || regex6431.Success || regex2512.Success ||
                regex1505.Success || regex2208.Success || regex1005.Success || regex1010.Success ||
                regex2010.Success || regex0505.Success || regex0705.Success || regex1020.Success ||
                regex1812.Success || regex2225.Success || regex5764.Success || regex4532.Success ||
                regex1210.Success || regex0816.Success || regex0363.Success || regexSOT.Success)
            {
                result.Add(string.Join(" ", line));
            }

            else
                result.Remove(line);
        }

        // Returns the new list so it can be formatted further.
        return result;
    }

    // Finds the placement 2 package types.
    static List<string> findPackagePlacementTwoType(List<string> list)
    {
        // Creates a new list to return with new format.
        var result = new List<string>();

        // Checks each line in the list.
        foreach (var line in list)
        {
            // PLACEMENT TWO Regex
            Match regexBGA = Regex.Match(line, @"^.+(BGA)");
            Match regexSOP8 = Regex.Match(line, @"^.+(SOP8)");
            Match regexQSOP = Regex.Match(line, @"^.+(QSOP)");
            Match regexTQSOP = Regex.Match(line, @"^.+(TQSOP)");
            Match regexSOIC16 = Regex.Match(line, @"^.+(SOIC16)");
            Match regexSOIC12Plus = Regex.Match(line, @"^.+(SOIC12)");
            Match regexSOIC8 = Regex.Match(line, @"^.+(SOIC8)");
            Match regexSO8 = Regex.Match(line, @"^.+(SO8)");
            Match regexSO08 = Regex.Match(line, @"^.+(SO08)");
            Match regexCQFP = Regex.Match(line, @"^.+(CQFP)");
            Match regexLCC = Regex.Match(line, @"^.+(LCC)");
            Match regexLGA = Regex.Match(line, @"^.+(LGA)");
            Match regexOSCCC = Regex.Match(line, @"^.+(OSCCC)");
            Match regexPLCC = Regex.Match(line, @"^.+(PLCC)");
            Match regexQFN = Regex.Match(line, @"^.+(QFN)");
            Match regexQFP = Regex.Match(line, @"^.+(QFP)");
            Match regexSOJ = Regex.Match(line, @"^.+(SOJ)");
            Match regexSON = Regex.Match(line, @"^.+(SON)");

            if (regexBGA.Success || regexSOP8.Success || regexQSOP.Success || regexTQSOP.Success ||
               regexSOIC16.Success || regexSOIC12Plus.Success || regexSOIC8.Success || regexSO8.Success ||
               regexSO08.Success || regexCQFP.Success || regexLCC.Success || regexLGA.Success ||
               regexOSCCC.Success || regexPLCC.Success || regexQFN.Success || regexQFP.Success ||
               regexSOJ.Success || regexSON.Success)
            {
                result.Add(string.Join(" ", line));
            }

            else
                result.Remove(line);
        }

        // Returns the new list so it can be formatted further.
        return result;
    }

    static List<string> findPackagePlacementChoiceType(List<string> list)
    {
        // Creates a new list to return with new format.
        var result = new List<string>();

        // Checks each line in the list.
        foreach (var line in list)
        {
            // PLACEMENT CHOICE Regex
            Match regexCAP = Regex.Match(line, @"^.+(CAP)");
            Match regexIND = Regex.Match(line, @"^.+(IND)");
            Match regexMELF = Regex.Match(line, @"^.+(MELF)");
            Match regexDIOM = Regex.Match(line, @"^.+(DIOM)");
            Match regexSOD = Regex.Match(line, @"^.+(SOD)");
            Match regexSTO = Regex.Match(line, @"^.+(STO)");
            Match regexTO = Regex.Match(line, @"^.+(TO)");

            if (regexCAP.Success || regexIND.Success || regexMELF.Success || regexDIOM.Success ||
               regexSOD.Success || regexSTO.Success || regexTO.Success)
            {
                result.Add(string.Join(" ", line));
            }

            else
                result.Remove(line);
        }

        // Returns the new list so it can be formatted further.
        return result;
    }

---

FRAGEN

Ich habe derzeit meine regulären Ausdrücke, die durch sortieren und teilen Sie die Datei in drei getrennte ListBoxen. Jedoch... Ich würde lieber die Daten in einer der ListBoxen platziert haben und dann sortiert/entfernt aus, dass ListBox, wenn es den richtigen regulären Ausdruck entspricht.

• Wie gehe ich vor, wenn ich das .txt-Dokument in die ListBox lade (wobei jede neue Zeile ein neues Element in der ListBox ist) und dann durch jede Zeile in der Haupt-ListBox mit Regex, um festzustellen, ob die Zeilen in eine andere zweite o dritte ListBox oder bleiben in der Haupt-ListBox ?

Answer 1

Anstatt mehrere Regexe zu verwenden, könnten Sie sie einfach zu einer kombinieren.

Sie müssen auch nicht anrufen Regex.Match gefolgt von match.Success ; einfach anrufen Regex.IsMatch .

Ich verstehe nicht, warum Sie die result.Remove(line) . Sie haben diese nicht übereinstimmende Zeile nie hinzugefügt, warum müssen Sie sie also entfernen?

Schließlich glaube ich nicht, dass Sie die Methode speziell für die Verwendung von List<string> . Sie können sie allgemeiner gestalten, indem Sie angeben IEnumerable<string> .

Ich habe den ersten Text umgeschrieben, um das Prinzip zu verdeutlichen:

static IEnumerable<string> findPackagePlacementOneType(IEnumerable<string> list)
{
    return list.Where(line => Regex.IsMatch(line,
        @"^.+(RES|0402|0201|0603|0805|1206|1306|1608|3216|2551|1913|1313|2513" +
        @"|5125|2525|5619|3813|1508|6431|2512|1505|2208|1005|1010|2010|0505" +
        @"|0705|1020|1812|2225|5764|4532|1210|0816|0363|SOT)"
    ));
}

Wenn Sie wirklich einmal ein neues List<string> können Sie einfach hinzufügen .ToList() nach einem Aufruf von findPackagePlacementOneType .

Answer 2

Ich würde empfehlen, ein paar zu machen ObservableCollection<string> s, eine für jeden Ihrer ListBox es. ObservableCollection s Ereignisse auslösen, wenn Elemente hinzugefügt oder entfernt werden, was Dinge wie ListBox Sie werden automatisch aktualisiert, wenn sie sich ändern. Angenommen, sie heißen items1 , 2 et 3 . Beginnen Sie mit items1 = new ObservableCollection<string>(list); und die anderen als leere Sammlungen initialisiert. Überarbeiten Sie auch die Methoden, die Sie gepostet haben, um eine einzelne string und geben eine bool ob sie mit einer übereinstimmt.

Teil 1, das Einfügen von Zeichenkettensammlungen in die ListBox es:

mainListBox.ItemsSource = items1;
listBox2.ItemsSource = items2;
listBox3.ItemsSource = items3;

Teil 2: Gehen Sie die einzelnen Punkte der Liste durch:

foreach (string str in items1.ToArray())
{
    if (isPackagePlacementOneType(str))
    {
        items1.Remove(str);
        items2.Add(str);
    } else if ...
}

Die .ToArray() ist die LINQ-Erweiterung; sie wird benötigt, weil man eine Aufzählung, durch die man iteriert, nicht ändern kann.

Teil 3: Außerdem würde ich empfehlen, die Methoden nach dem Prinzip "Do not Repeat Yourself" (DRY) ein wenig zu überarbeiten:

static readonly string[] match1 = new [] { "RES", ... };
static readonly string[] match2 = new [] { "BGA", ... };
static readonly string[] match3 = new [] { "CAP", ... };
//(then in the methods)
return match1.Any(x=>Regex.Match(line, @"^.+(" + x + ")").Success);

Dies hat auch den Vorteil, dass nicht Dutzende von Regexen ausgewertet werden müssen, die am Ende gar nicht gelesen werden.