C＃替换字符串（如果不在{大括号中）

Question

Due to an unfortunate past choice I have a following format string that looks like this:

# {0}mm {1}mm x {2}mm

It's processed in two stages, first one was to replace # character with a string with simple

formatString = formatString.Replace("#", "foo")

Somehow the original string changed to include octothorpes inside the format string as:

# {0}mm {1:0.##}mm x {2:0.##}mm

Because I still have to replace the first one # with foo , but the string.Replace("#","foo") will replace all occurences of # , resulting in foo {0}mm {1:0foofoo}mm x {2:0.foofoo}mm"

That's why I'd like to replace # symbol only if it's not inside curly braces. I think it can be achieved by a regex, but the correct expression doesn't come to my mind.

Answer 1

This should work:

(?<!{[^{}]*)(?![^{}]*})#

Which will only match if:

1. It is not preceded by an opening brace not followed by other braces,
2. It is not followed by a closing brace not preceded by other braces,
3. It is a hash.

The first two ensure you are not inside a brace pair, but not matching from one pair of braces to the other.

However if the hash you wish to match only occurs at the start then AlexInTime's solution is a much better approach.

Answer 2

I know you already have an accepted answer, but this question also happens to have a solution that is quite general and beautiful, so for completion, here it is. This situation is very similar to this question to "regex-match a pattern, excluding..."

We can solve it with a beautifully-simple regex:

{[^}]*}|(#+)

The left side of the alternation | matches complete {curlies} . We will ignore these matches. The right side matches and captures hashes # to Group 1, and we know they are the right ones because they were not matched by the expression on the left.

This program shows how to use the regex (see the results at the bottom of the online demo ):

using System;
using System.Text.RegularExpressions;
using System.Collections.Specialized;
class Program
{
static void Main() {
var myRegex = new Regex(@"{[^}]*}|(#+)");
string s1 = @"# {0}mm ####{1:0.##}mm ##x {2:0.##}mm";

string replaced = myRegex.Replace(s1, delegate(Match m) {
if (m.Groups[1].Value != "") return "";
else return m.Value;
});
Console.WriteLine("\n" + "*** Replacements ***");
Console.WriteLine(replaced);


Console.WriteLine("\nPress Any Key to Exit.");
Console.ReadKey();

} // END Main
} // END Program

Reference

• How to match (or replace) a pattern except in situations s1, s2, s3...
• Article about matching a pattern unless...

Answer 3

your regex can be as simple as ^(#) ^ start of string, (#) one occurence of #

if you don't really know regex to much I can definitely recommed http://txt2re.com/ which is a VERY visual regex builder

Answer 4

Use the Regex.Replace in stead of String.Replace

See http://msdn.microsoft.com/en-us/library/haekbhys(v=vs.110).aspx

Sample

using System.Text.RegularExpressions;
namespace TestReplaceFirst
{
    class Program
    {
        static void Main(string[] args)
        {
        var source = new List<string> { "# {0}mm {1}mm x {2}mm", "# {0}mm {1:0.##}mm x {2:0.##}mm", "{0}mm {1}mm x {2}mm # #", "{0}mm # {1:0.##}mm x {2:0.##}mm" };

        string pattern = "(?<!{[^{}]*)(?![^{}]*})#";
        string replacement = "foo";
        Regex rgx = new Regex(pattern);

        foreach (var str in source)
        {
            string result = rgx.Replace(str, replacement);
            Console.WriteLine("Original String:    '{0}'", str);
            Console.WriteLine("Replacement String: '{0}'", result);
        }
        Console.ReadKey();       
    }
}

Output:

Original String:    '# {0}mm {1}mm x {2}mm'
Replacement String: 'foo {0}mm {1}mm x {2}mm'
Original String:    '# {0}mm {1:0.##}mm x {2:0.##}mm'
Replacement String: 'foo {0}mm {1:0.##}mm x {2:0.##}mm'
Original String:    '{0}mm {1}mm x {2}mm # #'
Replacement String: '{0}mm {1}mm x {2}mm foo #'
Original String:    '{0}mm # {1:0.##}mm x {2:0.##}mm'
Replacement String: '{0}mm foo {1:0.##}mm x {2:0.##}mm'