Come si sostituisce la * prima istanza * di una stringa in .NET?

Voglio sostituire la prima occorrenza in una data stringa.

Come posso farlo in .NET?

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);
}

Esempio:

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

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

EDIT : Come menzionato da @itsmatt , c'è anche Regex.Replace (String, String, Int32), che può fare lo stesso, ma è probabilmente più costoso in fase di esecuzione, poiché utilizza un parser completo in cui il mio metodo trova una e tre stringhe concatenazioni.

EDIT2 : se questa è un'attività comune, potresti voler rendere il metodo un metodo di estensione:

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

Utilizzando l'esempio sopra è ora possibile scrivere:

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

Come ha detto itsmatt, Regex.Replace è una buona scelta per questo, tuttavia per rendere la sua risposta più completa, lo riempirò con un esempio di codice:

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

Il terzo parametro, impostato su 1 in questo caso, è il numero di occorrenze del pattern regex che si desidera sostituire nella stringa di input dall'inizio della stringa.

Speravo che questo potesse essere fatto con un sovraccarico di Regex.Replace statico, ma sfortunatamente sembra che sia necessaria un'istanza Regex per realizzarlo.

Dai un'occhiata a Regex.Replace .

Tenendo conto del "primo solo", forse:

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

?

O più in generale:

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);
}

Poi:

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

using System.Text.RegularExpressions;

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

troverà il primo Fin InputStringe lo sostituirà con R.

Metodo di estensione C # che farà questo:

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);    
    } 
}

Godere

Nella sintassi C #:

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

E poiché c'è anche VB.NET da considerare, vorrei offrire:

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

Presuppone che AAdebba essere sostituito solo se si trova all'inizio della stringa:

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

Se è necessario sostituire la prima occorrenza di AA, indipendentemente dal fatto che la stringa inizi o meno con essa, andare con la soluzione di Marc.

Uno dei sovraccarichi di Regex.Replaceprende un intper "Il numero massimo di volte che la sostituzione può avvenire". Ovviamente, l'uso Regex.Replaceper la sostituzione del testo normale può sembrare eccessivo, ma è certamente conciso:

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

Per chiunque non dispiaccia un riferimento a Microsoft.VisualBasic, c'è il ReplaceMetodo :

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

Questo esempio astrae le sottostringhe (ma è più lento), ma probabilmente è molto più veloce di una 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;
            }