Dize için bir alternatif var mı?

Bir dize aramak ve tüm oluşumları %FirstName%ve %PolicyAmount%bir veritabanından çekilen bir değer ile değiştirmek gerekiyor . Sorun FirstName büyük harf değişiyor olmasıdır. Bu String.Replace()yöntemi kullanmamı engelliyor . Konuyla ilgili şu web sayfalarını gördüm:

Regex.Replace(strInput, strToken, strReplaceWith, RegexOptions.IgnoreCase);

Ancak ben denemek ve değiştirme nedense %PolicyAmount%ile $0, yedek gerçekleşir asla. Dolar işareti regex ayrılmış bir karakter olması ile ilgili bir şey olduğunu varsayalım.

Regex özel karakterlerle başa çıkmak için girdiyi sterilize etmeyi içermeyen başka bir yöntem var mı?

MSDN
$ 0 - "Son alt dizeyi grup numarası numarasıyla (ondalık) eşleştirir."

.NET Normal ifadelerinde grup 0 her zaman tüm eşleşmedir. Gerçek bir $ için yapmanız gerekenler

string value = Regex.Replace("%PolicyAmount%", "%PolicyAmount%", @"$$0", RegexOptions.IgnoreCase);

Tartışmayı gerektiren bir aşırı yüklenme string.Replace olmalı gibi görünüyor StringComparison. Olmadığı için böyle bir şey deneyebilirsiniz:

public static string ReplaceString(string str, string oldValue, string newValue, StringComparison comparison)
{
    StringBuilder sb = new StringBuilder();

    int previousIndex = 0;
    int index = str.IndexOf(oldValue, comparison);
    while (index != -1)
    {
        sb.Append(str.Substring(previousIndex, index - previousIndex));
        sb.Append(newValue);
        index += oldValue.Length;

        previousIndex = index;
        index = str.IndexOf(oldValue, index, comparison);
    }
    sb.Append(str.Substring(previousIndex));

    return sb.ToString();
}

Kısmen kafa karıştırıcı bir cevap grubu, çünkü sorunun başlığı aslında sorulan sorudan çok daha büyük. Okuduktan sonra, herhangi bir cevabın, tüm iyi şeyleri özümsemekten birkaç düzenleme uzak olduğundan emin değilim, bu yüzden toplamayı deneyeceğim.

Burada bahsettiğim tuzaklardan kaçınan ve en geniş kapsamlı çözümü sunan bir uzantı yöntemi.

public static string ReplaceCaseInsensitiveFind(this string str, string findMe,
    string newValue)
{
    return Regex.Replace(str,
        Regex.Escape(findMe),
        Regex.Replace(newValue, "\\$[0-9]+", @"$$$0"),
        RegexOptions.IgnoreCase);
}

Yani...

• Bu @MarkRobinson bir uzantı yöntemidir
• Bu , Regex @Helge'i atlamaya çalışmaz (Regex'in dışında böyle koklamayı dizmek istiyorsanız gerçekten byte by-byte yapmanız gerekir)
• @MichaelLiu bireyin Geçirdi mükemmel test durumda , "œ".ReplaceCaseInsensitiveFind("oe", "")o aklında biraz daha farklı bir davranış olmuş olabilir gerçi.

Ne yazık ki, @HA'nın üçüne de sahip olduğunuz yorumu Escapedoğru değil . Başlangıç ​​değeri ve newValueolması gerekmez.

Not: Ancak, "yakalanan değer" işaretinin bir parçasıysa,$ eklediğiniz yeni değerden kaçmak zorundasınız . Böylece üç dolar işareti Regex.Regex.Replace [sic] içine yerleştirin. Bu olmadan, böyle bir şey kırılır ...

"This is HIS fork, hIs spoon, hissssssss knife.".ReplaceCaseInsensitiveFind("his", @"he$0r")

İşte hata:

An unhandled exception of type 'System.ArgumentException' occurred in System.dll

Additional information: parsing "The\hisr\ is\ he\HISr\ fork,\ he\hIsr\ spoon,\ he\hisrsssssss\ knife\." - Unrecognized escape sequence \h.

Ne söyleyeyim, Regex ile rahat olan insanların kullanımlarının hatalardan kaçındığını hissediyorum, ancak genellikle koklama dizelerini bayt etmek için hala kısmi oluyorum (ancak yalnızca kodlamalarda Spolsky'yi okuduktan sonra ) önemli kullanım durumları için tasarlanmıştır. Bana biraz güvensiz düzenli ifadeler Crockford hatırlatıyor . Çok sık istediğimiz şeye izin veren (şanslıysak) $10regexps yazıyoruz , ancak kasıtlı olarak daha fazlasına izin veriyoruz (örn., NewValue regexp'imde gerçekten geçerli bir "yakalama değeri" dizesi mi?), Çünkü yeterince düşünmedik . Her iki yöntemin de değeri vardır ve her ikisi de farklı türdeki istenmeyen hataları teşvik eder. Karmaşıklığı hafife almak genellikle kolaydır.

Bu tuhaf $kaçış (ve bu , yerine koyma değerlerinde beklediğim Regex.Escapegibi yakalanan değer kalıplarından kaçmadı $0) beni bir süre deli etti. Programlama Zor (c) 1842

İşte bir uzantı yöntemi. Nerede bulduğumdan emin değilim.

public static class StringExtensions
{
    public static string Replace(this string originalString, string oldValue, string newValue, StringComparison comparisonType)
    {
        int startIndex = 0;
        while (true)
        {
            startIndex = originalString.IndexOf(oldValue, startIndex, comparisonType);
            if (startIndex == -1)
                break;

            originalString = originalString.Substring(0, startIndex) + newValue + originalString.Substring(startIndex + oldValue.Length);

            startIndex += newValue.Length;
        }

        return originalString;
    }

}

En kolay yöntem basitçe .Net ile gelen ve .Net 1.0'dan beri var olan Değiştir yöntemini kullanmak gibi görünüyor:

string res = Microsoft.VisualBasic.Strings.Replace(res, 
                                   "%PolicyAmount%", 
                                   "$0", 
                                   Compare: Microsoft.VisualBasic.CompareMethod.Text);

Bu yöntemi kullanmak için, Microsoft.VisualBasic derlemesine bir başvuru eklemeniz gerekir. Bu derleme .Net çalışma zamanının standart bir parçasıdır, fazladan bir indirme değildir veya kullanılmaz olarak işaretlenmiştir.

    /// <summary>
    /// A case insenstive replace function.
    /// </summary>
    /// <param name="originalString">The string to examine.(HayStack)</param>
    /// <param name="oldValue">The value to replace.(Needle)</param>
    /// <param name="newValue">The new value to be inserted</param>
    /// <returns>A string</returns>
    public static string CaseInsenstiveReplace(string originalString, string oldValue, string newValue)
    {
        Regex regEx = new Regex(oldValue,
           RegexOptions.IgnoreCase | RegexOptions.Multiline);
        return regEx.Replace(originalString, newValue);
    }

Cfeduke'nin cevabından esinlenerek, dizedeki eski değeri bulmak için IndexOf'u kullanan ve daha sonra yeni değerle değiştiren bu işlevi yaptım. Milyonlarca satır işleme bir SSIS komut dosyasında kullandım ve regex yöntemi bundan çok daha yavaştı.

public static string ReplaceCaseInsensitive(this string str, string oldValue, string newValue)
{
    int prevPos = 0;
    string retval = str;
    // find the first occurence of oldValue
    int pos = retval.IndexOf(oldValue, StringComparison.InvariantCultureIgnoreCase);

    while (pos > -1)
    {
        // remove oldValue from the string
        retval = retval.Remove(pos, oldValue.Length);

        // insert newValue in it's place
        retval = retval.Insert(pos, newValue);

        // check if oldValue is found further down
        prevPos = pos + newValue.Length;
        pos = retval.IndexOf(oldValue, prevPos, StringComparison.InvariantCultureIgnoreCase);
    }

    return retval;
}

Üzerine Genişleyen C. Dragon'un 76 bir uzantısı aşırı varsayılan içine onun kodunu yaparak 'nin sevilen cevap Replaceyöntemi.

public static class StringExtensions
{
    public static string Replace(this string str, string oldValue, string newValue, StringComparison comparison)
    {
        StringBuilder sb = new StringBuilder();

        int previousIndex = 0;
        int index = str.IndexOf(oldValue, comparison);
        while (index != -1)
        {
            sb.Append(str.Substring(previousIndex, index - previousIndex));
            sb.Append(newValue);
            index += oldValue.Length;

            previousIndex = index;
            index = str.IndexOf(oldValue, index, comparison);
        }
        sb.Append(str.Substring(previousIndex));
        return sb.ToString();
     }
}

Jeff Reddy'in cevabına dayanarak, bazı optimizasyonlar ve onaylamalar ile:

public static string Replace(string str, string oldValue, string newValue, StringComparison comparison)
{
    if (oldValue == null)
        throw new ArgumentNullException("oldValue");
    if (oldValue.Length == 0)
        throw new ArgumentException("String cannot be of zero length.", "oldValue");

    StringBuilder sb = null;

    int startIndex = 0;
    int foundIndex = str.IndexOf(oldValue, comparison);
    while (foundIndex != -1)
    {
        if (sb == null)
            sb = new StringBuilder(str.Length + (newValue != null ? Math.Max(0, 5 * (newValue.Length - oldValue.Length)) : 0));
        sb.Append(str, startIndex, foundIndex - startIndex);
        sb.Append(newValue);

        startIndex = foundIndex + oldValue.Length;
        foundIndex = str.IndexOf(oldValue, startIndex, comparison);
    }

    if (startIndex == 0)
        return str;
    sb.Append(str, startIndex, str.Length - startIndex);
    return sb.ToString();
}

C. Dragon's'a benzer bir sürüm, ancak yalnızca tek bir yedeklemeye ihtiyacınız varsa:

int n = myText.IndexOf(oldValue, System.StringComparison.InvariantCultureIgnoreCase);
if (n >= 0)
{
    myText = myText.Substring(0, n)
        + newValue
        + myText.Substring(n + oldValue.Length);
}

Regex değişikliklerini yürütmek için başka bir seçenek de var, çünkü pek çok kişi eşleşmelerin dize içindeki konumu içerdiğini fark ediyor gibi görünmüyor:

    public static string ReplaceCaseInsensative( this string s, string oldValue, string newValue ) {
        var sb = new StringBuilder(s);
        int offset = oldValue.Length - newValue.Length;
        int matchNo = 0;
        foreach (Match match in Regex.Matches(s, Regex.Escape(oldValue), RegexOptions.IgnoreCase))
        {
            sb.Remove(match.Index - (offset * matchNo), match.Length).Insert(match.Index - (offset * matchNo), newValue);
            matchNo++;
        }
        return sb.ToString();
    }

Regex.Replace(strInput, strToken.Replace("$", "[$]"), strReplaceWith, RegexOptions.IgnoreCase);

Normal ifade yöntemi çalışmalıdır. Bununla birlikte, veritabanından gelen dizeyi küçük harf, sahip olduğunuz% değişkenlerin% yüzdesini küçük harfle yapmak ve sonra veritabanından alt kasalı dizgideki konumları ve uzunlukları bulmaktır. Unutmayın, bir dizgideki konumlar sadece alt kasası nedeniyle değişmez.

Daha sonra ters giden bir döngü kullanarak (eğer daha kolay, eğer daha sonraki noktaların nereye taşınacağı konusunda çalışan bir sayı tutmak zorunda kalacaksınız) alt kasa olmayan dizenizden% değişkenleri% konumlarından veritabanından kaldırın ve uzunluk ve değiştirme değerleri girin.

(Çünkü herkes buna ateş ediyor). İşte benim sürümüm (boş denetimler, doğru giriş ve değiştirme çıkışıyla) ** İnternet ve diğer sürümlerden esinlenildi:

using System;
using System.Text.RegularExpressions;

public static class MyExtensions {
    public static string ReplaceIgnoreCase(this string search, string find, string replace) {
        return Regex.Replace(search ?? "", Regex.Escape(find ?? ""), (replace ?? "").Replace("$", "$$"), RegexOptions.IgnoreCase);          
    }
}

Kullanımı:

var result = "This is a test".ReplaceIgnoreCase("IS", "was");

Davamı yapmama izin verin ve sonra beni dilerseniz parçalara ayırabilirsiniz.

Regex bu sorunun cevabı değildir - nispeten yavaş ve çok aç ve hafıza aç.

StringBuilder, string mangling'den çok daha iyidir.

Bu, ek bir uzantı yöntemi olacağından string.Replace, bunun nasıl çalıştığını eşleştirmenin önemli olduğuna inanıyorum - bu nedenle, aynı argüman sorunları için istisnalar atmak, bir değiştirme yapılmadıysa orijinal dizeyi döndürmek kadar önemlidir.

Bir StringComparison parametresi olması iyi bir fikir olmadığına inanıyorum. Ben denedim ama michael-liu tarafından belirtilen test durumda bir sorun gösterdi: -

[TestCase("œ", "oe", "", StringComparison.InvariantCultureIgnoreCase, Result = "")]

IndexOf eşleşirken, kaynak dizgideki (1) eşleşmenin uzunluğu ile oldValue.Length (2) arasında bir uyumsuzluk vardır. Bu, oldValue.Length geçerli eşleme konumuna eklendiğinde bazı diğer çözümlerde IndexOutOfRange'a neden olarak kendini gösterdi ve bunun etrafında bir yol bulamadım. Regex yine de davaya uymuyor, bu yüzden sadece çözümüm için kullanmanın pragmatik çözümünü StringComparison.OrdinalIgnoreCasealdım.

Kodum diğer cevaplara benzer, ancak benim büküm bir oluşturma sorunu gitmeden önce bir maç aramak olduğunu StringBuilder. Hiçbiri bulunmazsa, potansiyel olarak büyük bir ayırmadan kaçınılır. Kod daha sonra do{...}whilebirwhile{...}

Diğer Yanıtlara karşı bazı kapsamlı testler yaptım ve bu fraksiyonel olarak daha hızlı çıktı ve biraz daha az bellek kullandı.

    public static string ReplaceCaseInsensitive(this string str, string oldValue, string newValue)
    {
        if (str == null) throw new ArgumentNullException(nameof(str));
        if (oldValue == null) throw new ArgumentNullException(nameof(oldValue));
        if (oldValue.Length == 0) throw new ArgumentException("String cannot be of zero length.", nameof(oldValue));

        var position = str.IndexOf(oldValue, 0, StringComparison.OrdinalIgnoreCase);
        if (position == -1) return str;

        var sb = new StringBuilder(str.Length);

        var lastPosition = 0;

        do
        {
            sb.Append(str, lastPosition, position - lastPosition);

            sb.Append(newValue);

        } while ((position = str.IndexOf(oldValue, lastPosition = position + oldValue.Length, StringComparison.OrdinalIgnoreCase)) != -1);

        sb.Append(str, lastPosition, str.Length - lastPosition);

        return sb.ToString();
    }