Chaîne de caractères.Remplacer ignorant la casse

Vous pouvez utiliser un Regex et d'effectuer un casse remplacer:

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

Extensions de rendre notre vie plus facile:

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;
    }
}

2,5 X plus RAPIDE et PLUS EFFICACE méthode que celle des autres expressions régulières méthodes:

///<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%.
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();
}

Remarque: ignorer la casse == StringComparison.OrdinalIgnoreCase en tant que paramètre pour StringComparison comparisonType. Il est le plus rapide, non sensible à la casse pour remplacer toutes les valeurs.

---

Avantages de cette méthode:

• Élevée de l'UC et de la MÉMOIRE de l'efficacité;
• C'est la solution la plus rapide, 2,5 fois plus rapide que les autres méthodes
  avec des expressions régulières (preuve à la fin);
• Adapté pour enlever les parties de la chaîne d'entrée (set newValue à
  null), optimisé pour le présent;
• Le même que l'original .NET C# string.Replace comportement, même des exceptions;
• Bien documenté, facile à comprendre;
• Plus simple – pas d'expressions régulières. Les expressions régulières sont toujours plus lent en raison de leur polyvalence (même compilé);
• Cette méthode est bien testé et il n'y a pas des vices cachés comme une boucle infinie dans d'autres solutions, même très bien noté:

@AsValeO: fonctionne Pas avec la Regex éléments de langage, il n'est donc pas
méthode universelle

@Mike Stillion: Il y a un problème avec ce code. Si le texte de la nouvelle
est un sur-ensemble du texte dans l'ancien, ce qui peut produire une boucle sans fin.

---

De référence-la preuve: cette solution est 2.59 X fois plus rapide que la regex par @Steve B., 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 < 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 < benchmarkIterations; i++)
{
tempString2 = sourceString;
tempString2 = tempString2.Replace(oldValue, newValue,
StringComparison.OrdinalIgnoreCase);
totalLenght = totalLenght + tempString2.Length;
}
currentSolutionStopwatch.Stop();

---

Idée originale – @Darky711; merci @MinerR pour StringBuilder.

(Édité: n'étais pas au courant de le " nu lien de problème, désolé)

Prises de ici:

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

Semble que vous n'êtes pas le premier à se plaindre de l'absence de chaîne casse.Remplacer.

J'ai écrit méthode d'extension:

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 >= 0)
{
if (index > 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;
}

J'utilise deux méthodes d'extension pour la précédente méthode d'extension:

    public static bool IsNullOrEmpty(this string value)
{
return string.IsNullOrEmpty(value);
}
public static bool IsNot(this bool val)
{
return val == false;
}

Ci-dessous la fonction est d'éliminer tous correspondre à des mots tels que (ce) de la chaîne de la valeur. Par Ravikant Sonare.

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++)
{
if (regex.IsMatch(str[i].ToString()))
{
mystring = mystring.Replace(str[i].ToString(), string.Empty);
}
}
Console.WriteLine(mystring);
}

À l'aide de @Georgy Batalov solution j'ai eu un problème lors de l'utilisation de l'exemple suivant

chaîne d'origine = "bla,DC=bleh,DC=blih,DC=bloh,DC=com";
chaîne remplacé = original.ReplaceIgnoreCase(",DC=", ".")

Ci-dessous comment j'ai réécrit son extension

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 >= 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 > 0)
{
stringBuilder.Append(result);
}
return stringBuilder.ToString();
}

Je préfère ce - "Bonjour le Monde".ToLower().Replace( "le monde", "csharp" );