Wie ersetze ich die * erste Instanz * einer Zeichenfolge in .NET?

Ich möchte das erste Vorkommen in einer bestimmten Zeichenfolge ersetzen.

Wie kann ich dies in .NET erreichen?

string ReplaceFirst(string text, string search, string replace)
{
  int pos = text.IndexOf(search);
  if (pos < 0)
  {
    return text;
  }
  return text.Substring(0, pos) + replace + text.Substring(pos + search.Length);
}

Beispiel:

string str = "The brown brown fox jumps over the lazy dog";

str = ReplaceFirst(str, "brown", "quick");

BEARBEITEN : Wie @itsmatt erwähnt , gibt es auch Regex.Replace (String, String, Int32), die das gleiche tun, aber es ist wahrscheinlich teurer zur Laufzeit, da es eine voll funktionsfähige Parser verwendet , wo meine Methode macht eine Entdeckung und drei Zeichenfolge Verkettungen.

EDIT2 : Wenn dies eine häufige Aufgabe ist, möchten Sie die Methode möglicherweise zu einer Erweiterungsmethode machen:

public static class StringExtension
{
  public static string ReplaceFirst(this string text, string search, string replace)
  {
     // ...same as above...
  }
}

Mit dem obigen Beispiel ist es jetzt möglich zu schreiben:

str = str.ReplaceFirst("brown", "quick");

Wie itsmatt sagte, ist Regex.Replace eine gute Wahl, aber um seine Antwort vollständiger zu machen, werde ich sie mit einem Codebeispiel ausfüllen:

using System.Text.RegularExpressions;
...
Regex regex = new Regex("foo");
string result = regex.Replace("foo1 foo2 foo3 foo4", "bar", 1);             
// result = "bar1 foo2 foo3 foo4"

Der dritte Parameter, in diesem Fall auf 1 gesetzt, ist die Anzahl der Vorkommen des Regex-Musters, das Sie ab dem Beginn der Zeichenfolge in der Eingabezeichenfolge ersetzen möchten.

Ich hatte gehofft, dass dies mit einer statischen Regex- Überladung möglich ist, aber leider scheint es, dass Sie eine Regex-Instanz benötigen, um dies zu erreichen.

Schauen Sie sich Regex.Replace an .

Unter Berücksichtigung des "nur ersten" vielleicht:

int index = input.IndexOf("AA");
if (index >= 0) output = input.Substring(0, index) + "XQ" +
     input.Substring(index + 2);

?

Oder allgemeiner:

public static string ReplaceFirstInstance(this string source,
    string find, string replace)
{
    int index = source.IndexOf(find);
    return index < 0 ? source : source.Substring(0, index) + replace +
         source.Substring(index + find.Length);
}

Dann:

string output = input.ReplaceFirstInstance("AA", "XQ");

using System.Text.RegularExpressions;

RegEx MyRegEx = new RegEx("F");
string result = MyRegex.Replace(InputString, "R", 1);

wird zuerst Fin finden InputStringund durch ersetzen R.

C # -Erweiterungsmethode, die dies tut:

public static class StringExt
{
    public static string ReplaceFirstOccurrence(this string s, string oldValue, string newValue)
    {
         int i = s.IndexOf(oldValue);
         return s.Remove(i, oldValue.Length).Insert(i, newValue);    
    } 
}

Genießen

In der C # -Syntax:

int loc = original.IndexOf(oldValue);
if( loc < 0 ) {
    return original;
}
return original.Remove(loc, oldValue.Length).Insert(loc, newValue);

Und weil es auch VB.NET zu berücksichtigen gibt, möchte ich Folgendes anbieten:

Private Function ReplaceFirst(ByVal text As String, ByVal search As String, ByVal replace As String) As String
    Dim pos As Integer = text.IndexOf(search)
    If pos >= 0 Then
        Return text.Substring(0, pos) + replace + text.Substring(pos + search.Length)
    End If
    Return text 
End Function

Angenommen, dies AAmuss nur ersetzt werden, wenn es sich ganz am Anfang der Zeichenfolge befindet:

var newString;
if(myString.StartsWith("AA"))
{
  newString ="XQ" + myString.Substring(2);
}

Wenn Sie das erste Vorkommen von ersetzen müssen AA, unabhängig davon , ob die Zeichenfolge damit beginnt oder nicht, wählen Sie die Lösung von Marc.

Eine der Überladungen von Regex.Replacedauert ein intfür "Die maximale Häufigkeit, mit der der Austausch erfolgen kann". Natürlich Regex.Replacemag die Verwendung für das Ersetzen von Klartext wie ein Overkill erscheinen, aber es ist sicherlich prägnant:

string output = (new Regex("AA")).Replace(input, "XQ", 1);

Für alle, denen ein Verweis nichts ausmacht Microsoft.VisualBasic, gibt es die ReplaceMethode :

string result = Microsoft.VisualBasic.Strings.Replace("111", "1", "0", 2, 1); // "101"

Dieses Beispiel abstrahiert die Teilzeichenfolgen (ist aber langsamer), aber wahrscheinlich viel schneller als ein RegEx:

var parts = contents.ToString().Split(new string[] { "needle" }, 2, StringSplitOptions.None);
return parts[0] + "replacement" + parts[1];

string abc = "AAAAX1";

            if(abc.IndexOf("AA") == 0)
            {
                abc.Remove(0, 2);
                abc = "XQ" + abc;
            }