reserver [ ] til keys

@"\[([^\]]*)\]" kan vek fange det mellem [].

great - du dropper bare et svar. Har du noget forslag til en switch replace af keys?

Jeg er ikke helt sikker paa at jeg forstaar hvad du vil med den switch.

Er forventningen at den er hurtigere end N simple .Replace ?

Det er simpelthen blot en konsekvens af dårlig gennemtænkning jeg kommer nok bare til at lave en anden metode og regex som fanger en bestemt key altså:
        private static string RegexReplace(string msg, string key, string replacekey)
        {
            return Regex.Replace(msg, ("\[" + key + "\]"), replacekey);
        }

og så kalde den metode en gang for hver key og hvad den skal erstattes med

Du behoever ikke engang Regex Replace - String Replace er god nok !

Lidt kode:

using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;

namespace E
{
    public class Program
    {
        public static void Main(string[] args)
        {
            string s = "xxx [key1] yyy [key2] zzz";
            string s2 = s.Replace("[key1]", "foo").Replace("[key2]", "bar");
            Console.WriteLine(s2);
            string s3 = s;
            Regex re3 = new Regex(@"\[([^\]]*)\]");
            foreach(Match m in re3.Matches(s))
            {
                switch(m.Groups[1].Value)
                {
                    case "key1":
                        s3 = s3.Replace("[key1]", "foo");
                        break;
                    case "key2":
                        s3 = s3.Replace("[key2]", "bar");
                        break;
                }
            }
            Console.WriteLine(s3);
            Dictionary<string, string> d = new Dictionary<string, string>();
            d.Add("key1", "foo");
            d.Add("key2", "bar");
            string s4 = s;
            Regex re4 = new Regex(@"\[([^\]]*)\]");
            foreach(Match m in re4.Matches(s))
            {
                s4 = s4.Replace("[" + m.Groups[1].Value + "]", d[m.Groups[1].Value]);
            }
            Console.WriteLine(s4);
            Console.ReadKey();
        }
    }
}

og et svar

Og med en rigtig 1980'er loesning tilfoejet:

using System;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;

namespace E
{
    public class Program
    {
        public static void Main(string[] args)
        {
            string s = "xxx [key1] yyy [key2] zzz";
            string s2 = s.Replace("[key1]", "foo").Replace("[key2]", "bar");
            Console.WriteLine(s2);
            string s3 = s;
            Regex re3 = new Regex(@"\[([^\]]*)\]");
            foreach(Match m in re3.Matches(s))
            {
                switch(m.Groups[1].Value)
                {
                    case "key1":
                        s3 = s3.Replace("[key1]", "foo");
                        break;
                    case "key2":
                        s3 = s3.Replace("[key2]", "bar");
                        break;
                }
            }
            Console.WriteLine(s3);
            Dictionary<string, string> d = new Dictionary<string, string>();
            d.Add("key1", "foo");
            d.Add("key2", "bar");
            string s4 = s;
            Regex re4 = new Regex(@"\[([^\]]*)\]");
            foreach(Match m in re4.Matches(s))
            {
                s4 = s4.Replace("[" + m.Groups[1].Value + "]", d[m.Groups[1].Value]);
            }
            Console.WriteLine(s4);
            StringBuilder sb = new StringBuilder();
            int ix = 0;
            while(ix < s.Length)
            {
                int newix = s.IndexOf("[key", ix);
                if(newix > 0)
                {
                    sb.Append(s.Substring(ix, newix - ix));
                    string key = s.Substring(newix + 1, s.IndexOf("]", newix + 4) - newix - 1);
                    sb.Append(d[key]);
                    ix = newix + key.Length + 2;
                }
                else
                {
                    sb.Append(s.Substring(ix));
                    ix = s.Length;
                }
            }
            string s5 = sb.ToString();
            Console.WriteLine(s5);
            Console.ReadKey();
        }
    }
}

og så er issuet i at lave string replace at det er afhængigt af brugerinput så det er ikke vist om de skriver [key1]eller [Key1] eller [kEY1] osv. ;)

Hvis du skal understoette alle mulige mixed cases saa er Regex Replace langt nemmere end String Replace.

yes - det var derfor jeg efterspurgte det ;)

Men igen ville jeg vaelge den simple variant:

using System;
using System.Text.RegularExpressions;

namespace E
{
    public class Program
    {
        public static void Main(string[] args)
        {
            string s = "xxx [kEy1] yyy [KeY2] zzz";
            string sx = s;
            sx = Regex.Replace(sx, @"\[key1\]", "foo", RegexOptions.IgnoreCase);
            sx = Regex.Replace(sx, @"\[key2\]", "bar", RegexOptions.IgnoreCase);
            Console.WriteLine(sx);
            Console.ReadKey();
        }
    }
}

as would I.

perfekt. tusind tak endnu engang