用正则表达式替换正则表达式

Question

Consider two regular expressions:

var regex_A = "Main\.(.+)\.Value";
var regex_B = "M_(.+)_Sp";

I want to be able to replace a string using regex_A as input, and regex_B as the replacement string. But also the other way around. And without supplying additional information like a format string per regex.

Specifically I want to create a replaced_B string from an input_A string. So:

var input_A = "Main.Rotating.Value";
var replaced_B = input_A.RegEx_Awesome_Replace(regex_A, regex_B);
Assert.AreEqual("M_Rotating_Sp", replaced_B);

And this should also work in reverse (thats the reason i can't use a simple string.format for regex_B). Because I don't want to supply a format string for every regular expression (i'm lazy).

var input_B = "M_Skew_Sp";
var replaced_A = input_B.RegEx_Awesome_Replace(regex_B, regex_A);
Assert.AreEqual("Main.Skew.Value", replaced_A);

I have no clue if this exists, or how to call it. Google search finds me all kinds of other regex replaces... not this one.

Update:

So basically I need a way to convert a regular expression to a format string.

var regex_A_format = Regex2Format(regex_A);
Assert.AreEqual("Main.$1.Value", regex_A_format);

and

var regex_B_format = Regex2Format(regex_B);
Assert.AreEqual("M_$1_Sp", regex_B_format);

So what should the RegEx_Awesome_Replace and/or Regex2Format function look like?

Update 2:

I guess the RegEx_Awesome_Replace should look something like (using some code from answers below):

public static class StringExtenstions
{
    public static string RegExAwesomeReplace(this string inputString,string searchPattern,string replacePattern)
    {
        return Regex.Replace(inputString, searchPattern, Regex2Format(replacePattern));
    }
}

Which would leave the Regex2Format as an open question.

Answer 1

There is no defined way for one regex to refer to a match found in another regex. Regexes are not format strings.

What you can do is to use Tuple s of a format string together with its regex. eg

var a = new Tuple<Regex,string>(new Regex(@"(?<=Main\.).+(?=\.Value)"), @"Main.{0}.Value")
var b = new Tuple<Regex,string>(new Regex(@"(?<=M_).+(?=_Sp)"), @"M_{0}_Sp")`

Then you can pass these objects to a common replacement method in any order, like this:

private string RegEx_Awesome_Replace(string input, Tuple<Regex,string> toFind, Tuple<Regex,string> replaceWith)
{
    return string.Format(replaceWith.Item2, toFind.Item1.Match(input).Value);
}

You will notice that I have used zero-width positive lookahead assertion and zero-width positive lookbehind assertions in my regexes, to ensure that Value contains exactly the text that I want to replace.

You may also want to add error handling, for cases where the match can not be found. Maybe read about Regex.Match

Answer 2

Since you have already reduced your problem to where you need to change a Regex into a string format (implementing Regex2Format ) I will focus my answer just on that part. Note that my answer is incomplete because it doesn't address the full breadth of parsing regex capturing groups, however it works for simple cases.

First thing needed is a Regex that will match Regex capture groups. There is a negative lookbehind to not match escaped bracket symbols. There are other cases that break this regex. Eg a non-capturing group, wildcard symbols, things between square braces.

private static readonly Regex CaptureGroupMatcher = new Regex(@"(?<!\\)\([^\)]+\)");

The implementation of Regex2Format here basically writes everything outside of capture groups into the output string, and replaces the capture group value by {x} .

static string Regex2Format(string pattern)
{
    var targetBuilder = new StringBuilder();
    int previousEndIndex = 0;
    int formatIndex = 0;
    foreach (Match match in CaptureGroupMatcher.Matches(pattern))
    {
        var group = match.Groups[0];
        int endIndex = group.Index;
        AppendPart(pattern, previousEndIndex, endIndex, targetBuilder);
        targetBuilder.Append('{');
        targetBuilder.Append(formatIndex++);
        targetBuilder.Append('}');
        previousEndIndex = group.Index + group.Length;
    }
    AppendPart(pattern, previousEndIndex, pattern.Length, targetBuilder);
    return targetBuilder.ToString();
}

This helper function writes pattern string values into the output, it currently writes everything except \\ characters used to escape something.

static void AppendPart(string pattern, int previousEndIndex, int endIndex, StringBuilder targetBuilder)
{
    for (int i = previousEndIndex; i < endIndex; i++)
    {
        char c = pattern[i];
        if (c == '\\' && i < pattern.Length - 1 && pattern[i + 1] != '\\')
        {
            //backslash not followed by another backslash - it's an escape char
        }
        else
        {
            targetBuilder.Append(c);
        }
    }
}

Test cases

static void Test()
{
    var cases = new Dictionary<string, string>
    {
        { @"Main\.(.+)\.Value", @"Main.{0}.Value" },
        { @"M_(.+)_Sp(.*)", "M_{0}_Sp{1}" },
        { @"M_\(.+)_Sp", @"M_(.+)_Sp" },
    };

    foreach (var kvp in cases)
    {
        if (PatternToStringFormat(kvp.Key) != kvp.Value)
        {
            Console.WriteLine("Test failed for {0} - expected {1} but got {2}", kvp.Key, kvp.Value, PatternToStringFormat(kvp.Key));
        }
    }

}

To wrap up, here is the usage:

private static string AwesomeRegexReplace(string input, string sourcePattern, string targetPattern)
{
    var targetFormat = PatternToStringFormat(targetPattern);
    return Regex.Replace(input, sourcePattern, match =>
    {
        var args = match.Groups.OfType<Group>().Skip(1).Select(g => g.Value).ToArray<object>();
        return string.Format(targetFormat, args);
    });
}

Answer 3

这样的事情可能会起作用

 var replaced_B = Regex.Replace(input_A, @"Main\.(.+)\.Value", @"M_$1_Sp");

Answer 4

Are you looking for something like this?

public static class StringExtenstions
{
    public static string RegExAwesomeReplace(this string inputString,string searchPattern,string replacePattern)
    {
        Match searchMatch = Regex.Match(inputString,searchPattern);
        Match replaceMatch = Regex.Match(inputString, replacePattern);

        if (!searchMatch.Success || !replaceMatch.Success)
        {
            return inputString;
        }

        return inputString.Replace(searchMatch.Value, replaceMatch.Value);
    }
}

The string extension method returns the string with replaced value for search pattern and replace pattern.

This is how you call:

input_A.RegEx_Awesome_Replace(regex_A, regex_B);