Espressione regolare sostituisci in C#

Question

Sono abbastanza nuovo nell'usare le espressioni regolari e, in base ad alcuni tutorial che ho letto, non riesco a ottenere questo passaggio nel mio Regex.Replace formattato correttamente.

Ecco lo scenario su cui sto lavorando ... Quando estraggo i miei dati dalla casella di riepilogo, desidero formattarlo in un formato simile a CSV e quindi salvare il file. L'utilizzo dell'opzione Sostituisci è la soluzione ideale per questo scenario?

Prima dell'esempio di formattazione di espressioni regolari.

FirstName LastName Salary Position 
------------------------------------- 
John  Smith $100,000.00 M 

formato proposto dopo un'espressione regolare sostituire

John Smith,100000,M 

corrente uscita di stato formattazione:

John,Smith,100000,M 

* Nota - c'è un modo posso sostituire la prima virgola con uno spazio bianco?

frammento del mio codice

using(var fs = new FileStream(filepath, FileMode.OpenOrCreate, FileAccess.Write)) 
{ 
    using(var sw = new StreamWriter(fs)) 
    { 
     foreach (string stw in listBox1.Items) 
     { 
      StringBuilder sb = new StringBuilder(); 
      sb.AppendLine(stw); 

      //Piecing the list back to the original format 
      sb_trim = Regex.Replace(stw, @"[$,]", ""); 
      sb_trim = Regex.Replace(sb_trim, @"[.][0-9]+", ""); 
      sb_trim = Regex.Replace(sb_trim, @"\s", ","); 
      sw.WriteLine(sb_trim); 
     } 
    } 
} 

Answer 1

Si può fare di

//let stw be "John Smith $100,000.00 M" 

sb_trim = Regex.Replace(stw, @"\s+\$|\s+(?=\w+$)", ","); 
//sb_trim becomes "John Smith,100,000.00,M" 

sb_trim = Regex.Replace(sb_trim, @"(?<=\d),(?=\d)|[.]0+(?=,)", ""); 
//sb_trim becomes "John Smith,100000,M" 

sw.WriteLine(sb_trim); 

Answer 2

aggiungere le seguenti 2 linee

var regex = new Regex(Regex.Escape(",")); 
sb_trim = regex.Replace(sb_trim, " ", 1); 

Se sb_trim = John, Smith è questo con due sostituire, 100000, M il codice sopra restituirà "John Smith, 100000, M"

Answer 3

Prova questo ::

sb_trim = Regex.Replace(stw, @"(\D+)\s+\$([\d,]+)\.\d+\s+(.)", 
    m => string.Format(
     "{0},{1},{2}", 
     m.Groups[1].Value, 
     m.Groups[2].Value.Replace(",", string.Empty), 
     m.Groups[3].Value)); 

Questo è quanto di pulito una risposta, come si arriva, almeno con regex.

• (\D+): Primo gruppo di acquisizione. Uno o più caratteri non numerici.
• \s+\$: uno o più caratteri di spaziatura, quindi un segno di dollaro letterale ($).
• ([\d,]+): secondo gruppo di acquisizione. Uno o più cifre e/o virgole.
• \.\d+: punto decimale, quindi almeno una cifra.
• \s+: uno o più caratteri di spaziatura.
• (.): terzo gruppo di acquisizione. Qualsiasi carattere non lineare.

Il secondo gruppo di acquisizione deve inoltre avere le virgole spogliate. Potresti farlo con un'altra regex, ma è davvero inutile e dannosa per le prestazioni. Questo è il motivo per cui abbiamo bisogno di usare un'espressione lambda e un formato stringa per mettere insieme la sostituzione. Se non fosse per questo, si potrebbe utilizzare questo come la sostituzione, in luogo dell'espressione lambda:

"$1,$2,$3"