Überprüfen, ob Textbox bestimmtes Text beinhaltet

Hallo Community, bin recht neu hier im Forum und im C# Bereich.
Ich habe mir die Regeln durchgelesen, und informiert, wie ich hier auf dem Forum 'richtig' poste. 😃

Soo, zu meinem Problem:
Ich möchte gerne wissen, ob textBox2 (Mehrzeilig) ein bestimmtes Text beinhaltet, z.B. "Stop".
Wie kriege ich das hin? Ich habe versucht bei jeder Eingabe die letzte Zeile zu überprüfen, weil das Text alleine auf einer Zeile steht, jedoch hatte ich kein Erfolg.
Könnte mir jemand einen Ansatz für die Lösung geben? Wie ich es lösen könnte?

Vielen Dank schonmal,
MfG HighZane.

Hallo,

wie sieht den dein Code bis jetzt aus?

Aus dem Kopf geschrieben (Könnte Fehler enthalten)

if(textbox1.Text.Contains("Stop"))
{
 //Stop entahlten
}
else
{
 //Das Wort Stop nicht entalten
}

oder

if(textbox1.Text.IndexOf("Stop")>=0)
{
 //Stop entahlten
}
else
{
 //Das Wort Stop nicht entalten
}

Hallo HighZane,

Wenn du wissen willst ob NUR das Wort stop in der TextBox steht und nichts anderes kannst du das verwenden:

if(textBox1.Text == "stop")
{
     //Nur 'stop' steht drin
}
else
{
     //'stop' steht nicht drin
}

Anderseits kann man das aber auch relativ leicht googlen 😉

Google Suche nach "c# inhalt von textbox prüfen"

Mfg
Eniplay

Hi 123thomas, ich glaube deine Lösung wird mich weiterbringen.
Ich probiere es gleich, und sage Bescheid 😃

Und hallo Eniplay, das ist mir klar, aber ich möchte ja prüfen, ob das Text 'Stop' beinhaltet, und nicht ob es nur aus 'Stop' besteht. Danke trotzdem 😃

Und hallo Eniplay, das ist mir klar, aber ich möchte ja prüfen, ob das Text 'Stop' beinhaltet, und nicht ob es nur aus 'Stop' besteht. Danke trotzdem 😃

Ja gut dann ist die Methode von 123thomas die richtige 😃

Hey,
123thomas hat mir die richtige Lösung geliefert! Vielen Dank euch.
Jedoch hätte ich noch eine Frage:
Wie kriege ich das hin, dass ich die Anzahl von textBox2.Text.Contains("stop this") als int habe? Also die Anzahl der "stop this" in meinem textBox2 als int?

Ich hoffe ihr versteht mich, vielen Dank schonmal 😄

Schnellste Methode[1] wäre

int count = (textBox2.Text.Length -  textBox2.Text.Replace("stop this","").Length) / "stop this".Length;

Etwas langsamer, aber besser nachzuvollziehen:

int count = textBox2.Text.Split(new string[] { "stop this" }, StringSplitOptions.None).Length - 1;

LaTino
[1] ..die mir auf die Schnelle einfällt

Vielen Dank Latino, somit wäre mein Problem gelöst.

Etwas komplizierter:

        public static int CountString(string source, string find, StringComparison comparison)
        {
            const int INVALID_FIND_VALUE = -1;
            if (string.IsNullOrEmpty(find)) return INVALID_FIND_VALUE;
            if (string.IsNullOrEmpty(source)) return 0;

            int startIndex = 0;
            int sum = 0;

            while (startIndex < source.Length)
            {
                int newIndex = source.IndexOf(find, startIndex, comparison);

                if (newIndex == -1)
                {
                    return sum;
                }
                else
                {
                    sum++;
                    startIndex = newIndex + find.Length;
                }
            }

            return sum;
        }

Und hier der Aufruf:

        private void textBox1_TextChanged(object sender, EventArgs e)
        {
            DoCountString();
        }

        private void textBox2_TextChanged(object sender, EventArgs e)
        {
            DoCountString();
        }

        void DoCountString()
        {
            textBox3.Text = "Counted strings = " + CountString(textBox1.Text, textBox2.Text, StringComparison.OrdinalIgnoreCase);
        }

Wow! LaTinos Methode ist sogar schneller als meine.

noch eine schnellere Möglichkeit wäre mit Regex 😁 :

Regex reg = new Regex("stop this");
int count = reg.Matches(textBox2.Text).Count;

kurze Zeitmessung (builder.Length => 6.168.000):

static void Main(string[] args)
{
    StringBuilder builder = new StringBuilder();
    for (int i = 0; i < 1000; i++)
    {
        builder.Append(_testText);
    }

    Method1(builder.ToString());
    Method1(builder.ToString());
    Method1(builder.ToString());

    Console.WriteLine();

    Method2(builder.ToString());
    Method2(builder.ToString());
    Method2(builder.ToString());

    Console.WriteLine();

    Method3(builder.ToString());
    Method3(builder.ToString());
    Method3(builder.ToString());

    Console.ReadLine();
}

static void Method1(string text)
{
    Stopwatch watch = Stopwatch.StartNew();
    int count = (text.Length - text.Replace(_search, string.Empty).Length) / _search.Length;
    watch.Stop();
    Console.WriteLine("Method1 Count: {0} Duration: {1:0.0} ms", count, watch.ElapsedMilliseconds);
}

static void Method2(string text)
{
    Stopwatch watch = Stopwatch.StartNew();
    int count = text.Split(new string[] { _search }, StringSplitOptions.None).Length - 1;
    watch.Stop();
    Console.WriteLine("Method2 Count: {0} Duration: {1:0.0} ms", count, watch.ElapsedMilliseconds);
}

static void Method3(string text)
{
    Regex reg = new Regex(_search);
    Stopwatch watch = Stopwatch.StartNew();
    int count = reg.Matches(text).Count;
    watch.Stop();
    Console.WriteLine("Method3 Count: {0} Duration: {1:0.0} ms", count, watch.ElapsedMilliseconds);
}

Ausgabe bei mir (Release ohne Debugger):

Method1 Count: 9000 Duration: 36,0 ms
Method1 Count: 9000 Duration: 34,0 ms
Method1 Count: 9000 Duration: 35,0 ms

Method2 Count: 9000 Duration: 62,0 ms
Method2 Count: 9000 Duration: 75,0 ms
Method2 Count: 9000 Duration: 56,0 ms

Method3 Count: 9000 Duration: 8,0 ms
Method3 Count: 9000 Duration: 8,0 ms
Method3 Count: 9000 Duration: 14,0 ms

Ich kapiers nicht. Eine reine Zeichensuche muss doch schneller sein als eine Zeichenkettenmanipulation. Und Regex müsste doch auf Grund seiner Komplexität langsamer sein, als eine auf die Anforderung spezialisierte Suchfunktion. Wo ist mein Denkfehler?

Aber tatsächlich ists vollkommen unwichtig, ob 9000 irre lange testTexte in 35ms ausgezählt sind oder in 8.

Viel wichtiger ist, dass der Code leicht verständlich ist: 3 Rules of Optimization

😉

Ich kapiers nicht. Eine reine Zeichensuche muss doch schneller sein als eine Zeichenkettenmanipulation. Und Regex müsste doch auf Grund seiner Komplexität langsamer sein, als eine auf die Anforderung spezialisierte Suchfunktion. Wo ist mein Denkfehler?

Zuerst einmal, was ErfinderDesRades gesagt hat. Zum zweiten ist string.Replace[1] schneller, als für jedes Vorkommen des Suchbegriffs den string bis zum nächsten Treffer durchzuenumerieren. Einfach ausgedrückt: du bekommst mit deiner Methode zusätzlich die Information darüber, WO der gesuchte String steht, obwohl du diese Information nicht brauchst. Das kostet Zeit. Je häufiger der gesuchte Begriff vorkommt, desto ineffizienter ist deine Methode.

Zum dritten sollte einem bei solchen Einsatzzwecke eigentlich direkt regex einfallen, was mir (wiedermal) auch durch die Lappen gerutscht ist 😃.

LaTino
[1] ruft die externe Methode ReplaceInternal auf, die sehr effizient ist