Suchen Sie Text in einer Zeichenfolge mit C #

Wie kann ich einen bestimmten Text in einer Zeichenfolge finden? Danach möchte ich eine neue Zeichenfolge zwischen dieser und etwas anderem erstellen. Zum Beispiel, wenn die Zeichenfolge war:

This is an example string and my data is here

Und ich möchte eine Zeichenfolge mit dem Wert zwischen "mein" und "ist" erstellen. Wie kann ich das tun? Das ist ziemlich pseudo, aber hoffentlich macht es Sinn.

Verwenden Sie diese Methode:

public static string getBetween(string strSource, string strStart, string strEnd)
{
    if (strSource.Contains(strStart) && strSource.Contains(strEnd))
    {
        int Start, End;
        Start = strSource.IndexOf(strStart, 0) + strStart.Length;
        End = strSource.IndexOf(strEnd, Start);
        return strSource.Substring(Start, End - Start);
    }

    return "";
}

Wie man es benutzt:

string source = "This is an example string and my data is here";
string data = getBetween(source, "my", "is");

Dies ist der einfachste Weg:

if(str.Contains("hello"))

Sie könnten Regex verwenden:

var regex = new Regex(".*my (.*) is.*");
if (regex.IsMatch("This is an example string and my data is here"))
{
    var myCapturedText = regex.Match("This is an example string and my data is here").Groups[1].Value;
    Console.WriteLine("This is my captured text: {0}", myCapturedText);
}

 string string1 = "This is an example string and my data is here";
 string toFind1 = "my";
 string toFind2 = "is";
 int start = string1.IndexOf(toFind1) + toFind1.Length;
 int end = string1.IndexOf(toFind2, start); //Start after the index of 'my' since 'is' appears twice
 string string2 = string1.Substring(start, end - start);

Hier ist meine Funktion mit Oscar Jaras Funktion als Modell.

public static string getBetween(string strSource, string strStart, string strEnd) {
   const int kNotFound = -1;

   var startIdx = strSource.IndexOf(strStart);
   if (startIdx != kNotFound) {
      startIdx += strStart.Length;
      var endIdx = strSource.IndexOf(strEnd, startIdx);
      if (endIdx > startIdx) {
         return strSource.Substring(startIdx, endIdx - startIdx);
      }
   }
   return String.Empty;
}

Diese Version führt höchstens zwei Suchvorgänge im Text durch. Es vermeidet eine Ausnahme, die von Oskars Version ausgelöst wird, wenn nach einer Endzeichenfolge gesucht wird, die nur vor der Startzeichenfolge auftritt, d. H.getBetween(text, "my", "and"); . H.

Die Verwendung ist die gleiche:

string text = "This is an example string and my data is here";
string data = getBetween(text, "my", "is");

Sie können es kompakt so machen:

string abc = abc.Replace(abc.Substring(abc.IndexOf("me"), (abc.IndexOf("is", abc.IndexOf("me")) + 1) - abc.IndexOf("size")), string.Empty);

Mit Ausnahme der Antwort von @ Prashant wurden die obigen Antworten falsch beantwortet. Wo ist die "Ersetzen" -Funktion der Antwort? Das OP fragte: "Danach möchte ich eine neue Zeichenfolge zwischen dieser und etwas anderem erstellen."

Aufgrund der hervorragenden Resonanz von @ Oscar habe ich seine Funktion zu einer "Search And Replace"Funktion in einer erweitert.

Ich denke, die Antwort von @ Prashant hätte die vom OP akzeptierte Antwort sein sollen, da sie ersetzt.

Jedenfalls habe ich meine Variante angerufen - ReplaceBetween().

public static string ReplaceBetween(string strSource, string strStart, string strEnd, string strReplace)
{
    int Start, End;
    if (strSource.Contains(strStart) && strSource.Contains(strEnd))
    {
        Start = strSource.IndexOf(strStart, 0) + strStart.Length;
        End = strSource.IndexOf(strEnd, Start);
        string strToReplace = strSource.Substring(Start, End - Start);
        string newString = strSource.Concat(Start,strReplace,End - Start);
        return newString;
    }
    else
    {
        return string.Empty;
    }
}

  string WordInBetween(string sentence, string wordOne, string wordTwo)
        {

            int start = sentence.IndexOf(wordOne) + wordOne.Length + 1;

            int end = sentence.IndexOf(wordTwo) - start - 1;

            return sentence.Substring(start, end);


        }

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading;
using System.Diagnostics;

namespace oops3
{


    public class Demo
    {

        static void Main(string[] args)
        {
            Console.WriteLine("Enter the string");
            string x = Console.ReadLine();
            Console.WriteLine("enter the string to be searched");
            string SearchText = Console.ReadLine();
            string[] myarr = new string[30];
             myarr = x.Split(' ');
            int i = 0;
            foreach(string s in myarr)
            {
                i = i + 1;
                if (s==SearchText)
                {
                    Console.WriteLine("The string found at position:" + i);

                }

            }
            Console.ReadLine();
        }


    }












        }

static void Main(string[] args)
    {

        int f = 0;
        Console.WriteLine("enter the string");
        string s = Console.ReadLine();
        Console.WriteLine("enter the word to be searched");
        string a = Console.ReadLine();
        int l = s.Length;
        int c = a.Length;

        for (int i = 0; i < l; i++)
        {
            if (s[i] == a[0])
            {
                for (int K = i + 1, j = 1; j < c; j++, K++)
                {
                    if (s[K] == a[j])
                    {
                        f++;
                    }
                }
            }
        }
        if (f == c - 1)
        {
            Console.WriteLine("matching");
        }
        else
        {
            Console.WriteLine("not found");
        }
        Console.ReadLine();
    }

Dies ist der richtige Weg, um einen Teil des Textes innerhalb einer Zeichenfolge zu ersetzen (basierend auf der getBetween-Methode von Oscar Jara):

public static string ReplaceTextBetween(string strSource, string strStart, string strEnd, string strReplace)
    {
        int Start, End, strSourceEnd;
        if (strSource.Contains(strStart) && strSource.Contains(strEnd))
        {
            Start = strSource.IndexOf(strStart, 0) + strStart.Length;
            End = strSource.IndexOf(strEnd, Start);
            strSourceEnd = strSource.Length - 1;

            string strToReplace = strSource.Substring(Start, End - Start);
            string newString = string.Concat(strSource.Substring(0, Start), strReplace, strSource.Substring(Start + strToReplace.Length, strSourceEnd - Start));
            return newString;
        }
        else
        {
            return string.Empty;
        }
    }

Das string.Concatverkettet 3 Strings:

1. Der String-Quellteil vor dem zu ersetzenden String gefunden - strSource.Substring(0, Start)
2. Die ersetzende Zeichenfolge - strReplace
3. Der String-Quellteil nach dem zu ersetzenden String gefunden - strSource.Substring(Start + strToReplace.Length, strSourceEnd - Start)

Wenn Sie wissen, dass Sie immer die Zeichenfolge zwischen "my" und "is" möchten, können Sie immer Folgendes ausführen:

string message = "This is an example string and my data is here";

//Get the string position of the first word and add two (for it's length)
int pos1 = message.IndexOf("my") + 2;

//Get the string position of the next word, starting index being after the first position
int pos2 = message.IndexOf("is", pos1);

//use substring to obtain the information in between and store in a new string
string data = message.Substring(pos1, pos2 - pos1).Trim();

Finden Sie zuerst den Index des Textes und dann den Teilstring

        var ind = Directory.GetCurrentDirectory().ToString().IndexOf("TEXT To find");

        string productFolder = Directory.GetCurrentDirectory().ToString().Substring(0, ind);

Fügen Sie einfach diesen Code hinzu:

if (string.Contains ("search_text")) {MessageBox.Show ("Message."); }}