Thay thế nhiều phần tử chuỗi trong C #

Có cách nào tốt hơn để làm điều này ...

MyString.Trim().Replace("&", "and").Replace(",", "").Replace("  ", " ")
         .Replace(" ", "-").Replace("'", "").Replace("/", "").ToLower();

Tôi đã mở rộng lớp chuỗi để giữ cho nó thành một công việc nhưng có cách nào nhanh hơn không?

public static class StringExtension
{
    public static string clean(this string s)
    {
        return s.Replace("&", "and").Replace(",", "").Replace("  ", " ")
                .Replace(" ", "-").Replace("'", "").Replace(".", "")
                .Replace("eacute;", "é").ToLower();
    }
}

Chỉ để giải trí (và để dừng các tranh luận trong các bình luận) Tôi đã đưa ra một ý chính về điểm chuẩn cho các ví dụ khác nhau bên dưới.

https://gist.github.com/ChrisMcKee/5937656

Tùy chọn regex đạt điểm khủng khiếp; tùy chọn từ điển xuất hiện nhanh nhất; phiên bản dài hạn của trình thay thế stringbuilder nhanh hơn một chút so với phiên bản ngắn.

Nhanh hơn - không. Hiệu quả hơn - có, nếu bạn sẽ sử dụng StringBuilderlớp học. Với việc triển khai của bạn, mỗi thao tác sẽ tạo ra một bản sao của một chuỗi mà trong các trường hợp có thể làm giảm hiệu suất. Chuỗi là các đối tượng bất biến nên mỗi thao tác chỉ trả về một bản sao đã sửa đổi.

Nếu bạn mong đợi phương thức này sẽ được gọi chủ động trên bội Stringssố có độ dài đáng kể, có thể tốt hơn là "chuyển" việc triển khai của nó vào StringBuilderlớp. Với nó, bất kỳ sửa đổi nào được thực hiện trực tiếp trên phiên bản đó, vì vậy bạn không cần phải thực hiện các thao tác sao chép không cần thiết.

public static class StringExtention
{
    public static string clean(this string s)
    {
        StringBuilder sb = new StringBuilder (s);

        sb.Replace("&", "and");
        sb.Replace(",", "");
        sb.Replace("  ", " ");
        sb.Replace(" ", "-");
        sb.Replace("'", "");
        sb.Replace(".", "");
        sb.Replace("eacute;", "é");

        return sb.ToString().ToLower();
    }
}

điều này sẽ hiệu quả hơn:

public static class StringExtension
{
    public static string clean(this string s)
    {
        return new StringBuilder(s)
              .Replace("&", "and")
              .Replace(",", "")
              .Replace("  ", " ")
              .Replace(" ", "-")
              .Replace("'", "")
              .Replace(".", "")
              .Replace("eacute;", "é")
              .ToString()
              .ToLower();
    }
}

Nếu bạn chỉ đơn giản là theo đuổi một giải pháp tốt và không cần tiết kiệm vài nano giây, vậy còn một số đường LINQ thì sao?

var input = "test1test2test3";
var replacements = new Dictionary<string, string> { { "1", "*" }, { "2", "_" }, { "3", "&" } };

var output = replacements.Aggregate(input, (current, replacement) => current.Replace(replacement.Key, replacement.Value));

Có lẽ dễ đọc hơn một chút?

    public static class StringExtension {

        private static Dictionary<string, string> _replacements = new Dictionary<string, string>();

        static StringExtension() {
            _replacements["&"] = "and";
            _replacements[","] = "";
            _replacements["  "] = " ";
            // etc...
        }

        public static string clean(this string s) {
            foreach (string to_replace in _replacements.Keys) {
                s = s.Replace(to_replace, _replacements[to_replace]);
            }
            return s;
        }
    }

Cũng thêm đề xuất của New In Town về StringBuilder ...

Có một thứ có thể được tối ưu hóa trong các giải pháp được đề xuất. Có nhiều lệnh gọi để Replace()làm cho mã thực hiện nhiều lần chuyển trên cùng một chuỗi. Với các chuỗi rất dài, các giải pháp có thể chậm do dung lượng bộ nhớ cache của CPU bị thiếu. Có thể là một người nên xem xét thay thế nhiều chuỗi trong một lần vượt qua .

Một tùy chọn khác sử dụng linq là

[TestMethod]
public void Test()
{
  var input = "it's worth a lot of money, if you can find a buyer.";
  var expected = "its worth a lot of money if you can find a buyer";
  var removeList = new string[] { ".", ",", "'" };
  var result = input;

  removeList.ToList().ForEach(o => result = result.Replace(o, string.Empty));

  Assert.AreEqual(expected, result);
}

Tôi đang làm điều gì đó tương tự, nhưng trong trường hợp của tôi, tôi đang thực hiện tuần tự hóa / De-serialization, vì vậy tôi cần có thể đi cả hai hướng. Tôi thấy việc sử dụng chuỗi [] [] hoạt động gần giống với từ điển, bao gồm cả việc khởi tạo, nhưng bạn cũng có thể đi theo hướng khác, trả các chuỗi thay thế về giá trị ban đầu của chúng, điều mà từ điển thực sự không được thiết lập để làm.

Chỉnh sửa: Bạn có thể sử dụng Dictionary<Key,List<Values>>để nhận được kết quả giống như chuỗi [] []

string input = "it's worth a lot of money, if you can find a buyer.";
for (dynamic i = 0, repl = new string[,] { { "'", "''" }, { "money", "$" }, { "find", "locate" } }; i < repl.Length / 2; i++) {
    input = input.Replace(repl[i, 0], repl[i, 1]);
}