The 30-Day .NET Challenge - Day 21: StringComparison

The article demonstrates the importance of using StringComparison options for efficient string comparison in .NET

Introduction

Whether it's searching, sorting, or equality, how you compare strings can significantly impact your application performance. The article demonstrates the importance of using StringComparison options for efficient string comparison in .NET

Learning Objectives

• The Problem with Inefficient String Comparisons
• Efficient String Comparison with StringComparison
• Choosing the Right StringComparison Option

Prerequisites for Developers

• Basic understanding of C# programming language.

30 Day .Net Challenge

Getting Started

The Problem with Inefficient String Comparisons

Consider the following common approach used by most developers for string comparison:

    // Inefficient string comparison
    bool equal = string1.ToLower() == string2.ToLower();

• The ToLower method creates a new string memory allocation for each comparison, leading to unnecessary allocations. Consider a method with frequent requests that can degrade the application performance.
• The ToLower method is culture-sensitive, which means it might produce different results depending on the current culture set in the executing thread.

Efficient String Comparison with StringComparison

.NET provides a powerful enumeration, StringComparison, designed to address these inefficiencies.

    // Efficient string comparison
    bool equal = string.Equals(string1, string2, StringComparison.OrdinalIgnoreCase);

The aforementioned addresses both of the problems in the old string comparison way.

• No Unnecessary Allocations
• Improved Performance

Choosing the Right StringComparison Option

• Ordinal: Use for most general-purpose comparisons where cultural rules are not relevant. This is the fastest option.
• OrdinalIgnoreCase: Ideal for case-insensitive comparisons where cultural rules do not apply.
• **CurrentCulture and CurrentCultureIgnoreCase: **Use when comparing strings displayed to the user, where adherence to cultural rules is important.
• InvariantCulture and InvariantCultureIgnoreCase: Suitable for scenarios requiring consistency across different cultures, such as storing and retrieving data.

Create another class named StringComparisons and add the following code snippet

    public static class StringComparisons
    {
        private static readonly string string1 = "test";
        private static readonly string string2 = "test";
        public static void BadMethod()
        {
            // Inefficient string comparison
            bool equal = string1.ToLower() == string2.ToLower();
            Console.WriteLine($"In bad method strings are {equal}");
        }
    
        public static void GoodMethod()
        {
            // efficient string comparison
            bool equal = string.Equals(string1, string2, System.StringComparison.OrdinalIgnoreCase);
            Console.WriteLine($"In good method strings are {equal}");
        }
    }

Execute from the main method as follows

    #region Day 21: String Comparisons
    static string ExecuteDay21()
    {
        StringComparisons.BadMethod();
        StringComparisons.GoodMethod();
    
        return "Executed Day 21 successfully..!!";
    }
    
    #endregion

Console output

    In bad method strings are True
    In good method strings are True

Complete Code on GitHub

GitHub — ssukhpinder/30DayChallenge.Net

C# Programming🚀

Thank you for being a part of the C# community! Before you leave:

Follow us: Youtube | X | LinkedIn | Dev.to Visit our other platforms: GitHub More content at C# Programming