CODEWITHSUNDEEP
c#.netregex
Sinaesthetic
Sinaesthetic

Reputation: 12192

what is a good pattern to processes each individual regex match through a method

I'm trying to figure out a pattern where I run a regex match on a long string, and each time it finds a match, it runs a replace on it. The thing is, the replace will vary depending on the matched value. This new value will be determined by a method. For example:

var matches = Regex.Match(myString, myPattern);
while(matches.Success){
   Regex.Replace(myString, matches.Value, GetNewValue(matches.Groups[1]));
   matches = matches.NextMatch();
}

The problem (i think) is that if I run the Regex.Replace, all of the match indexes get messed up so the result ends up coming out wrong. Any suggestions?

Upvotes: 1

Views: 1023

Answers (3)

Sina Iravanian
Sina Iravanian

Reputation: 16286

If you replace each pattern with a fixed string, Regex.replace does that for you. You don't need to iterate the matches:

Regex.Replace(myString, myPattern, "replacement");

Otherwise, if the replacement depends upon the matched value, use the MatchEvaluator delegate, as the 3rd argument to Regex.Replace. It receives an instance of Match and returns string. The return value is the replacement string. If you don't want to replace some matches, simply return match.Value:

string myString = "aa bb aa bb";
string myPattern = @"\w+";
string result = Regex.Replace(myString, myPattern, 
                      match => match.Value == "aa" ? "0" : "1" );
Console.WriteLine(result);
// 0 1 0 1

If you really need to iterate the matches and replace them manually, you need to start replacement from the last match towards the first, so that the index of the string is not ruined for the upcoming matches. Here's an example:

var matches = Regex.Matches(myString, myPattern);
var matchesFromEndToStart = matches.Cast<Match>().OrderByDescending(m => m.Index);
var sb = new StringBuilder(myString);
foreach (var match in matchesFromEndToStart)
{
    if (IsGood(match))
    {
        sb.Remove(match.Index, match.Length)
          .Insert(match.Index, GetReplacementFor(match));
    }
}

Console.WriteLine(sb.ToString());

Just be careful, that your matches do not contain nested instances. If so, you either need to remove matches which are inside another match, or rerun the regex pattern to generate new matches after each replacement. I still recommend the second approach, which uses the delegates.

Upvotes: 4

Tullo_x86
Tullo_x86

Reputation: 2673

I would use something like

Regex regEx = new Regex("some.*?pattern");
string input = "someBLAHpattern!";
foreach (Match match in regEx.Matches(input))
{
    DoStuffWith(match.Value);
}

Upvotes: 0

RideTheWalrus
RideTheWalrus

Reputation: 84

If I understand your question correctly, you want to perform a replace based on a constant Regular Expression, but the replacement text you use will change based on the actual text that the regex matches on.

The Captures property of the Match Class (not the Match method) returns a collection of all the matches with your regex within the input string. It contains information like the position within the string, the matched value and the length of the match. If you iterate over this collection with a foreach loop you should be able to treat each match individually and perform some string manipulations where you can dynamically modify the replacement value.

Upvotes: 1

Related Questions