Làm thế nào để sử dụng Câu lệnh C # Switch Statement

Nếu tôi có một câu lệnh switch-case trong đó đối tượng trong switch là chuỗi, thì có thể thực hiện một phép so sánh ignoreCase không?

Tôi có ví dụ:

string s = "house";
switch (s)
{
  case "houSe": s = "window";
}

Sẽ snhận được giá trị "cửa sổ"? Làm cách nào để ghi đè câu lệnh switch-case để nó so sánh các chuỗi bằng cách sử dụng ignoreCase?

Như bạn đã biết, viết thường hai chuỗi và so sánh chúng không giống như thực hiện so sánh chữ hoa và chữ thường. Có rất nhiều lý do cho điều này. Ví dụ, tiêu chuẩn Unicode cho phép văn bản có dấu được mã hóa theo nhiều cách. Một số ký tự bao gồm cả ký tự cơ sở và dấu phụ trong một điểm mã. Các ký tự này cũng có thể được biểu diễn dưới dạng ký tự cơ sở theo sau là ký tự dấu phụ kết hợp. Hai cách đại diện này ngang nhau cho tất cả các mục đích và các so sánh chuỗi nhận biết văn hóa trong .NET Framework sẽ xác định chính xác chúng là bằng nhau, với CurrentCulture hoặc InvariantCulture (có hoặc không có lờ mờ). Mặt khác, so sánh theo thứ tự sẽ không chính xác coi chúng là không bình đẳng.

Thật không may, switchkhông làm bất cứ điều gì ngoài một so sánh thứ tự. So sánh thứ tự là tốt cho một số loại ứng dụng, chẳng hạn như phân tích cú pháp tệp ASCII với các mã được xác định chặt chẽ, nhưng so sánh chuỗi thứ tự là sai đối với hầu hết các mục đích sử dụng khác.

Những gì tôi đã làm trong quá khứ để có được hành vi chính xác chỉ là mô phỏng tuyên bố chuyển đổi của chính tôi. Có rất nhiều cách để làm điều này. Một cách sẽ là tạo một List<T>cặp chuỗi trường hợp và đại biểu. Danh sách có thể được tìm kiếm bằng cách so sánh chuỗi thích hợp. Khi kết quả phù hợp được tìm thấy thì đại biểu được liên kết có thể được gọi.

Một lựa chọn khác là thực hiện chuỗi ifcâu lệnh rõ ràng . Điều này thường hóa ra không quá tệ vì cấu trúc này rất đều đặn.

Điều tuyệt vời về điều này là thực sự không có bất kỳ hình phạt hiệu suất nào trong việc chế nhạo chức năng chuyển đổi của riêng bạn khi so sánh với các chuỗi. Hệ thống sẽ không tạo bảng nhảy O (1) theo cách mà nó có thể làm với các số nguyên, vì vậy dù sao thì nó cũng sẽ so sánh từng chuỗi một.

Nếu có nhiều trường hợp cần so sánh và hiệu suất là một vấn đề, thì List<T>tùy chọn được mô tả ở trên có thể được thay thế bằng từ điển được sắp xếp hoặc bảng băm. Khi đó, hiệu suất có thể khớp hoặc vượt quá tùy chọn câu lệnh chuyển đổi.

Dưới đây là một ví dụ về danh sách các đại biểu:

delegate void CustomSwitchDestination();
List<KeyValuePair<string, CustomSwitchDestination>> customSwitchList;
CustomSwitchDestination defaultSwitchDestination = new CustomSwitchDestination(NoMatchFound);
void CustomSwitch(string value)
{
    foreach (var switchOption in customSwitchList)
        if (switchOption.Key.Equals(value, StringComparison.InvariantCultureIgnoreCase))
        {
            switchOption.Value.Invoke();
            return;
        }
    defaultSwitchDestination.Invoke();
}

Tất nhiên, bạn có thể sẽ muốn thêm một số tham số tiêu chuẩn và có thể là kiểu trả về cho đại biểu CustomSwitchDestination. Và bạn sẽ muốn tạo ra những cái tên hay hơn!

Nếu hành vi của mỗi trường hợp của bạn không thể ủy quyền lệnh gọi theo cách này, chẳng hạn như nếu các thông số khác nhau là cần thiết, thì bạn đang mắc kẹt với các trạng thái bị xích if. Tôi cũng đã làm điều này một vài lần.

    if (s.Equals("house", StringComparison.InvariantCultureIgnoreCase))
    {
        s = "window";
    }
    else if (s.Equals("business", StringComparison.InvariantCultureIgnoreCase))
    {
        s = "really big window";
    }
    else if (s.Equals("school", StringComparison.InvariantCultureIgnoreCase))
    {
        s = "broken window";
    }

Một cách tiếp cận đơn giản hơn chỉ là viết thường chuỗi của bạn trước khi nó đi vào câu lệnh switch và đặt các trường hợp thấp hơn.

Trên thực tế, phần trên tốt hơn một chút từ quan điểm hiệu suất nano giây thuần túy, nhưng nhìn kém tự nhiên hơn.

Ví dụ:

string s = "house"; 
switch (s.ToLower()) { 
  case "house": 
    s = "window"; 
    break;
}

Xin lỗi vì bài viết mới này cho một câu hỏi cũ, nhưng có một tùy chọn mới để giải quyết vấn đề này bằng cách sử dụng C # 7 (VS 2017).

C # 7 hiện cung cấp "đối sánh mẫu" và nó có thể được sử dụng để giải quyết vấn đề này do đó:

string houseName = "house";  // value to be tested, ignoring case
string windowName;   // switch block will set value here

switch (true)
{
    case bool b when houseName.Equals("MyHouse", StringComparison.InvariantCultureIgnoreCase): 
        windowName = "MyWindow";
        break;
    case bool b when houseName.Equals("YourHouse", StringComparison.InvariantCultureIgnoreCase): 
        windowName = "YourWindow";
        break;
    case bool b when houseName.Equals("House", StringComparison.InvariantCultureIgnoreCase): 
        windowName = "Window";
        break;
    default:
        windowName = null;
        break;
}

Giải pháp này cũng giải quyết vấn đề được đề cập trong câu trả lời của @Jeffrey L Whitledge rằng so sánh phân biệt chữ hoa chữ thường của các chuỗi không giống như so sánh hai chuỗi có chữ thường.

Nhân tiện, có một bài báo thú vị vào tháng 2 năm 2017 trên Tạp chí Visual Studio mô tả việc đối sánh mẫu và cách nó có thể được sử dụng trong các khối trường hợp. Vui lòng xem: Khớp mẫu trong Khối trường hợp C # 7.0

BIÊN TẬP

Dựa trên câu trả lời của @ LewisM, điều quan trọng là chỉ ra rằng switchtuyên bố có một số hành vi mới, thú vị. Đó là nếu casecâu lệnh của bạn chứa một khai báo biến, thì giá trị được chỉ định trong switchphần sẽ được sao chép vào biến được khai báo trong case. Trong ví dụ sau, giá trị trueđược sao chép vào biến cục bộ b. Hơn nữa, biến bkhông được sử dụng và chỉ tồn tại để whenmệnh đề của casecâu lệnh có thể tồn tại:

switch(true)
{
    case bool b when houseName.Equals("X", StringComparison.InvariantCultureIgnoreCase):
        windowName = "X-Window";):
        break;
}

Như @LewisM đã chỉ ra, điều này có thể được sử dụng để mang lại lợi ích - lợi ích đó là thứ được so sánh thực sự có trong switchcâu lệnh, giống như cách sử dụng cổ điển của switchcâu lệnh. Ngoài ra, các giá trị tạm thời được khai báo trong casecâu lệnh có thể ngăn chặn các thay đổi không mong muốn hoặc vô tình đối với giá trị ban đầu:

switch(houseName)
{
    case string hn when hn.Equals("X", StringComparison.InvariantCultureIgnoreCase):
        windowName = "X-Window";
        break;
}

Trong một số trường hợp, bạn có thể sử dụng enum. Vì vậy, trước tiên hãy phân tích cú pháp enum (với cờ ignoreCase true) và hơn là có một công tắc trên enum.

SampleEnum Result;
bool Success = SampleEnum.TryParse(inputText, true, out Result);
if(!Success){
     //value was not in the enum values
}else{
   switch (Result) {
      case SampleEnum.Value1:
      break;
      case SampleEnum.Value2:
      break;
      default:
      //do default behaviour
      break;
   }
}

Phần mở rộng cho câu trả lời của @STLDeveloperA. Một cách mới để thực hiện đánh giá câu lệnh mà không có nhiều câu lệnh if kể từ c # 7 là sử dụng câu lệnh Switch đối sánh mẫu, tương tự như cách @STLDeveloper mặc dù cách này đang bật biến được chuyển

string houseName = "house";  // value to be tested
string s;
switch (houseName)
{
    case var name when string.Equals(name, "Bungalow", StringComparison.InvariantCultureIgnoreCase): 
        s = "Single glazed";
    break;

    case var name when string.Equals(name, "Church", StringComparison.InvariantCultureIgnoreCase):
        s = "Stained glass";
        break;
        ...
    default:
        s = "No windows (cold or dark)";
        break;
}

Tạp chí studio trực quan có một bài viết hay về các khối hộp ghép mẫu có thể đáng xem.

Một cách khả thi là sử dụng từ điển trường hợp bỏ qua với một đại diện hành động.

string s = null;
var dic = new Dictionary<string, Action>(StringComparer.CurrentCultureIgnoreCase)
{
    {"house",  () => s = "window"},
    {"house2", () => s = "window2"}
};

dic["HouSe"]();

// Lưu ý rằng lệnh gọi không trả về văn bản mà chỉ điền biến cục bộ s.
// Nếu bạn muốn trả về văn bản thực, hãy thay thế Actionthành Func<string>và các giá trị trong từ điển thành một cái gì đó như() => "window2"

Đây là giải pháp kết hợp giải pháp của @Magnus trong một lớp:

public class SwitchCaseIndependent : IEnumerable<KeyValuePair<string, Action>>
{
    private readonly Dictionary<string, Action> _cases = new Dictionary<string, Action>(StringComparer.OrdinalIgnoreCase);

    public void Add(string theCase, Action theResult)
    {
        _cases.Add(theCase, theResult);
    }

    public Action this[string whichCase]
    {
        get
        {
            if (!_cases.ContainsKey(whichCase))
            {
                throw new ArgumentException($"Error in SwitchCaseIndependent, \"{whichCase}\" is not a valid option");
            }
            //otherwise
            return _cases[whichCase];
        }
    }

    public IEnumerator<KeyValuePair<string, Action>> GetEnumerator()
    {
        return _cases.GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return _cases.GetEnumerator();
    }
}

Dưới đây là một ví dụ về việc sử dụng nó trong một ứng dụng Windows Form đơn giản:

   var mySwitch = new SwitchCaseIndependent
   {
       {"hello", () => MessageBox.Show("hello")},
       {"Goodbye", () => MessageBox.Show("Goodbye")},
       {"SoLong", () => MessageBox.Show("SoLong")},
   };
   mySwitch["HELLO"]();

Nếu bạn sử dụng lambdas (như ví dụ), bạn sẽ nhận được các bao đóng sẽ nắm bắt các biến cục bộ của bạn (khá gần với cảm giác bạn nhận được từ một câu lệnh switch).

Vì nó sử dụng một Từ điển dưới vỏ bọc, nó có hành vi O (1) và không dựa vào việc xem qua danh sách các chuỗi. Tất nhiên, bạn cần phải xây dựng từ điển đó, và điều đó có thể tốn nhiều tiền hơn.

Có lẽ sẽ có ý nghĩa nếu thêm một bool ContainsCase(string aCase)phương thức đơn giản gọi ContainsKeyphương thức của từ điển .

Tôi hy vọng điều này sẽ giúp cố gắng chuyển đổi toàn bộ chuỗi thành trường hợp cụ thể hoặc chữ thường hoặc chữ hoa và sử dụng chuỗi chữ thường để so sánh:

public string ConvertMeasurements(string unitType, string value)
{
    switch (unitType.ToLower())
    {
        case "mmol/l": return (Double.Parse(value) * 0.0555).ToString();
        case "mg/dl": return (double.Parse(value) * 18.0182).ToString();
    }
}

Cần đủ để làm điều này:

string s = "houSe";
switch (s.ToLowerInvariant())
{
  case "house": s = "window";
  break;
}

Sự so sánh chuyển đổi do đó văn hóa bất biến. Theo như tôi có thể thấy, điều này sẽ đạt được kết quả tương tự như các giải pháp Đối sánh mẫu C # 7, nhưng ngắn gọn hơn.