String zwischen zwei Strings in einem String abrufen

Vielleicht ist ein guter Weg, einfach einen Teilstring auszuschneiden:

String St = "super exemple of string key : text I want to keep - end of my string";

int pFrom = St.IndexOf("key : ") + "key : ".Length;
int pTo = St.LastIndexOf(" - ");

String result = St.Substring(pFrom, pTo - pFrom);

string input = "super exemple of string key : text I want to keep - end of my string";
var match = Regex.Match(input, @"key : (.+?)-").Groups[1].Value;

oder nur mit Stringoperationen

var start = input.IndexOf("key : ") + 6;
var match2 = input.Substring(start, input.IndexOf("-") - start);

Sie können es ohne Regex tun

 input.Split(new string[] {"key :"},StringSplitOptions.None)[1]
      .Split('-')[0]
      .Trim();

Je nachdem, wie robust/flexibel Ihre Implementierung sein soll, kann dies tatsächlich etwas schwierig sein. Hier ist die Implementierung, die ich verwende:

public static class StringExtensions {
    /// <summary>
    /// takes a substring between two anchor strings (or the end of the string if that anchor is null)
    /// </summary>
    /// <param name="this">a string</param>
    /// <param name="from">an optional string to search after</param>
    /// <param name="until">an optional string to search before</param>
    /// <param name="comparison">an optional comparison for the search</param>
    /// <returns>a substring based on the search</returns>
    public static string Substring(this string @this, string from = null, string until = null, StringComparison comparison = StringComparison.InvariantCulture)
    {
        var fromLength = (from ?? string.Empty).Length;
        var startIndex = !string.IsNullOrEmpty(from) 
            ? @this.IndexOf(from, comparison) + fromLength
            : 0;

        if (startIndex < fromLength) { throw new ArgumentException("from: Failed to find an instance of the first anchor"); }

            var endIndex = !string.IsNullOrEmpty(until) 
            ? @this.IndexOf(until, startIndex, comparison) 
            : @this.Length;

        if (endIndex < 0) { throw new ArgumentException("until: Failed to find an instance of the last anchor"); }

        var subString = @this.Substring(startIndex, endIndex - startIndex);
        return subString;
    }
}

// usage:
var between = "a - to keep x more stuff".Substring(from: "-", until: "x");
// returns " to keep "

Regex ist hier übertrieben.

Sie könnten verwenden string.Split mit der Überladung, die einen string[] für die Trennzeichen erfordert, aber das wäre auch ein Overkill.

In Substring und IndexOf - schauen Sie sich die erste an, um Teile eines Strings und einen Index und eine Länge zu erhalten, und den zweiten, um indexierte innere Strings/Zeichen zu finden.

So kann ich das machen

   public string Between(string STR , string FirstString, string LastString)
    {       
        string FinalString;     
        int Pos1 = STR.IndexOf(FirstString) + FirstString.Length;
        int Pos2 = STR.IndexOf(LastString);
        FinalString = STR.Substring(Pos1, Pos2 - Pos1);
        return FinalString;
    }

Ich denke das funktioniert: 

   static void Main(string[] args)
    {
        String text = "One=1,Two=2,ThreeFour=34";

        Console.WriteLine(betweenStrings(text, "One=", ",")); // 1
        Console.WriteLine(betweenStrings(text, "Two=", ",")); // 2
        Console.WriteLine(betweenStrings(text, "ThreeFour=", "")); // 34

        Console.ReadKey();

    }

    public static String betweenStrings(String text, String start, String end)
    {
        int p1 = text.IndexOf(start) + start.Length;
        int p2 = text.IndexOf(end, p1);

        if (end == "") return (text.Substring(p1));
        else return text.Substring(p1, p2 - p1);                      
    }

oder mit einer Regex.

using System.Text.RegularExpressions;

...

var value =
    Regex.Match(
        "super exemple of string key : text I want to keep - end of my string",
        "key : (.*) - ")
    .Groups[1].Value;

mit einem laufendem Beispiel .

Sie können entscheiden, ob es zu viel ist.

oder

als untervalidierte Erweiterungsmethode

using System.Text.RegularExpressions;

public class Test
{
    public static void Main()
    {
        var value =
                "super exemple of string key : text I want to keep - end of my string"
                    .Between(
                        "key : ",
                        " - ");

        Console.WriteLine(value);
    }
}

public static class Ext
{
    static string Between(this string source, string left, string right)
    {
        return Regex.Match(
                source,
                string.Format("{0}(.*){1}", left, right))
            .Groups[1].Value;
    }
}

 string str="super exemple of string key : text I want to keep - end of my string";
        int startIndex = str.IndexOf("key") + "key".Length;
        int endIndex = str.IndexOf("-");
        string newString = str.Substring(startIndex, endIndex - startIndex);

Eine funktionierende LINQ-Lösung:

string str = "super exemple of string key : text I want to keep - end of my string";
string res = new string(str.SkipWhile(c => c != ':')
                           .Skip(1)
                           .TakeWhile(c => c != '-')
                           .ToArray()).Trim();
Console.WriteLine(res); // text I want to keep

Da : und - eindeutig sind, können Sie Folgendes verwenden: 

string input;
string output;
input = "super example of string key : text I want to keep - end of my string";
output = input.Split(new char[] { ':', '-' })[1];

Sie können die Erweiterungsmethode unten verwenden:

public static string GetStringBetween(this string token, string first, string second)
    {            
        if (!token.Contains(first)) return "";

        var afterFirst = token.Split(new[] { first }, StringSplitOptions.None)[1];

        if (!afterFirst.Contains(second)) return "";

        var result = afterFirst.Split(new[] { second }, StringSplitOptions.None)[0];

        return result;
    }

Verwendung ist: 

var token = "super exemple of string key : text I want to keep - end of my string";
var keyValue = token.GetStringBetween("key : ", " - ");

Ich habe das Code-Snippet von Vijay Singh Rana verwendet, das im Grunde genommen die Aufgabe erfüllt. Es verursacht jedoch Probleme, wenn das firstString bereits das lastString enthält. Ich wollte ein access_token aus einer JSON-Antwort extrahieren (kein JSON-Parser geladen). Mein firstString war \"access_token\": \" und mein lastString war \". Am Ende hatte ich eine kleine Modifikation

string Between(string str, string firstString, string lastString)
{    
    int pos1 = str.IndexOf(firstString) + firstString.Length;
    int pos2 = str.Substring(pos1).IndexOf(lastString);
    return str.Substring(pos1, pos2);
}

Sie haben bereits einige gute Antworten und ich weiß, dass der von mir bereitgestellte Code alles andere als effizient und sauber ist. Ich dachte jedoch, es könnte für Bildungszwecke nützlich sein. Wir können den ganzen Tag über vorgefertigte Klassen und Bibliotheken verwenden. Aber ohne das Innenleben zu verstehen, ahmen wir es einfach nach und wiederholen es und werden nie etwas lernen. Dieser Code funktioniert und ist grundlegender oder "jungfräulich" als einige der anderen:

char startDelimiter = ':';
char endDelimiter = '-';

Boolean collect = false;

string parsedString = "";

foreach (char c in originalString)
{
    if (c == startDelimiter)
         collect = true;

    if (c == endDelimiter)
         collect = false;

    if (collect == true && c != startDelimiter)
         parsedString += c;
}

Am Ende wird die gewünschte Zeichenfolge der Variablen parsedString zugewiesen. Denken Sie daran, dass damit auch fortlaufende und vorhergehende Leerzeichen erfasst werden. Denken Sie daran, dass ein String einfach ein Array von Zeichen ist, das wie andere Arrays mit Indizes usw. bearbeitet werden kann.

Sich kümmern.

var matches = Regex.Matches(input, @"(?<=key :)(.+?)(?=-)");

Dies gibt nur die Werte zwischen "Schlüssel:" und dem folgenden Vorkommen von "-" zurück.

Wenn Sie nach einer 1-Zeilen-Lösung suchen, ist dies Folgendes:

s.Substring(s.IndexOf("eT") + "eT".Length).Split("97".ToCharArray()).First()

Die gesamte 1-Zeilen-Lösung mit System.Linq:

using System;
using System.Linq;

class OneLiner
{
    static void Main()
    {
        string s = "TextHereTisImortant973End"; //Between "eT" and "97"
        Console.WriteLine(s.Substring(s.IndexOf("eT") + "eT".Length)
                           .Split("97".ToCharArray()).First());
    }
}

Da ich immer sage, nichts ist unmöglich:

string value =  "super exemple of string key : text I want to keep - end of my string";
Regex regex = new Regex(@"(key \: (.*?) _ )");
Match match = regex.Match(value);
if (match.Success)
{
    Messagebox.Show(match.Value);
}

Hoffe, dass ich geholfen habe.

Hope That I Helped.