C # preg_replace?

Question

Che cos'è il preg_replace di PHP in C #?

Ho un array di stringhe che vorrei sostituire con un altro array di stringhe. Ecco un esempio in PHP. Come posso fare qualcosa del genere in C # senza usare .Replace (& Quot; old & Quot;, & Quot; new & Quot;).

$patterns[0] = '/=C0/';
$patterns[1] = '/=E9/';
$patterns[2] = '/=C9/';


$replacements[0] = 'à';
$replacements[1] = 'é';
$replacements[2] = 'é';
return preg_replace($patterns, $replacements, $text);

Answer 1

public static class StringManipulation
{
    public static string PregReplace(string input, string[] pattern, string[] replacements)
    {
        if (replacements.Length != pattern.Length)
            throw new ArgumentException("Replacement and Pattern Arrays must be balanced");

        for (int i = 0; i < pattern.Length; i++)
        {
            input = Regex.Replace(input, pattern[i], replacements[i]);                
        }

        return input;
    }
}

Ecco cosa userò. Qualche codice di Jonathan Holland ma non in C # 3.5 ma in C # 2.0 :)

Grazie a tutti.

Answer 2

I veri uomini usano espressioni regolari, ma ecco un metodo di estensione che lo aggiunge a String se lo volevi:

public static class ExtensionMethods
{
    public static String PregReplace(this String input, string[] pattern, string[] replacements)
    {
        if (replacements.Length != pattern.Length)
            throw new ArgumentException("Replacement and Pattern Arrays must be balanced");

        for (var i = 0; i < pattern.Length; i++)
        {
            input = Regex.Replace(input, pattern[i], replacements[i]);                
        }

        return input;
    }
}

Lo usi in questo modo:

 class Program
    {
        static void Main(string[] args)
        {
            String[] pattern = new String[4];
            String[] replacement = new String[4];

            pattern[0] = "Quick";
            pattern[1] = "Fox";
            pattern[2] = "Jumped";
            pattern[3] = "Lazy";

            replacement[0] = "Slow";            
            replacement[1] = "Turtle";
            replacement[2] = "Crawled";
            replacement[3] = "Dead";

            String DemoText = "The Quick Brown Fox Jumped Over the Lazy Dog";

            Console.WriteLine(DemoText.PregReplace(pattern, replacement));
        }        
    }

Answer 3

Puoi usare .Select () (in .NET 3.5 e C # 3) per facilitare l'applicazione delle funzioni ai membri di una collezione.

stringsList.Select( s => replacementsList.Select( r => s.Replace(s,r) ) );

Non hai bisogno del supporto regexp, vuoi solo un modo semplice per iterare sugli array.

Answer 4

Stai cercando System.Text.RegularExpressions;

using System.Text.RegularExpressions;

Regex r = new Regex("=C0");
string output = r.Replace(text);

Per ottenere il comportamento dell'array di PHP nel modo in cui hai bisogno, hai bisogno di più istanze di `Regex

Tuttavia, nel tuo esempio, saresti molto meglio servito da .Replace (vecchio, nuovo), è molto più veloce della compilazione di macchine a stati.

Answer 5

Modifica: Uhg ho appena realizzato che questa domanda era per 2.0, ma la lascerò nel caso in cui tu abbia accesso a 3.5.

Solo un'altra interpretazione della cosa Linq. Ora ho usato List & Lt; Char & Gt; invece di Char [], ma è solo per renderlo un po 'più pulito. Non esiste alcun metodo IndexOf sugli array ma ce n'è uno sull'elenco. Perché ne avevo bisogno? Bene, da quello che sto indovinando, non esiste una correlazione diretta tra l'elenco di sostituzione e l'elenco di quelli da sostituire. Solo l'indice.

Quindi, con questo in mente, puoi farlo con Char [] bene. Ma quando vedi il metodo IndexOf, devi aggiungere un .ToList () prima di esso.

In questo modo: someArray.ToList (). IndexOf

  String text;
  List<Char> patternsToReplace;
  List<Char> patternsToUse;

  patternsToReplace = new List<Char>();
  patternsToReplace.Add('a');
  patternsToReplace.Add('c');
  patternsToUse = new List<Char>();
  patternsToUse.Add('X');
  patternsToUse.Add('Z');

  text = "This is a thing to replace stuff with";

  var allAsAndCs = text.ToCharArray()
                 .Select
                 (
                   currentItem => patternsToReplace.Contains(currentItem) 
                     ? patternsToUse[patternsToReplace.IndexOf(currentItem)] 
                     : currentItem
                 )
                 .ToArray();

  text = new String(allAsAndCs);

Questo converte semplicemente il testo in una matrice di caratteri, selezionandoli attraverso ciascuno di essi. Se il personaggio attuale non è nella lista delle sostituzioni, rispedisci il personaggio così com'è. Se si trova nell'elenco di sostituzione, restituisce il carattere nello stesso indice dell'elenco di caratteri sostitutivi. L'ultima cosa è creare una stringa dall'array di caratteri.

  using System;
  using System.Collections.Generic;
  using System.Linq;