blocks|key|1037005|text|您可以使用Regex并执行不区分大小写的替换：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1037006|class+Program
{
++++static+void+Main()
++++{
++++++++string+input+=+"hello+WoRlD";
++++++++string+result+=+
+++++++++++Regex.Replace(input,+"world",+"csharp",+RegexOptions.IgnoreCase);
++++++++Console.WriteLine(result);+//+prints+"hello+csharp"
++++}
}|code-block|syntax|javascript|1037007|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/system.text.regularexpressions.regex.aspx^0|5|5|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

You could use a <a href="http://msdn.microsoft.com/en-us/library/system.text.regularexpressions.regex.aspx" rel="noreferrer">Regex</a> and perform a case insensitive replace:

<pre><code>class Program
{
 static void Main()
 {
 string input = "hello WoRlD";
 string result = 
 Regex.Replace(input, "world", "csharp", RegexOptions.IgnoreCase);
 Console.WriteLine(result); // prints "hello csharp"
 }
}
</code></pre>

blocks|key|1037044|text|(编辑：没有意识到‘裸链接’的问题，很抱歉)|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|1037045|摘自here|1037046|string+myString+=+"find+Me+and+replace+ME";
string+strReplace+=+"me";
myString+=+Regex.Replace(myString,+"me",+strReplace,+RegexOptions.IgnoreCase);|code-block|syntax|javascript|1037047|似乎您不是第一个抱怨缺少不区分大小写的string.Replace的人。|1037048|entityMap|0|LINK|mutability|MUTABLE|url|http://weblogs.asp.net/jgalloway/archive/2004/02/11/71188.aspx^0|1|3|0|2|4|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Z|8|@]|D|@$9|10|A|11|1|12]]|E|$]]|$1|H|3|I|5|J|7|13|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|14|8|@]|D|@]|E|$]]|$1|O|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|P|$Q|$5|R|S|T|E|$U|V]]]]

(Edited: wasn't aware of the `naked link' problem, sorry about that)

Taken from <a href="http://weblogs.asp.net/jgalloway/archive/2004/02/11/71188.aspx" rel="noreferrer">here</a>:

<pre><code>string myString = "find Me and replace ME";
string strReplace = "me";
myString = Regex.Replace(myString, "me", strReplace, RegexOptions.IgnoreCase);
</code></pre>

Seems you are not the first to complain of the lack of case insensitive string.Replace.

blocks|key|2938922|text|var+search+=+"world";
var+replacement+=+"csharp";
string+result+=+Regex.Replace(
++++stringToLookInto,
++++Regex.Escape(search),+
++++replacement.Replace("$","$$"),+
++++RegexOptions.IgnoreCase
);|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|2938923|如果您依赖于可以包含Regex+language+elements的用户输入，则Regex.Escape非常有用|unstyled|offset|length|2938924|更新|style|BOLD|2938925|多亏了注释，你实际上不必转义替换字符串。|2938926|Here+is+a+small+fiddle+that+tests+the+code：|2938927|using+System;
using+System.Text.RegularExpressions;+++++++++++
public+class+Program
{
++++public+static+void+Main()
++++{

++++++++var+tests+=+new[]+{
++++++++++++new+{+Input="abcdef",+Search="abc",+Replacement="xyz",+Expected="xyzdef"+},
++++++++++++new+{+Input="ABCdef",+Search="abc",+Replacement="xyz",+Expected="xyzdef"+},
++++++++++++new+{+Input="A*BCdef",+Search="a*bc",+Replacement="xyz",+Expected="xyzdef"+},
++++++++++++new+{+Input="abcdef",+Search="abc",+Replacement="x*yz",+Expected="x*yzdef"+},+++++++
++++++++++++new+{+Input="abcdef",+Search="abc",+Replacement="$",+Expected="$def"+},
++++++++};


++++++++foreach(var+test+in+tests){
++++++++++++var+result+=+ReplaceCaseInsensitive(test.Input,+test.Search,+test.Replacement);

++++++++++++Console.WriteLine(
++++++++++++++++"Success:+{0},+Actual:+{1},+{2}",
++++++++++++++++result+==+test.Expected,
++++++++++++++++result,
++++++++++++++++test
++++++++++++);

++++++++}


++++}

++++private+static+string+ReplaceCaseInsensitive(string+input,+string+search,+string+replacement){
++++++++string+result+=+Regex.Replace(
++++++++++++input,
++++++++++++Regex.Escape(search),+
++++++++++++replacement.Replace("$","$$"),+
++++++++++++RegexOptions.IgnoreCase
++++++++);
++++++++return+result;
++++}
}|2938928|它的输出是：|2938929|Success:+True,+Actual:+xyzdef,+{+Input+=+abcdef,+Search+=+abc,+Replacement+=+xyz,+Expected+=+xyzdef+}+
Success:+True,+Actual:+xyzdef,+{+Input+=+ABCdef,+Search+=+abc,+Replacement+=+xyz,+Expected+=+xyzdef+}
Success:+True,+Actual:+xyzdef,+{+Input+=+A*BCdef,+Search+=+a*bc,+Replacement+=+xyz,+Expected+=+xyzdef+}+
Success:+True,+Actual:+x*yzdef,+{+Input+=+abcdef,+Search+=+abc,+Replacement+=+x*yz,+Expected+=+x*yzdef}+
Success:+True,+Actual:+$def,+{+Input+=+abcdef,+Search+=+abc,+Replacement+=+$,+Expected+=+$def+}|2938930|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/library/az24scfc.aspx|1|http://msdn.microsoft.com/library/system.text.regularexpressions.regex.escape.aspx|2|https://dotnetfiddle.net/zuDrT2^0|0|A|N|0|14|C|1|0|0|2|0|0|0|16|2|0|0|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|19|8|@]|9|@$G|1A|H|1B|1|1C]|$G|1D|H|1E|1|1F]]|A|$]]|$1|I|3|J|5|F|7|1G|8|@$G|1H|H|1I|K|L]]|9|@]|A|$]]|$1|M|3|N|5|F|7|1J|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|1K|8|@]|9|@$G|1L|H|1M|1|1N]]|A|$]]|$1|Q|3|R|5|6|7|1O|8|@]|9|@]|A|$B|C]]|$1|S|3|T|5|F|7|1P|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1Q|8|@]|9|@]|A|$B|C]]|$1|W|3|-4|5|F|7|1R|8|@]|9|@]|A|$]]]|X|$Y|$5|Z|10|11|A|$12|13]]|14|$5|Z|10|11|A|$12|15]]|16|$5|Z|10|11|A|$12|17]]]]

<pre><code>var search = "world";
var replacement = "csharp";
string result = Regex.Replace(
 stringToLookInto,
 Regex.Escape(search), 
 replacement.Replace("$","$$"), 
 RegexOptions.IgnoreCase
);
</code></pre>

The <a href="http://msdn.microsoft.com/library/system.text.regularexpressions.regex.escape.aspx">Regex.Escape</a> is useful if you rely on user input which can contains <a href="http://msdn.microsoft.com/library/az24scfc.aspx">Regex language elements</a>

Update

Thanks to comments, you actually don't have to escape the replacement string.

<a href="https://dotnetfiddle.net/zuDrT2">Here is a small fiddle that tests the code</a>: 

<pre><code>using System;
using System.Text.RegularExpressions; 
public class Program
{
 public static void Main()
 {

 var tests = new[] {
 new { Input="abcdef", Search="abc", Replacement="xyz", Expected="xyzdef" },
 new { Input="ABCdef", Search="abc", Replacement="xyz", Expected="xyzdef" },
 new { Input="A*BCdef", Search="a*bc", Replacement="xyz", Expected="xyzdef" },
 new { Input="abcdef", Search="abc", Replacement="x*yz", Expected="x*yzdef" }, 
 new { Input="abcdef", Search="abc", Replacement="$", Expected="$def" },
 };


 foreach(var test in tests){
 var result = ReplaceCaseInsensitive(test.Input, test.Search, test.Replacement);

 Console.WriteLine(
 "Success: {0}, Actual: {1}, {2}",
 result == test.Expected,
 result,
 test
 );

 }


 }

 private static string ReplaceCaseInsensitive(string input, string search, string replacement){
 string result = Regex.Replace(
 input,
 Regex.Escape(search), 
 replacement.Replace("$","$$"), 
 RegexOptions.IgnoreCase
 );
 return result;
 }
}
</code></pre>

Its output is:

<pre><code>Success: True, Actual: xyzdef, { Input = abcdef, Search = abc, Replacement = xyz, Expected = xyzdef } 
Success: True, Actual: xyzdef, { Input = ABCdef, Search = abc, Replacement = xyz, Expected = xyzdef }
Success: True, Actual: xyzdef, { Input = A*BCdef, Search = a*bc, Replacement = xyz, Expected = xyzdef } 
Success: True, Actual: x*yzdef, { Input = abcdef, Search = abc, Replacement = x*yz, Expected = x*yzdef} 
Success: True, Actual: $def, { Input = abcdef, Search = abc, Replacement = $, Expected = $def }
</code></pre>

blocks|key|4727349|text|扩展让我们的生活更轻松：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4727350|static+public+class+StringExtensions
{
++++static+public+string+ReplaceInsensitive(this+string+str,+string+from,+string+to)
++++{
++++++++str+=+Regex.Replace(str,+from,+to,+RegexOptions.IgnoreCase);
++++++++return+str;
++++}
}|code-block|syntax|javascript|4727351|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Extensions make our lives easier:

<pre><code>static public class StringExtensions
{
 static public string ReplaceInsensitive(this string str, string from, string to)
 {
 str = Regex.Replace(str, from, to, RegexOptions.IgnoreCase);
 return str;
 }
}
</code></pre>

blocks|key|1037099|text|很多使用正则表达式的建议。这个不带它的扩展方法怎么样：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1037100|public+static+string+Replace(this+string+str,+string+old,+string+@new,+StringComparison+comparison)
{
++++@new+=+@new+??+"";
++++if+(string.IsNullOrEmpty(str)+%7C%7C+string.IsNullOrEmpty(old)+%7C%7C+old.Equals(@new,+comparison))
++++++++return+str;
++++int+foundAt+=+0;
++++while+((foundAt+=+str.IndexOf(old,+foundAt,+comparison))+!=+-1)
++++{
++++++++str+=+str.Remove(foundAt,+old.Length).Insert(foundAt,+@new);
++++++++foundAt+%2B=+@new.Length;
++++}
++++return+str;
}|code-block|syntax|javascript|1037101|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Lots of suggestions using Regex. How about this extension method without it:

<pre><code>public static string Replace(this string str, string old, string @new, StringComparison comparison)
{
 @new = @new ?? "";
 if (string.IsNullOrEmpty(str) || string.IsNullOrEmpty(old) || old.Equals(@new, comparison))
 return str;
 int foundAt = 0;
 while ((foundAt = str.IndexOf(old, foundAt, comparison)) != -1)
 {
 str = str.Remove(foundAt, old.Length).Insert(foundAt, @new);
 foundAt += @new.Length;
 }
 return str;
}
</code></pre>

blocks|key|2939074|text|修改了@Darky711的答案，使用传入的比较类型并匹配框架，尽可能地替换命名和xml注释。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2939075|///+<summary>
///+Returns+a+new+string+in+which+all+occurrences+of+a+specified+string+in+the+current+instance+are+replaced+with+another+specified+string.
///+</summary>
///+<param+name="str">The+string+performing+the+replace+method.</param>
///+<param+name="oldValue">The+string+to+be+replaced.</param>
///+<param+name="newValue">The+string+replace+all+occurrances+of+oldValue.</param>
///+<param+name="comparisonType">Type+of+the+comparison.</param>
///+<returns></returns>
public+static+string+Replace(this+string+str,+string+oldValue,+string+@newValue,+StringComparison+comparisonType)
{
++++@newValue+=+@newValue+??+string.Empty;
++++if+(string.IsNullOrEmpty(str)+%7C%7C+string.IsNullOrEmpty(oldValue)+%7C%7C+oldValue.Equals(@newValue,+comparisonType))
++++{
++++++++return+str;
++++}
++++int+foundAt;
++++while+((foundAt+=+str.IndexOf(oldValue,+0,+comparisonType))+!=+-1)
++++{
++++++++str+=+str.Remove(foundAt,+oldValue.Length).Insert(foundAt,+@newValue);
++++}
++++return+str;
}|code-block|syntax|javascript|2939076|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Modified @Darky711's answer to use the passed in comparison type and match the framework replace naming and xml comments as closely as possible.

<pre><code>/// &lt;summary&gt;
/// Returns a new string in which all occurrences of a specified string in the current instance are replaced with another specified string.
/// &lt;/summary&gt;
/// &lt;param name="str"&gt;The string performing the replace method.&lt;/param&gt;
/// &lt;param name="oldValue"&gt;The string to be replaced.&lt;/param&gt;
/// &lt;param name="newValue"&gt;The string replace all occurrances of oldValue.&lt;/param&gt;
/// &lt;param name="comparisonType"&gt;Type of the comparison.&lt;/param&gt;
/// &lt;returns&gt;&lt;/returns&gt;
public static string Replace(this string str, string oldValue, string @newValue, StringComparison comparisonType)
{
 @newValue = @newValue ?? string.Empty;
 if (string.IsNullOrEmpty(str) || string.IsNullOrEmpty(oldValue) || oldValue.Equals(@newValue, comparisonType))
 {
 return str;
 }
 int foundAt;
 while ((foundAt = str.IndexOf(oldValue, 0, comparisonType)) != -1)
 {
 str = str.Remove(foundAt, oldValue.Length).Insert(foundAt, @newValue);
 }
 return str;
}
</code></pre>

blocks|key|1037283|text|在搜索字符串中使用Regex.Escape扩展Petrucio的答案，并按照Steve+B的答案中的建议转义匹配组(以及对我的口味的一些小更改)：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1037284|public+static+class+StringExtensions
{
++++public+static+string+ReplaceIgnoreCase(this+string+str,+string+from,+string+to)
++++{
++++++++return+Regex.Replace(str,+Regex.Escape(from),+to.Replace("$",+"$$"),+RegexOptions.IgnoreCase);
++++}
}|code-block|syntax|javascript|1037285|这将产生以下预期结果：|1037286|Console.WriteLine("(heLLo)+wOrld".ReplaceIgnoreCase("(hello)+world",+"Hi+$1+Universe"));+//+Hi+$1+Universe
Console.WriteLine("heLLo+wOrld".ReplaceIgnoreCase("(hello)+world",+"Hi+$1+Universe"));+++//+heLLo+wOrld|1037287|但是，如果不执行转义，您将得到以下结果，这不是仅区分大小写的String.Replace的预期行为：|1037288|Console.WriteLine("(heLLo)+wOrld".ReplaceIgnoreCase_NoEscaping("(hello)+world",+"Hi+$1+Universe"));+//+(heLLo)+wOrld
Console.WriteLine("heLLo+wOrld".ReplaceIgnoreCase_NoEscaping("(hello)+world",+"Hi+$1+Universe"));+++//+Hi+heLLo+Universe|1037289|entityMap|0|LINK|mutability|MUTABLE|url|https://msdn.microsoft.com/en-us/library/system.text.regularexpressions.regex.escape(v=vs.110).aspx|1|https://stackoverflow.com/users/828681/petrucio|2|https://stackoverflow.com/users/588868/steve-b^0|9|C|9|C|0|N|8|1|12|7|2|0|0|0|0|U|E|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@$9|15|A|16|B|C]]|D|@$9|17|A|18|1|19]|$9|1A|A|1B|1|1C]|$9|1D|A|1E|1|1F]]|E|$]]|$1|F|3|G|5|H|7|1G|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1H|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|1I|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1J|8|@$9|1K|A|1L|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|H|7|1M|8|@]|D|@]|E|$I|J]]|$1|S|3|-4|5|6|7|1N|8|@]|D|@]|E|$]]]|T|$U|$5|V|W|X|E|$Y|Z]]|10|$5|V|W|X|E|$Y|11]]|12|$5|V|W|X|E|$Y|13]]]]

Extending <a href="https://stackoverflow.com/users/828681/petrucio">Petrucio</a>'s answer with <a href="https://msdn.microsoft.com/en-us/library/system.text.regularexpressions.regex.escape(v=vs.110).aspx" rel="nofollow noreferrer"><code>Regex.Escape</code></a> on the search string, and escaping matched group as suggested in <a href="https://stackoverflow.com/users/588868/steve-b">Steve B</a>'s answer (and some minor changes to my taste):

<pre><code>public static class StringExtensions
{
 public static string ReplaceIgnoreCase(this string str, string from, string to)
 {
 return Regex.Replace(str, Regex.Escape(from), to.Replace("$", "$$"), RegexOptions.IgnoreCase);
 }
}
</code></pre>

Which will produce the following expected results:

<pre><code>Console.WriteLine("(heLLo) wOrld".ReplaceIgnoreCase("(hello) world", "Hi $1 Universe")); // Hi $1 Universe
Console.WriteLine("heLLo wOrld".ReplaceIgnoreCase("(hello) world", "Hi $1 Universe")); // heLLo wOrld
</code></pre>

However without performing the escapes you would get the following, which is not an expected behaviour from a <code>String.Replace</code> that is just case-insensitive:

<pre><code>Console.WriteLine("(heLLo) wOrld".ReplaceIgnoreCase_NoEscaping("(hello) world", "Hi $1 Universe")); // (heLLo) wOrld
Console.WriteLine("heLLo wOrld".ReplaceIgnoreCase_NoEscaping("(hello) world", "Hi $1 Universe")); // Hi heLLo Universe
</code></pre>

blocks|key|2939126|text|您可以使用Microsoft.VisualBasic名称空间来查找此辅助函数：|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|2939127|Replace(sourceString,+"replacethis",+"withthis",+,+,+CompareMethod.Text)|code-block|syntax|javascript|2939128|entityMap^0|5|L|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

You can use the Microsoft.VisualBasic namespace to find this helper function:

<pre><code>Replace(sourceString, "replacethis", "withthis", , , CompareMethod.Text)
</code></pre>

blocks|key|1037326|text|下面的功能是从字符串集中删除所有像(this)这样的匹配词。作者:+Ravikant+Sonare。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1037327|private+static+void+myfun()
{
++++string+mystring+=+"thiTHISThiss+This+THIS+THis+tThishiThiss.+Box";
++++var+regex+=+new+Regex("this",+RegexOptions.IgnoreCase);
++++mystring+=+regex.Replace(mystring,+"");
++++string[]+str+=+mystring.Split('+');
++++for+(int+i+=+0;+i+<+str.Length;+i%2B%2B)
++++{
++++++++if+(regex.IsMatch(str[i].ToString()))
++++++++{
++++++++++++mystring+=+mystring.Replace(str[i].ToString(),+string.Empty);

++++++++}
++++}
++++Console.WriteLine(mystring);
}|code-block|syntax|javascript|1037328|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Below function is to remove all match word like (this) from the string set. By Ravikant Sonare.

<pre><code>private static void myfun()
{
 string mystring = "thiTHISThiss This THIS THis tThishiThiss. Box";
 var regex = new Regex("this", RegexOptions.IgnoreCase);
 mystring = regex.Replace(mystring, "");
 string[] str = mystring.Split(' ');
 for (int i = 0; i &lt; str.Length; i++)
 {
 if (regex.IsMatch(str[i].ToString()))
 {
 mystring = mystring.Replace(str[i].ToString(), string.Empty);

 }
 }
 Console.WriteLine(mystring);
}
</code></pre>

blocks|key|2939177|text|我已经编写了扩展方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2939178|public+static+string+ReplaceIgnoreCase(this+string+source,+string+oldVale,+string+newVale)
++++{
++++++++if+(source.IsNullOrEmpty()+%7C%7C+oldVale.IsNullOrEmpty())
++++++++++++return+source;

++++++++var+stringBuilder+=+new+StringBuilder();
++++++++string+result+=+source;

++++++++int+index+=+result.IndexOf(oldVale,+StringComparison.InvariantCultureIgnoreCase);

++++++++while+(index+>=+0)
++++++++{
++++++++++++if+(index+>+0)
++++++++++++++++stringBuilder.Append(result.Substring(0,+index));

++++++++++++if+(newVale.IsNullOrEmpty().IsNot())
++++++++++++++++stringBuilder.Append(newVale);

++++++++++++stringBuilder.Append(result.Substring(index+%2B+oldVale.Length));

++++++++++++result+=+stringBuilder.ToString();

++++++++++++index+=+result.IndexOf(oldVale,+StringComparison.InvariantCultureIgnoreCase);
++++++++}

++++++++return+result;
++++}|code-block|syntax|javascript|2939179|对于前面的扩展方法，我使用了两个额外的扩展方法：|2939180|++++public+static+bool+IsNullOrEmpty(this+string+value)
++++{
++++++++return+string.IsNullOrEmpty(value);
++++}

++++public+static+bool+IsNot(this+bool+val)
++++{
++++++++return+val+==+false;
++++}|2939181|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I have wrote extension method:

<pre><code>public static string ReplaceIgnoreCase(this string source, string oldVale, string newVale)
 {
 if (source.IsNullOrEmpty() || oldVale.IsNullOrEmpty())
 return source;

 var stringBuilder = new StringBuilder();
 string result = source;

 int index = result.IndexOf(oldVale, StringComparison.InvariantCultureIgnoreCase);

 while (index &gt;= 0)
 {
 if (index &gt; 0)
 stringBuilder.Append(result.Substring(0, index));

 if (newVale.IsNullOrEmpty().IsNot())
 stringBuilder.Append(newVale);

 stringBuilder.Append(result.Substring(index + oldVale.Length));

 result = stringBuilder.ToString();

 index = result.IndexOf(oldVale, StringComparison.InvariantCultureIgnoreCase);
 }

 return result;
 }
</code></pre>

I use two additional extension methods for previous extension method:

<pre><code> public static bool IsNullOrEmpty(this string value)
 {
 return string.IsNullOrEmpty(value);
 }

 public static bool IsNot(this bool val)
 {
 return val == false;
 }
</code></pre>

blocks|key|2939274|text|与other的正则表达式方法相比，和最有效的方法快2.5倍：|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|2939275|///+<summary>
///+Returns+a+new+string+in+which+all+occurrences+of+a+specified+string+in+the+current+instance+are+replaced+with+another+
///+specified+string+according+the+type+of+search+to+use+for+the+specified+string.
///+</summary>
///+<param+name="str">The+string+performing+the+replace+method.</param>
///+<param+name="oldValue">The+string+to+be+replaced.</param>
///+<param+name="newValue">The+string+replace+all+occurrences+of+<paramref+name="oldValue"/>.+
///+If+value+is+equal+to+<c>null</c>,+than+all+occurrences+of+<paramref+name="oldValue"/>+will+be+removed+from+the+<paramref+name="str"/>.</param>
///+<param+name="comparisonType">One+of+the+enumeration+values+that+specifies+the+rules+for+the+search.</param>
///+<returns>A+string+that+is+equivalent+to+the+current+string+except+that+all+instances+of+<paramref+name="oldValue"/>+are+replaced+with+<paramref+name="newValue"/>.+
///+If+<paramref+name="oldValue"/>+is+not+found+in+the+current+instance,+the+method+returns+the+current+instance+unchanged.</returns>
[DebuggerStepThrough]
public+static+string+Replace(this+string+str,
++++string+oldValue,+string+@newValue,
++++StringComparison+comparisonType)
{

++++//+Check+inputs.
++++if+(str+==+null)
++++{
++++++++//+Same+as+original+.NET+C#+string.Replace+behavior.
++++++++throw+new+ArgumentNullException(nameof(str));
++++}
++++if+(str.Length+==+0)
++++{
++++++++//+Same+as+original+.NET+C#+string.Replace+behavior.
++++++++return+str;
++++}
++++if+(oldValue+==+null)
++++{
++++++++//+Same+as+original+.NET+C#+string.Replace+behavior.
++++++++throw+new+ArgumentNullException(nameof(oldValue));
++++}
++++if+(oldValue.Length+==+0)
++++{
++++++++//+Same+as+original+.NET+C#+string.Replace+behavior.
++++++++throw+new+ArgumentException("String+cannot+be+of+zero+length.");
++++}


++++//if+(oldValue.Equals(newValue,+comparisonType))
++++//{
++++//This+condition+has+no+sense
++++//It+will+prevent+method+from+replacesing:+"Example",+"ExAmPlE",+"EXAMPLE"+to+"example"
++++//return+str;
++++//}



++++//+Prepare+string+builder+for+storing+the+processed+string.
++++//+Note:+StringBuilder+has+a+better+performance+than+String+by+30-40%25.
++++StringBuilder+resultStringBuilder+=+new+StringBuilder(str.Length);



++++//+Analyze+the+replacement:+replace+or+remove.
++++bool+isReplacementNullOrEmpty+=+string.IsNullOrEmpty(@newValue);



++++//+Replace+all+values.
++++const+int+valueNotFound+=+-1;
++++int+foundAt;
++++int+startSearchFromIndex+=+0;
++++while+((foundAt+=+str.IndexOf(oldValue,+startSearchFromIndex,+comparisonType))+!=+valueNotFound)
++++{

++++++++//+Append+all+characters+until+the+found+replacement.
++++++++int+@charsUntilReplacment+=+foundAt+-+startSearchFromIndex;
++++++++bool+isNothingToAppend+=+@charsUntilReplacment+==+0;
++++++++if+(!isNothingToAppend)
++++++++{
++++++++++++resultStringBuilder.Append(str,+startSearchFromIndex,+@charsUntilReplacment);
++++++++}



++++++++//+Process+the+replacement.
++++++++if+(!isReplacementNullOrEmpty)
++++++++{
++++++++++++resultStringBuilder.Append(@newValue);
++++++++}


++++++++//+Prepare+start+index+for+the+next+search.
++++++++//+This+needed+to+prevent+infinite+loop,+otherwise+method+always+start+search+
++++++++//+from+the+start+of+the+string.+For+example:+if+an+oldValue+==+"EXAMPLE",+newValue+==+"example"
++++++++//+and+comparisonType+==+"any+ignore+case"+will+conquer+to+replacing:
++++++++//+"EXAMPLE"+to+"example"+to+"example"+to+"example"+…+infinite+loop.
++++++++startSearchFromIndex+=+foundAt+%2B+oldValue.Length;
++++++++if+(startSearchFromIndex+==+str.Length)
++++++++{
++++++++++++//+It+is+end+of+the+input+string:+no+more+space+for+the+next+search.
++++++++++++//+The+input+string+ends+with+a+value+that+has+already+been+replaced.+
++++++++++++//+Therefore,+the+string+builder+with+the+result+is+complete+and+no+further+action+is+required.
++++++++++++return+resultStringBuilder.ToString();
++++++++}
++++}


++++//+Append+the+last+part+to+the+result.
++++int+@charsUntilStringEnd+=+str.Length+-+startSearchFromIndex;
++++resultStringBuilder.Append(str,+startSearchFromIndex,+@charsUntilStringEnd);


++++return+resultStringBuilder.ToString();

}|code-block|syntax|javascript|2939276|注意:+ignore+case+==+StringComparison.OrdinalIgnoreCase作为StringComparison+comparisonType的参数。它是替换所有值的最快、不区分大小写的方法。|CODE|2939277|2939278|这种方法的优点是：|2939279|高CPU和内存efficiency;|2939280|It是最快的解决方案，比其他正则表达式的方法快2.5倍(在end);|unordered-list-item|2939281|
|2939282|Suitable中证明从输入字符串中删除部分(将|2939283|2939284|设置为null)，为此进行了优化；|2939285|2939286|与原始的.NET+C#+string.Replace行为相同，相同的exceptions;|2939287|2939288|Well注释，易于understand;|2939289|2939290|Simpler+-+no正则表达式。正则表达式总是因为它们的通用性而变慢(即使是compiled);|2939291|2939292|This方法也经过了很好的测试，在其他的解决方案中也没有像无限循环这样的隐藏缺陷，即使是很高的评价：|2939293|2939294|2939295|+@AsValeO:不适用于正则表达式语言元素，因此它不是通用方法|blockquote|2939296|2939297|@Mike+Stillion:这段代码有问题。如果new中的文本是old中文本的超集，则会产生无限循环。|2939298|2939299|2939300|Benchmark-proof：这个解决方案比@Steve+B.的快2.59x倍，代码：|2939301|//+Results:
//+1/2.+Regular+expression+solution:+4486+milliseconds
//+2/2.+Current+solution:+1727+milliseconds+—+2.59X+times+FASTER!+than+regex!

//+Notes:+the+test+was+started+5+times,+the+result+is+an+average;+release+build.

const+int+benchmarkIterations+=+1000000;
const+string+sourceString+=+"aaaaddsdsdsdsdsd";
const+string+oldValue+=+"D";
const+string+newValue+=+"Fod";
long+totalLenght+=+0;

Stopwatch+regexStopwatch+=+Stopwatch.StartNew();
string+tempString1;
for+(int+i+=+0;+i+<+benchmarkIterations;+i%2B%2B)
{
++++tempString1+=+sourceString;
++++tempString1+=+ReplaceCaseInsensitive(tempString1,+oldValue,+newValue);

++++totalLenght+=+totalLenght+%2B+tempString1.Length;
}
regexStopwatch.Stop();



Stopwatch+currentSolutionStopwatch+=+Stopwatch.StartNew();
string+tempString2;
for+(int+i+=+0;+i+<+benchmarkIterations;+i%2B%2B)
{
++++tempString2+=+sourceString;
++++tempString2+=+tempString2.Replace(oldValue,+newValue,
++++++++StringComparison.OrdinalIgnoreCase);

++++totalLenght+=+totalLenght+%2B+tempString2.Length;
}
currentSolutionStopwatch.Stop();|2939302|2939303|原创创意--+@Darky711；感谢@MinerR的StringBuilder。|2939304|entityMap^0|I|4|0|0|0|F|J|Y|1J|V|0|0|0|0|0|0|0|0|3|4|0|0|C|E|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|F|X|6|0|0|0|R|D|0^^$0|@$1|2|3|4|5|6|7|1X|8|@$9|1Y|A|1Z|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|20|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|21|8|@$9|22|A|23|B|C]|$9|24|A|25|B|M]|$9|26|A|27|B|M]]|D|@]|E|$]]|$1|N|3|-4|5|6|7|28|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|29|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|2A|8|@]|D|@]|E|$]]|$1|S|3|T|5|U|7|2B|8|@]|D|@]|E|$]]|$1|V|3|W|5|6|7|2C|8|@]|D|@]|E|$]]|$1|X|3|Y|5|U|7|2D|8|@]|D|@]|E|$]]|$1|Z|3|W|5|6|7|2E|8|@]|D|@]|E|$]]|$1|10|3|11|5|U|7|2F|8|@$9|2G|A|2H|B|M]]|D|@]|E|$]]|$1|12|3|W|5|6|7|2I|8|@]|D|@]|E|$]]|$1|13|3|14|5|U|7|2J|8|@$9|2K|A|2L|B|M]]|D|@]|E|$]]|$1|15|3|W|5|6|7|2M|8|@]|D|@]|E|$]]|$1|16|3|17|5|U|7|2N|8|@]|D|@]|E|$]]|$1|18|3|W|5|6|7|2O|8|@]|D|@]|E|$]]|$1|19|3|1A|5|U|7|2P|8|@]|D|@]|E|$]]|$1|1B|3|W|5|6|7|2Q|8|@]|D|@]|E|$]]|$1|1C|3|1D|5|U|7|2R|8|@]|D|@]|E|$]]|$1|1E|3|-4|5|6|7|2S|8|@]|D|@]|E|$]]|$1|1F|3|-4|5|6|7|2T|8|@]|D|@]|E|$]]|$1|1G|3|1H|5|1I|7|2U|8|@]|D|@]|E|$]]|$1|1J|3|-4|5|6|7|2V|8|@]|D|@]|E|$]]|$1|1K|3|1L|5|6|7|2W|8|@]|D|@]|E|$]]|$1|1M|3|-4|5|6|7|2X|8|@]|D|@]|E|$]]|$1|1N|3|-4|5|6|7|2Y|8|@]|D|@]|E|$]]|$1|1O|3|1P|5|6|7|2Z|8|@$9|30|A|31|B|C]|$9|32|A|33|B|C]]|D|@]|E|$]]|$1|1Q|3|1R|5|H|7|34|8|@]|D|@]|E|$I|J]]|$1|1S|3|-4|5|6|7|35|8|@]|D|@]|E|$]]|$1|1T|3|1U|5|6|7|36|8|@$9|37|A|38|B|M]]|D|@]|E|$]]|$1|1V|3|-4|5|6|7|39|8|@]|D|@]|E|$]]]|1W|$]]

2.5X FASTER and MOST EFFECTIVE method than other's regular expressions methods:

<pre><code>/// &lt;summary&gt;
/// Returns a new string in which all occurrences of a specified string in the current instance are replaced with another 
/// specified string according the type of search to use for the specified string.
/// &lt;/summary&gt;
/// &lt;param name="str"&gt;The string performing the replace method.&lt;/param&gt;
/// &lt;param name="oldValue"&gt;The string to be replaced.&lt;/param&gt;
/// &lt;param name="newValue"&gt;The string replace all occurrences of &lt;paramref name="oldValue"/&gt;. 
/// If value is equal to &lt;c&gt;null&lt;/c&gt;, than all occurrences of &lt;paramref name="oldValue"/&gt; will be removed from the &lt;paramref name="str"/&gt;.&lt;/param&gt;
/// &lt;param name="comparisonType"&gt;One of the enumeration values that specifies the rules for the search.&lt;/param&gt;
/// &lt;returns&gt;A string that is equivalent to the current string except that all instances of &lt;paramref name="oldValue"/&gt; are replaced with &lt;paramref name="newValue"/&gt;. 
/// If &lt;paramref name="oldValue"/&gt; is not found in the current instance, the method returns the current instance unchanged.&lt;/returns&gt;
[DebuggerStepThrough]
public static string Replace(this string str,
 string oldValue, string @newValue,
 StringComparison comparisonType)
{

 // Check inputs.
 if (str == null)
 {
 // Same as original .NET C# string.Replace behavior.
 throw new ArgumentNullException(nameof(str));
 }
 if (str.Length == 0)
 {
 // Same as original .NET C# string.Replace behavior.
 return str;
 }
 if (oldValue == null)
 {
 // Same as original .NET C# string.Replace behavior.
 throw new ArgumentNullException(nameof(oldValue));
 }
 if (oldValue.Length == 0)
 {
 // Same as original .NET C# string.Replace behavior.
 throw new ArgumentException("String cannot be of zero length.");
 }


 //if (oldValue.Equals(newValue, comparisonType))
 //{
 //This condition has no sense
 //It will prevent method from replacesing: "Example", "ExAmPlE", "EXAMPLE" to "example"
 //return str;
 //}



 // Prepare string builder for storing the processed string.
 // Note: StringBuilder has a better performance than String by 30-40%.
 StringBuilder resultStringBuilder = new StringBuilder(str.Length);



 // Analyze the replacement: replace or remove.
 bool isReplacementNullOrEmpty = string.IsNullOrEmpty(@newValue);



 // Replace all values.
 const int valueNotFound = -1;
 int foundAt;
 int startSearchFromIndex = 0;
 while ((foundAt = str.IndexOf(oldValue, startSearchFromIndex, comparisonType)) != valueNotFound)
 {

 // Append all characters until the found replacement.
 int @charsUntilReplacment = foundAt - startSearchFromIndex;
 bool isNothingToAppend = @charsUntilReplacment == 0;
 if (!isNothingToAppend)
 {
 resultStringBuilder.Append(str, startSearchFromIndex, @charsUntilReplacment);
 }



 // Process the replacement.
 if (!isReplacementNullOrEmpty)
 {
 resultStringBuilder.Append(@newValue);
 }


 // Prepare start index for the next search.
 // This needed to prevent infinite loop, otherwise method always start search 
 // from the start of the string. For example: if an oldValue == "EXAMPLE", newValue == "example"
 // and comparisonType == "any ignore case" will conquer to replacing:
 // "EXAMPLE" to "example" to "example" to "example" … infinite loop.
 startSearchFromIndex = foundAt + oldValue.Length;
 if (startSearchFromIndex == str.Length)
 {
 // It is end of the input string: no more space for the next search.
 // The input string ends with a value that has already been replaced. 
 // Therefore, the string builder with the result is complete and no further action is required.
 return resultStringBuilder.ToString();
 }
 }


 // Append the last part to the result.
 int @charsUntilStringEnd = str.Length - startSearchFromIndex;
 resultStringBuilder.Append(str, startSearchFromIndex, @charsUntilStringEnd);


 return resultStringBuilder.ToString();

}
</code></pre>

Note: ignore case == <code>StringComparison.OrdinalIgnoreCase</code> as parameter for <code>StringComparison comparisonType</code>. It is the fastest, case-insensitive way to replace all values.

<hr>

Advantages of this method:

<ul>
<li>High CPU and MEMORY efficiency;</li>
<li>It is the fastest solution, 2.5 times faster than other's methods
with regular expressions (proof in the end);</li>
<li>Suitable for removing parts from the input string (set <code>newValue</code> to
<code>null</code>), optimized for this;</li>
<li>Same as original .NET C# <code>string.Replace</code> behavior, same exceptions;</li>
<li>Well commented, easy to understand;</li>
<li>Simpler – no regular expressions. Regular expressions are always slower because of their versatility (even compiled);</li>
<li>This method is well tested and there are no hidden flaws like infinite loop in other's solutions, even highly rated:</li>
</ul>

<blockquote>
 @AsValeO: Not works with Regex language elements, so it's not
 universal method
 
 @Mike Stillion: There is a problem with this code. If the text in new
 is a superset of the text in old, this can produce an endless loop.
</blockquote>

<hr>

Benchmark-proof: this solution is 2.59X times faster than regex from @Steve B., code:

<pre><code>// Results:
// 1/2. Regular expression solution: 4486 milliseconds
// 2/2. Current solution: 1727 milliseconds — 2.59X times FASTER! than regex!

// Notes: the test was started 5 times, the result is an average; release build.

const int benchmarkIterations = 1000000;
const string sourceString = "aaaaddsdsdsdsdsd";
const string oldValue = "D";
const string newValue = "Fod";
long totalLenght = 0;

Stopwatch regexStopwatch = Stopwatch.StartNew();
string tempString1;
for (int i = 0; i &lt; benchmarkIterations; i++)
{
 tempString1 = sourceString;
 tempString1 = ReplaceCaseInsensitive(tempString1, oldValue, newValue);

 totalLenght = totalLenght + tempString1.Length;
}
regexStopwatch.Stop();



Stopwatch currentSolutionStopwatch = Stopwatch.StartNew();
string tempString2;
for (int i = 0; i &lt; benchmarkIterations; i++)
{
 tempString2 = sourceString;
 tempString2 = tempString2.Replace(oldValue, newValue,
 StringComparison.OrdinalIgnoreCase);

 totalLenght = totalLenght + tempString2.Length;
}
currentSolutionStopwatch.Stop();
</code></pre>

<hr>

Original idea – @Darky711; thanks @MinerR for <code>StringBuilder</code>.

blocks|key|4727802|text|这不起作用吗:我无法想象还有什么比这更快或更容易的了。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4727803|public+static+class+ExtensionMethodsString
{
++++public+static+string+Replace(this+String+thisString,+string+oldValue,+string+newValue,+StringComparison+stringComparison)
++++{
++++++++string+working+=+thisString;
++++++++int+index+=+working.IndexOf(oldValue,+stringComparison);
++++++++while+(index+!=+-1)
++++++++{
++++++++++++working+=+working.Remove(index,+oldValue.Length);
++++++++++++working+=+working.Insert(index,+newValue);
++++++++++++index+=+index+%2B+newValue.Length;
++++++++++++index+=+working.IndexOf(oldValue,+index,+stringComparison);
++++++++}
++++++++return+working;
++++}
}|code-block|syntax|javascript|4727804|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Doesn't this work: I cant imaging anything else being much quicker or easier.

<pre><code>public static class ExtensionMethodsString
{
 public static string Replace(this String thisString, string oldValue, string newValue, StringComparison stringComparison)
 {
 string working = thisString;
 int index = working.IndexOf(oldValue, stringComparison);
 while (index != -1)
 {
 working = working.Remove(index, oldValue.Length);
 working = working.Insert(index, newValue);
 index = index + newValue.Length;
 index = working.IndexOf(oldValue, index, stringComparison);
 }
 return working;
 }
}
</code></pre>

blocks|key|4727843|text|使用@Georgy+Batalov解决方案时，我在使用以下示例时遇到了问题|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4727844|字符串原始=+"blah，DC=bleh，DC=blih，DC=bloh，DC=com"；字符串替换=+original.ReplaceIgnoreCase("，DC="，".")|4727845|下面是我是如何重写他的扩展的|4727846|public+static+string+ReplaceIgnoreCase(this+string+source,+string+oldVale,+
string+newVale)
++++{
++++++++if+(source.IsNullOrEmpty()+%7C%7C+oldVale.IsNullOrEmpty())
++++++++++++return+source;

++++++++var+stringBuilder+=+new+StringBuilder();
++++++++string+result+=+source;

++++++++int+index+=+result.IndexOf(oldVale,+StringComparison.InvariantCultureIgnoreCase);
++++++++bool+initialRun+=+true;

++++++++while+(index+>=+0)
++++++++{
++++++++++++string+substr+=+result.Substring(0,+index);
++++++++++++substr+=+substr+%2B+newVale;
++++++++++++result+=+result.Remove(0,+index);
++++++++++++result+=+result.Remove(0,+oldVale.Length);

++++++++++++stringBuilder.Append(substr);

++++++++++++index+=+result.IndexOf(oldVale,+StringComparison.InvariantCultureIgnoreCase);
++++++++}

++++++++if+(result.Length+>+0)
++++++++{
++++++++++++stringBuilder.Append(result);
++++++++}

++++++++return+stringBuilder.ToString();
++++}|code-block|syntax|javascript|4727847|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|O|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|P|8|@]|9|@]|A|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Using @Georgy Batalov solution I had a problem when using the following example

string original = "blah,DC=bleh,DC=blih,DC=bloh,DC=com";
string replaced = original.ReplaceIgnoreCase(",DC=", ".")

Below is how I rewrote his extension

<pre><code>public static string ReplaceIgnoreCase(this string source, string oldVale, 
string newVale)
 {
 if (source.IsNullOrEmpty() || oldVale.IsNullOrEmpty())
 return source;

 var stringBuilder = new StringBuilder();
 string result = source;

 int index = result.IndexOf(oldVale, StringComparison.InvariantCultureIgnoreCase);
 bool initialRun = true;

 while (index &gt;= 0)
 {
 string substr = result.Substring(0, index);
 substr = substr + newVale;
 result = result.Remove(0, index);
 result = result.Remove(0, oldVale.Length);

 stringBuilder.Append(substr);

 index = result.IndexOf(oldVale, StringComparison.InvariantCultureIgnoreCase);
 }

 if (result.Length &gt; 0)
 {
 stringBuilder.Append(result);
 }

 return stringBuilder.ToString();
 }
</code></pre>

blocks|key|2654206|text|我更喜欢这样--+"Hello+World".ToLower().Replace(+"world"，"csharp“)；|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2654207|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I prefer this - "Hello World".ToLower().Replace( "world", "csharp" );

blocks|key|4727867|text|以下是替换字符串的替代方法，忽略字符大小写|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4727868|String+thisString+=+"hello+world";+
String+replaceString+=+"World";

//thisString.Replace("World",+"csharp");+
//below+is+the+alternative+to+replace+string+ignoring+character+case

int+start+=+StringUtils.indexOfIgnoreCase(thisString,replaceString);
String+searchKey+=+thisString.substring(start,+start%2BreplaceString.length());
thisString=+thisString.replaceAll(searchKey+,replaceString+);
System.out.println(thisString);

//prints+hello+World|code-block|syntax|javascript|4727869|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

below is the alternative to replace string ignoring character case

<pre><code>String thisString = "hello world"; 
String replaceString = "World";

//thisString.Replace("World", "csharp"); 
//below is the alternative to replace string ignoring character case

int start = StringUtils.indexOfIgnoreCase(thisString,replaceString);
String searchKey = thisString.substring(start, start+replaceString.length());
thisString= thisString.replaceAll(searchKey ,replaceString );
System.out.println(thisString);

//prints hello World
</code></pre>

blocks|key|1037557|text|您还可以尝试使用Regex类。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1037558|var+regex+=+new+Regex(+"camel",+RegexOptions.IgnoreCase+);+var+newSentence+=+regex.Replace(+sentence,+"horse"+);|1037559|entityMap^0|8|5|0|0|34|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|P|8|@]|D|@]|E|$]]]|I|$]]

You can also try the <code>Regex</code> class.

<code>var regex = new Regex( "camel", RegexOptions.IgnoreCase );
var newSentence = regex.Replace( sentence, "horse" );</code>

blocks|key|4727911|text|.Net核心内置了这个方法：Replace(String,+String,+StringComparison)+Doc。现在我们可以简单地写成："...".Replace("oldValue",+"newValue",+StringComparison.OrdinalIgnoreCase)|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4727912|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.microsoft.com/en-us/dotnet/api/system.string.replace?view=netcore-2.2#System_String_Replace_System_String_System_String_System_StringComparison_^0|E|15|20|21|1K|3|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]|$9|Q|A|R|B|C]]|D|@$9|S|A|T|1|U]]|E|$]]|$1|F|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

.Net Core has this method built-in:
<code>Replace(String, String, StringComparison)</code> <a href="https://docs.microsoft.com/en-us/dotnet/api/system.string.replace?view=netcore-2.2#System_String_Replace_System_String_System_String_System_StringComparison_" rel="noreferrer">Doc</a>. Now we can simply write:
<code>&quot;...&quot;.Replace(&quot;oldValue&quot;, &quot;newValue&quot;, StringComparison.OrdinalIgnoreCase)</code>

blocks|key|4727936|text|使用这个，测试和100%25的工作！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4727937|对于VB.NET|4727938|Dim+myString+As+String
Dim+oldValue+As+String
Dim+newValue+As+String

myString+=+Form1.TextBox1.Text
oldValue+=+TextBox1.Text
newValue+=+TextBox2.Text

Dim+working+As+String+=+myString
Dim+index+As+Integer+=+working.IndexOf(oldValue,+StringComparison.CurrentCultureIgnoreCase)

While+index+<>+-1
++++working+=+working.Remove(index,+oldValue.Length)
++++working+=+working.Insert(index,+newValue)
++++index+=+index+%2B+newValue.Length
++++index+=+working.IndexOf(oldValue,+index,+StringComparison.CurrentCultureIgnoreCase)
++++Form1.TextBox1.Text+=+working
End+While|code-block|syntax|javascript|4727939|对于C#|4727940|private+void+Button2_Click(System.Object+sender,+System.EventArgs+e)
{
++++string+myString;
++++string+oldValue;
++++string+newValue;

++++myString+=+Form1.TextBox1.Text;
++++oldValue+=+TextBox1.Text;
++++newValue+=+TextBox2.Text;

++++string+working+=+myString;
++++int+index+=+working.IndexOf(oldValue,+StringComparison.CurrentCultureIgnoreCase);

++++while+(index+!=+-1)
++++{
++++++++working+=+working.Remove(index,+oldValue.Length);
++++++++working+=+working.Insert(index,+newValue);
++++++++index+=+index+%2B+newValue.Length;
++++++++index+=+working.IndexOf(oldValue,+index,+StringComparison.CurrentCultureIgnoreCase);
++++++++Form1.TextBox1.Text+=+working;
++++}
}|4727941|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Use this, Tested and 100% Worked!
For VB.NET
<pre><code>Dim myString As String
Dim oldValue As String
Dim newValue As String

myString = Form1.TextBox1.Text
oldValue = TextBox1.Text
newValue = TextBox2.Text

Dim working As String = myString
Dim index As Integer = working.IndexOf(oldValue, StringComparison.CurrentCultureIgnoreCase)

While index &lt;&gt; -1
 working = working.Remove(index, oldValue.Length)
 working = working.Insert(index, newValue)
 index = index + newValue.Length
 index = working.IndexOf(oldValue, index, StringComparison.CurrentCultureIgnoreCase)
 Form1.TextBox1.Text = working
End While
</code></pre>
For C#
<pre><code>private void Button2_Click(System.Object sender, System.EventArgs e)
{
 string myString;
 string oldValue;
 string newValue;

 myString = Form1.TextBox1.Text;
 oldValue = TextBox1.Text;
 newValue = TextBox2.Text;

 string working = myString;
 int index = working.IndexOf(oldValue, StringComparison.CurrentCultureIgnoreCase);

 while (index != -1)
 {
 working = working.Remove(index, oldValue.Length);
 working = working.Insert(index, newValue);
 index = index + newValue.Length;
 index = working.IndexOf(oldValue, index, StringComparison.CurrentCultureIgnoreCase);
 Form1.TextBox1.Text = working;
 }
}
</code></pre>

blocks|key|1037659|text|此方法可以忽略大小写，也可以仅选择整个单词|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1037660|public+static+string+Replace(this+string+s,+string+word,+string+by,+StringComparison+stringComparison,+bool+WholeWord)
{
++++s+=+s+%2B+"+";
++++int+wordSt;
++++StringBuilder+sb+=+new+StringBuilder();
++++while+(s.IndexOf(word,+stringComparison)+>+-1)
++++{
++++++++wordSt+=+s.IndexOf(word,+stringComparison);
++++++++if+(!WholeWord+%7C%7C+((wordSt+==+0+%7C%7C+!Char.IsLetterOrDigit(char.Parse(s.Substring(wordSt+-+1,+1))))+&&+!Char.IsLetterOrDigit(char.Parse(s.Substring(wordSt+%2B+word.Length,+1)))))
++++++++{
++++++++++++sb.Append(s.Substring(0,+wordSt)+%2B+by);
++++++++}
++++++++else
++++++++{
++++++++++++sb.Append(s.Substring(0,+wordSt+%2B+word.Length));
++++++++}
++++++++s+=+s.Substring(wordSt+%2B+word.Length);
++++}
++++sb.Append(s);
++++return+sb.ToString().Substring(0,+sb.Length+-+1);
}|code-block|syntax|javascript|1037661|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

My this Method could Ignore Case as well as Select Only Whole Word
<pre><code>public static string Replace(this string s, string word, string by, StringComparison stringComparison, bool WholeWord)
{
 s = s + &quot; &quot;;
 int wordSt;
 StringBuilder sb = new StringBuilder();
 while (s.IndexOf(word, stringComparison) &gt; -1)
 {
 wordSt = s.IndexOf(word, stringComparison);
 if (!WholeWord || ((wordSt == 0 || !Char.IsLetterOrDigit(char.Parse(s.Substring(wordSt - 1, 1)))) &amp;&amp; !Char.IsLetterOrDigit(char.Parse(s.Substring(wordSt + word.Length, 1)))))
 {
 sb.Append(s.Substring(0, wordSt) + by);
 }
 else
 {
 sb.Append(s.Substring(0, wordSt + word.Length));
 }
 s = s.Substring(wordSt + word.Length);
 }
 sb.Append(s);
 return sb.ToString().Substring(0, sb.Length - 1);
}
</code></pre>

I have a string called "hello world"

I need to replace the word "world" to "csharp"

for this I use:

<pre><code>string.Replace("World", "csharp");
</code></pre>

but as a result, I don't get the string replaced. The reason is case sensitiveness. The original string contains "world" whereas I'm trying to replace "World".

Is there any way to avoid this case sensitiveness in string.Replace method?

String.Replace ignoring case

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我有一个名为"hello world“的字符串我需要把"world“改成"csharp”为此，我使用：string.Replace("World", "csharp");但是结果是，我没有把字符串替换掉。原因是区分大小写。原始字符串包含"World“，而我正在尝试替换"world”。有没有办法避免在string.Rep...

问String.Replace忽略大小写
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问String.Replace忽略大小写EN