✨ Shield now has support for Avalonia UI

C# String Interview Questions and Answers

May 19, 2023 | .NET, C#

Whether you are a developer preparing for an upcoming job interview or a hiring manager seeking to explore your candidates’ in-depth knowledge, string interview questions in C# are essential for assessing how well someone understands the intricacies of strings in the .NET world.

From basic string manipulation to advanced concepts like Unicode and encoding, our collection of string programs in C# for interview covers a wide spectrum of topics that cater to developers of varying expertise.

So, let’s dive into the world of C# string manipulation interview questions and learn the finer details of tackling string-related challenges in C#.


What is the difference between the System.String and System.Text.StringBuilder classes in C#, and when would you recommend using one over the other?


System.String and System.Text.StringBuilder are two classes in C# used to work with strings. They have some key differences:

  • Immutable vs Mutable: System.String is an immutable class, which means that once a string object is created, its content cannot be changed. Any modification to a System.String object creates a new string. System.Text.StringBuilder, on the other hand, is a mutable class, allowing you to modify the contents of the object without creating new instances.
  • Performance: Due to the immutable nature of System.String, modifying strings repeatedly can create a performance overhead and increased memory usage, as new string instances have to be created each time the string changes. System.Text.StringBuilder is more performant when you need to modify strings frequently since it does not need to create new instances for every change.


  • Use System.String for short strings, when the string is not modified frequently or when the changes to the string are simple (e.g., concatenating a few strings).
  • Use System.Text.StringBuilder for longer strings or when the string undergoes frequent modifications (e.g., in a loop), to avoid the additional overhead of creating new string instances.

In C#, what are the potential performance implications of using the ‘+’ operator to concatenate strings in a loop? How can you avoid these issues?


In C#, using the + operator to concatenate strings in a loop is not recommended due to the following performance implications:

  • Memory overhead: Since the System.String class is immutable, concatenating strings using the + operator creates a new string instance for every operation. This leads to a significant memory overhead when concatenating strings inside a loop.
  • Garbage collection: The short-lived intermediate string instances created during concatenation can increase pressure on the garbage collector (GC), potentially leading to performance issues.

To avoid these performance issues when concatenating strings in a loop, use the System.Text.StringBuilder class:

StringBuilder sb = new StringBuilder();
for (int i = 0; i < 100; i++)
    sb.Append("some string");
string result = sb.ToString();

The StringBuilder class is more efficient as it is mutable and allows you to build a string without creating new string instances for each concatenation.

Explain how C# implements string interning? What benefits does it provide, and are there any potential drawbacks?


In C#, string interning is a technique used to store a single instance of each distinct string value. This is done using a string intern pool, which is a data structure that stores each unique string instance.

When a new string is created, C# checks if an identical string already exists in the intern pool. If so, it returns a reference to the existing string instead of creating a new instance.

Benefits of string interning:

  • Memory efficiency: Interning reduces memory usage by storing only one instance of each distinct string value. This helps in scenarios where there are many duplicate string instances.
  • Faster equality comparison: Interned strings can be compared for equality by checking if their references are the same. This is faster than comparing the content of the strings character by character.

Drawbacks of string interning:

  • Overhead: Creating a new string has some overhead due to the need to check the string intern pool for existing instances.
  • Limitations: Not all strings are automatically interned in C#. For example, strings created using the + operator or dynamically created are not automatically interned.

To intern a string explicitly, you can use the String.Intern method:

string str1 = "hello";
string str2 = String.Intern(new String("hello".ToCharArray()));

In this case, str1 and str2 reference the same interned string instance.

How would you implement a custom string comparison method in C#, considering culture-specific rules and case-insensitivity?


To implement a custom string comparison method that takes culture-specific rules and case-insensitivity into account, you can use the CompareInfo class from the System.Globalization namespace:

  1. Get a CompareInfo instance for the specific culture you want to use for the comparison.
  2. Use the CompareInfo.Compare method with the ignore-case option.

Here’s an example of a custom case-insensitive, culture-specific string comparison method:

using System.Globalization;

public bool CustomStringEquals(string strA, string strB, CultureInfo culture)
    CompareInfo compareInfo = culture.CompareInfo;
    int comparisonResult = compareInfo.Compare(strA, strB, CompareOptions.IgnoreCase);
    return comparisonResult == 0;

You can then call the CustomStringEquals method, passing in the desired culture:

string strA = "café";
string strB = "Café";

CultureInfo cultureInfo = new CultureInfo("fr-FR");
bool areEqual = CustomStringEquals(strA, strB, cultureInfo); // Returns true

In this example, the CustomStringEquals method returns true when comparing “café” and “Café” using the French culture, as the comparison is case-insensitive and takes into account culture-specific rules.

What is an Encoding in C# and how does it relate to string manipulation? How would you convert a string to a specific Encoding (e.g., UTF-8)?


An Encoding in C# is an abstract class that represents a character encoding scheme for converting between char data and byte data. This class is used to encode System.String objects into byte arrays, and decode byte arrays into System.String objects.

The most common encoding schemes are UTF-8, UTF-16, and UTF-32, which are provided by the derived classes – UTF8Encoding, UnicodeEncoding, and UTF32Encoding in the System.Text namespace.

Encoding relates to string manipulation as it greatly impacts how strings are represented in binary form, which is crucial when saving or sending strings across different systems. It is essential to ensure that the correct encoding is used for both encoding and decoding to avoid data loss or corruption.

To convert a string to a specific encoding, such as UTF-8, you can use the Encoding class’s static UTF8 property. Here’s an example:

string input = "Hello, world!";
Encoding utf8Encoding = Encoding.UTF8;
byte[] encodedBytes = utf8Encoding.GetBytes(input); // Encode the string as a byte array using UTF-8

To decode the byte array back to a string:

string decodedString = utf8Encoding.GetString(encodedBytes); // Decode the byte array back to a string using UTF-8

Remember to always use the same encoding for both encoding and decoding the data.

As you can see, understanding how to convert and work with different encodings is an integral part of string manipulation in C#.

Now that we’ve discussed the fundamentals of handling encodings, let’s move on to exploring some of the more advanced concepts and scenarios that often arise in string-related interview questions in C#.

Describe how the C# string.GetHashCode() method works, and explain why comparing two strings using GetHashCode() is not reliable for determining string equality.


The string.GetHashCode() method in C# returns an int32 value that represents a hash code for the string object. It is designed to distribute similar strings to different hash codes as evenly as possible. This makes it ideal for use in hash-based collections, such as Dictionary<TKey, TValue> or HashSet<T>.

When comparing two strings using GetHashCode(), it is not reliable for determining string equality for the following reasons:

  1. Hash collisions: Different strings can have the same hash code. While hash functions try to minimize collisions, they are still possible, and two unequal strings might have the same hash code. Relying on GetHashCode() for equality checks could lead to false positives.
  2. Not intended for equality: The primary purpose of GetHashCode() is to provide a hash code for use in hash-based collections, not to check for exact equality between two strings or objects.

Instead of using GetHashCode(), use the string Equals method, == operator, or the string.Compare method to reliably determine if two strings are equal:

string strA = "hello";
string strB = "world";
bool areEqual = strA.Equals(strB); // Using string.Equals

In C#, explain how the StringComparer class can be used as an alternative to the built-in equality and comparison methods for strings. Provide an example.


The StringComparer class in C# is an implementation of the IComparer<string> and IEqualityComparer<string> interfaces, designed to handle string comparisons and equality checks by providing various options for customization.

It provides several pre-built comparers, which can be used in sorting operations, search algorithms, or with collections that require custom string comparison logic.

Examples of using StringComparer:

  • Case-insensitive comparison: Comparing strings without considering their case:
string[] words = { "Apple", "banana", "Cherry" };
Array.Sort(words, StringComparer.OrdinalIgnoreCase);

// The words array now contains: ["Apple", "banana", "Cherry"]
  • Culture-aware comparison: Comparing strings while taking culture-specific rules into account:
string[] words = { "apple", "banana", "cherry" };
CultureInfo culture = new CultureInfo("de-DE");
StringComparer comparer = StringComparer.Create(culture, ignoreCase: true);
Array.Sort(words, comparer);

// The words array now contains: ["apple", "banana", "cherry"]

By using the StringComparer class, you get more control over how strings are compared and sorted, making it easier to handle situations where the built-in string comparison and equality methods may not be sufficient.

How do you perform a Regular Expression match in a C# string and replace some matched content with new data? Provide a code example.


In C#, you can apply regular expressions using the Regex class from the System.Text.RegularExpressions namespace. To perform a regular expression match in a C# string and replace some matched content with new data, you can use the Regex.Replace method.

Here’s a code example that demonstrates how to perform a match and replace operation using a regular expression:

using System.Text.RegularExpressions;

string input = "Hello, my phone number is 123-456-7890";
string pattern = @"\d{3}-\d{3}-\d{4}";
string replacement = "(XXX) XXX-XXXX";

string result = Regex.Replace(input, pattern, replacement);
// result: "Hello, my phone number is (XXX) XXX-XXXX"

In this example, we use the Regex.Replace method to replace a phone number in the input string, matching the pattern \d{3}-\d{3}-\d{4} with the replacement string (XXX) XXX-XXXX. The result is a new string with the phone number obfuscated.

Explain the difference between string.IsNullOrEmpty() and string.IsNullOrWhiteSpace() methods in C#. Provide examples of when each would be appropriate to use.


string.IsNullOrEmpty() and string.IsNullOrWhiteSpace() are two static methods in C# that are used to determine if a string is empty or contains only whitespace characters.

  • string.IsNullOrEmpty(): This method checks if the given string is null or has a length of 0. It considers whitespace characters as valid content.

Example usage:

string input = "   ";
bool result = string.IsNullOrEmpty(input); // Returns false

In this example, string.IsNullOrEmpty() returns false because the input string contains whitespace characters, which are considered valid content.

You should use string.IsNullOrEmpty() when you only need to check if a string is null or empty but treat whitespace characters as valid.

  • string.IsNullOrWhiteSpace(): This method checks if the given string is null, has a length of 0, or contains only whitespace characters, such as spaces, tabs, or line breaks.

Example usage:

string input = "   ";
bool result = string.IsNullOrWhiteSpace(input); // Returns true

In this example, string.IsNullOrWhiteSpace() returns true because the input string contains only whitespace characters.

You should use string.IsNullOrWhiteSpace() when you need to check if a string is null, empty, or contains only whitespace characters.

Describe the ReadOnlyMemory and ReadOnlySpan data structures in C#. Explain their use cases and benefits when working with strings.


ReadOnlyMemory<char> and ReadOnlySpan<char> are data structures in C# that provide efficient ways to work with sequences of characters or substrings, without having to create new string instances.

  • ReadOnlyMemory: This structure represents a contiguous region of memory that contains a range of char data. It provides a safe, bounds-checked, non-copying view of a string’s characters. Important features of ReadOnlyMemory<char> include:
  • Slice operations on strings without allocating new memory.
  • Ability to use within asynchronous methods, as it is a struct that can be safely used across async boundaries.

Example usage:

string input = "Hello, world!";
ReadOnlyMemory<char> memory = input.AsMemory();
ReadOnlyMemory<char> slicedMemory = memory.Slice(0, 5);
string substring = slicedMemory.ToString(); // "Hello"
  • ReadOnlySpan: This structure is similar to ReadOnlyMemory<char> but can only be used on the stack, making it suitable for high-performance scenarios where reducing memory allocations is critical. It provides:
  • Slice operations on strings with minimal overhead.
  • Usage within synchronous methods, particularly in performance-critical scenarios.

Example usage:

string input = "Hello, world!";
ReadOnlySpan<char> span = input.AsSpan();
ReadOnlySpan<char> slicedSpan = span.Slice(0, 5);
string substring = slicedSpan.ToString(); // "Hello"

Use cases and benefits:

  • Efficiently working with substrings or character sequences.
  • Reducing memory allocations and copying during string manipulation.
  • Providing safe, bounds-checked, non-copying views on string data (particularly useful for high-performance scenarios).

We’ve covered the usage of ReadOnlyMemory and ReadOnlySpan data structures when working with strings in C#. These data structures bring efficiency and flexibility to string manipulation tasks.

Let’s delve further into string programming interview questions and explore pattern matching in C# strings, a common and powerful technique used in many real-world applications.

How would you implement KMP (Knuth-Morris-Pratt) algorithm for pattern matching in C# strings?


The Knuth-Morris-Pratt (KMP) algorithm is a pattern-matching algorithm that solves the problem of finding a substring within a longer text string efficiently by preprocessing the pattern and using information about previously matched characters.

Here’s a simple implementation of the KMP algorithm in C#:

public static int KMP(string text, string pattern)
    int textLength = text.Length;
    int patternLength = pattern.Length;
    int[] lps = ComputeLps(pattern);
    int i = 0, j = 0;

    while (i < textLength && j < patternLength)
        if (text[i] == pattern[j])
        else if (j > 0)
            j = lps[j - 1];

    if (j == patternLength)
        return i - patternLength;
        return -1;

private static int[] ComputeLps(string pattern)
    int length = pattern.Length;
    int[] lps = new int[length];
    int j = 1, l = 0;

    while (j < length)
        if (pattern[j] == pattern[l])
            lps[j] = l;
        else if (l > 0)
            l = lps[l - 1];
            lps[j] = 0;
    return lps;

To use the KMP algorithm to find an index of the first occurrence of a pattern in a text string:

string pattern = "ABABCABAB";

int matchedIndex = KMP(text, pattern);
Console.WriteLine(matchedIndex); // Output: 10

In this example, the KMP algorithm finds the first occurrence of pattern “ABABCABAB” at index 10 in the text “ABABDABACDABABCABAB”.

What is a format string attack? Explain how C# provides protection against format string attacks when working with strings, and provide an example of a potentially insecure code snippet.


A format string attack is a type of vulnerability that occurs when an application uses untrusted input as part of a format string in various methods like string.Format, Console.WriteLine, or interpolated strings. This allows an attacker to control the format string parameters, potentially causing data leaks, memory corruption, or code execution.

C# provides protection against format string attacks by ensuring that the format specifier syntax is well-defined and allowing you to explicitly define the format strings instead of working with untrusted user input directly.

However, if you use untrusted user input in your format string, you may still be vulnerable to format string attacks. Here is an example of a potentially insecure code snippet:

string userInput = Console.ReadLine(); // Untrusted user input
string value = "Secret Value";
string result = string.Format(userInput, value);

In this example, we use untrusted user input in the format string directly, which could lead to leaks of the value variable content or other memory content depending on the malicious format string provided by the attacker.

To protect against format string attacks, avoid using untrusted or unsanitized user input as a format string and always use trusted format strings when working with format specifiers.

For example, you could use a safe format string, where you control the format string and only reference the user input as part of the formatted data:

string userInput = Console.ReadLine(); // Untrusted user input
string safeFormatString = "User input: {0}";
string result = string.Format(safeFormatString, userInput);

In this case, the format string is controlled by you, and the user input is only used as a data value in the string.Format call, preventing format string attacks.

In C#, what is the purpose of string normalization, and how would you perform it using the System.Globalization namespace?


String normalization is the process of transforming different Unicode representations of a text string into a standard form, improving the consistency and accuracy of string comparisons and operations. There are several Unicode normalization forms: Normalization Form D (NFD), Normalization Form C (NFC), Normalization Form KD (NFKD), and Normalization Form KC (NFKC).

Each form defines specific rules by which Unicode characters are combined or decomposed to ensure a consistent representation.

In C#, you can perform string normalization using the System.Globalization namespace by invoking the Normalize method on a string object and providing a normalization form as the argument.

Example of string normalization using NFC:

using System.Globalization;

string input = "Cafe\u0301"; // "Cafe" with a separate acute accent (U+0301)
string normalized = input.Normalize(NormalizationForm.FormC); // "Café" with a combined 'e' and acute accent (U+00E9)

In this example, we normalize the input string containing a separate acute accent to a string with a combined ‘e’ and acute accent using the NFC normalization form.

Performing string normalization can be crucial when comparing or processing strings provided by different sources and ensuring that your application handles Unicode text consistently.

How would you implement a custom string fuzzy matching algorithm in C#? Provide a brief explanation, along with a code example demonstrating a simple implementation.


A custom string fuzzy matching algorithm provides a way to find similarities between strings even if they are not identical. One common fuzzy matching algorithm is the Levenshtein distance (also known as edit distance), which calculates the minimum number of single-character edits (insertions, deletions, or substitutions) required to transform one string into the other.

Here is a simple implementation of the Levenshtein distance algorithm in C#:

public static int LevenshteinDistance(string strA, string strB)
    int m = strA.Length;
    int n = strB.Length;

    int[,] d = new int[m + 1, n + 1];

    for (int i = 0; i <= m; i++) d[i, 0] = i;
    for (int j = 0; j <= n; j++) d[0, j] = j;

    for (int i = 1; i <= m; i++)
        for (int j = 1; j <= n; j++)
            int cost = (strA[i - 1] == strB[j - 1]) ? 0 : 1;
            d[i, j] = Math.Min(
                    d[i - 1, j] + 1, // Deletion
                    d[i, j - 1] + 1  // Insertion
                d[i - 1, j - 1] + cost // Substitution

    return d[m, n];

To use the Levenshtein distance to calculate the similarity between two strings, you can call the method like this:

string strA = "kitten";
string strB = "sitting";

int distance = LevenshteinDistance(strA, strB);
Console.WriteLine(distance); // Output: 3 (k -> s, i -> e, + g)

In this example, the Levenshtein distance between “kitten” and “sitting” is 3, meaning that three single-character edits are needed to transform “kitten” into “sitting”.

You can further expand this implementation and use normalized Levenshtein distance (the distance divided by the longest string length) or other similarity metrics like the Jaro-Winkler distance, depending on your fuzzy matching needs

Explain the difference between String.Format, $”{…}”, and interpolated string handlers (in C# 10), and discuss which scenarios would be most appropriate for each.


String.Format, $"{...}" (string interpolation), and interpolated string handlers are features in C# to compose formatted strings. They have some differences in terms of syntax, readability, and functionality.

  • String.Format: This is a static method that replaces placeholder tokens (such as {0}, {1}) within the format string with argument values passed to the method.
  • Less concise and less readable than string interpolation.
  • Good for situations where you need to use the same format string multiple times or need to store it separately from the formatting operation.

Example usage:

string message = string.Format("Hello, {0}! The temperature today is {1} degrees.", "John", 22);
Console.WriteLine(message); // Output: Hello, John! The temperature today is 22 degrees.
  • $”{…}” (string interpolation): Provides a more readable, concise syntax for substituting expressions directly into the string using curly braces {}.
  • More readable and concise than String.Format.
  • Perfect for simple, short string formatting and concatenation in most scenarios.

Example usage:

string name = "John";
int temperature = 22;
string message = $"Hello, {name}! The temperature today is {temperature} degrees.";
Console.WriteLine(message); // Output: Hello, John! The temperature today is 22 degrees.
  • Interpolated string handlers (C# 10): A new feature that allows custom handling of interpolated strings through custom builders. Enables more efficient string manipulation, avoiding unnecessary allocations and supporting additional features.
  • Same syntax as normal string interpolation but can be more efficient for frequently manipulated strings.
  • Recommended for scenarios that require high-performance string manipulation or custom behavior like logging, text localization, or templating.

Example usage (a simple custom handler for converting interpolated strings to uppercase):

string name = "John";
int temperature = 22;
string message = UppercaseHandler.Create($@"Hello, {name}! The temperature today is {temperature} degrees.");
Console.WriteLine(message); // Output: HELLO, JOHN! THE TEMPERATURE TODAY IS 22 DEGREES.

In summary, for most applications, using string interpolation ($"{...}") provides a more readable and concise way to format strings. However, for high-performance or custom scenarios, C# 10’s interpolated string handlers can provide additional benefits. If you need to reuse a format string multiple times or store it separately from the formatting operation, you can still use the String.Format method.

By now, you should have a deeper understanding of various string formatting techniques available in C#.

With that knowledge in hand, let’s dive into some C# string programs for interview that will expand your comprehension of character and string encodings, and how they affect string manipulation when working with multi-byte characters.

Describe the difference between character encoding and string encoding. How can these differences impact string manipulation when working with multi-byte characters in C#?


  • Character encoding: Character encoding is a system that assigns a unique code (usually a number) to each character in a given character set. Examples of character encodings are Unicode (UTF-8, UTF-16, UTF-32), ASCII, and ISO-8859-1. Character encoding defines how individual characters are represented in binary form.
  • String encoding: String encoding refers to the conversion of an entire System.String object or sequence of characters into a sequence of bytes, and the reverse conversion of a sequence of bytes into a string. In C#, the System.Text.Encoding abstract class and its derived classes (e.g., UTF8Encoding, UnicodeEncoding, UTF32Encoding) handle string encoding and decoding.

The main difference between character encoding and string encoding is that character encoding focuses on the mapping of individual characters to their binary representations, while string encoding deals with the process of converting an entire string or sequence of characters into a series of bytes.

When working with multi-byte characters in C#, the differences between character encoding and string encoding can impact string manipulation in several ways:

  • Memory usage: Multi-byte characters can increase memory usage, as they require more bytes to represent a single character than single-byte characters.
  • Indexing and slicing: Manipulating strings containing multi-byte characters can be challenging, as operations like indexing and slicing may not work as expected due to the variable byte length of characters.
  • Encoding and decoding: When converting between strings and byte arrays, using the correct string encoding is essential to preserving multi-byte characters, as using an incorrect or incompatible encoding can lead to data loss or corruption.

To handle multi-byte characters in C# properly, use the System.Text.Encoding class and its derived classes, like UTF8Encoding, when encoding and decoding strings, and be aware of the potential issues when performing string manipulation operations involving multi-byte characters.

How would you implement an extension method in C# that returns all indices of a substring within a given string?


An extension method in C# is a static method defined in a static class that appears to extend the functionality of an existing type, allowing you to call it as if it were an instance method of the type.

Here is an implementation of an extension method that returns all indices of a substring within a given string:

using System;
using System.Collections.Generic;

public static class StringExtensions
    public static List<int> AllIndicesOf(this string source, string substr, StringComparison comparison = StringComparison.CurrentCulture)
        List<int> indices = new List<int>();
        int index = 0;

        while ((index = source.IndexOf(substr, index, comparison)) != -1)
            index += substr.Length;

        return indices;

This extension method, AllIndicesOf, takes a source string, a substr to search for within the source, and an optional StringComparison parameter to specify the comparison method. It returns a list of all indices where the substring occurs in the source string.

Here’s an example of how to call this extension method:

string text = "The quick brown fox jumps over the brown dog.";
string searchString = "brown";

List<int> indices = text.AllIndicesOf(searchString);
Console.WriteLine(string.Join(", ", indices)); // Output: 10, 31

In this example, the AllIndicesOf extension method is called on the text string, searching for the substring “brown”. The method returns a list containing the indices 10 and 31, where “brown” appears in the source string.

Explain the differences between StringComparison.Ordinal, StringComparison.OrdinalIgnoreCase, StringComparison.CurrentCulture, and StringComparison.CurrentCultureIgnoreCase in C#. When should each be used?


StringComparison is an enumeration in C# defining different ways strings can be compared in methods like string.Compare, string.Equals, and string.IndexOf. The different StringComparison values result in different string comparison behavior in terms of case sensitivity and cultural rules for sorting and equivalency.

  • StringComparison.Ordinal: Compares strings based on the numeric values of their Unicode characters, resulting in a case-sensitive and culture-insensitive comparison.
  • Use when you need a high-performance, case-sensitive comparison that doesn’t take culture into account.
  • Suitable for comparing strings in internal data structures and ensuring case-sensitive uniqueness.
  • StringComparison.OrdinalIgnoreCase: Compares strings based on the numeric values of their Unicode characters, but performs a case-insensitive comparison.
  • Use when you need a high-performance, case-insensitive comparison that ignores culture-specific rules.
  • Good choice for comparing strings in file paths, resource identifiers, or any scenario where case doesn’t matter and culture-specific rules are not important.
  • StringComparison.CurrentCulture: Compares strings using the sorting and equivalency rules of the current thread’s culture. This comparison is case-sensitive and culture-sensitive.
  • Use when you need to compare strings for display purposes, sorting lists, or any scenario where the current culture’s rules should be honored.
  • Not suitable for security-sensitive comparisons or performance-critical operations.
  • StringComparison.CurrentCultureIgnoreCase: Compares strings using the sorting and equivalency rules of the current thread’s culture but performs a case-insensitive comparison.
  • Use when you need to compare strings for display purposes or sorting lists with case-insensitive behavior, considering the current culture’s rules.
  • Not suitable for security-sensitive comparisons or performance-critical operations.

Here’s an example of how to use different StringComparison options:

string strA = "Café";
string strB = "café";

Console.WriteLine(strA.Equals(strB, StringComparison.Ordinal)); // Output: False
Console.WriteLine(strA.Equals(strB, StringComparison.OrdinalIgnoreCase)); // Output: False
Console.WriteLine(strA.Equals(strB, StringComparison.CurrentCulture)); // Output: False
Console.WriteLine(strA.Equals(strB, StringComparison.CurrentCultureIgnoreCase)); // Output: True

In the example, we compare two strings that appear to be the same but have different capitalization. Using StringComparison.Ordinal or StringComparison.CurrentCulture results in a case-sensitive comparison, returning false.

Using StringComparison.OrdinalIgnoreCase or StringComparison.CurrentCultureIgnoreCase performs a case-insensitive comparison, and only StringComparison.CurrentCultureIgnoreCase returns true as it also considers culture-specific rules for equality.

How would you traverse and manipulate Unicode text in C# while considering its specific features (e.g., surrogate pairs, combining characters, and normalization)?


To traverse and manipulate Unicode text in C# effectively, you must consider Unicode’s specific features such as surrogate pairs, combining characters, and normalization.

  • Surrogate pairs: These are pairs of code units in the UTF-16 encoding that together represent a single Unicode character outside the basic multilingual plane (BMP). In .NET, a char is UTF-16 encoded, so each ‘character’ in a string is a UTF-16 code unit rather than a complete Unicode character. This can affect the handling of surrogate pairs when traversing or otherwise manipulating Unicode text.
  • Combining characters: Combining characters are Unicode characters that don’t have a standalone representation and are meant to be combined with another character to form a single typographic unit.
  • Normalization: Normalization is the process of converting Unicode text into a standard, canonical form for more accurate and consistent string comparisons and operations.

To traverse and manipulate Unicode text in C# effectively, consider the following guidelines:

  1. When looping through a string, instead of using a traditional for loop and indexing directly into the string, use a foreach loop that iterates over the char elements in the string. This automatically handles surrogate pairs.
string text = "𠈓Aé𝄞C"; // Contains a non-BMP character and combining characters

foreach (char ch in text)
    Console.Write($"{ch} ");
  1. When working with combining characters, normalize the string using the Normalize method provided by the System.String class. This ensures that each character is represented in the desired normalization form for better consistency and manipulation.
string input = "Cafe\u0301"; // "Cafe" with a separate acute accent
string normalized = input.Normalize(NormalizationForm.FormC); // "Café" with a combined 'e' and acute accent

foreach (char ch in normalized)
    Console.Write($"{ch} ");
  1. Be mindful of string manipulation methods that require direct indexing (e.g., Substring, Remove, etc.) as they can lead to incorrect results for strings containing surrogate pairs.
string text = "A𠈓C"; // Contains a non-BMP character
string substring = text.Substring(1, 1); // Incorrect, splits a surrogate pair

When necessary, use System.Globalization.StringInfo methods, such as LengthInTextElements, SubstringByTextElements, and GetNextTextElement, to work with text elements instead of individual chars.

using System.Globalization;

string text = "A𠈓C";
StringInfo si = new StringInfo(text);
int length = si.LengthInTextElements; // Correct: 3

string substring = si.SubstringByTextElements(1, 1); // Correct: "𠈓"

By following these guidelines when traversing and manipulating Unicode text in C#, you can address the specific features of Unicode and ensure proper handling of non-BMP characters, combining characters, and surrogate pairs.

What is the purpose of the StringComparison enumeration and how can it be used to customize string comparison and sorting in C#? Provide example scenarios for different StringComparison options.


The purpose of the StringComparison enumeration in C# is to provide various options to control how string comparison operations are performed with respect to case-sensitivity or culture-specific rules.

The StringComparison enumeration is used as an argument in string comparison and sorting methods, such as string.Compare, string.Equals, string.IndexOf, string.LastIndexOf, Array.Sort, and List.Sort.

Different StringComparison options and their use cases are listed below:

  • StringComparison.Ordinal: Represents a case-sensitive, culture-insensitive string comparison. It compares strings based on the numeric values of their Unicode characters.
    • Use for high-performance string comparisons where case sensitivity and culture must be taken into account.
    • Examples: String comparison in internal data structures, case-sensitive uniqueness checks.
  • StringComparison.OrdinalIgnoreCase: Represents a case-insensitive, culture-insensitive string comparison. It compares strings based on a case-insensitive comparison of their Unicode character numeric values.
    • Use for high-performance string comparisons where case sensitivity is not essential, and culture-specific rules are not needed.
    • Examples: File path comparisons, resource identifier comparisons.
  • StringComparison.CurrentCulture: Represents a case-sensitive, culture-sensitive string comparison. It compares strings using the sorting and equivalency rules of the current thread’s culture.
    • Use for string comparisons intended for display purposes or when cultural rules must be considered.
    • Examples: Sorting display lists of strings, user input validation.
  • StringComparison.CurrentCultureIgnoreCase: Represents a case-insensitive, culture-sensitive string comparison. It compares strings using the case-insensitive sorting and equivalency rules of the current thread’s culture.
    • Use for case-insensitive string comparisons where cultural rules must be considered.
    • Examples: Case-insensitive user input validation, sorting display lists of strings without regard to case.

Using the appropriate StringComparison option in string comparison and sorting operations ensures that your code behaves as expected based on the specific rules for case sensitivity and culture.

Examples of using different StringComparison options:

// StringComparison.Ordinal: Case-sensitive and culture-insensitive comparison
string compareResultOrdinal = string.Compare("Café", "cafe", StringComparison.Ordinal) > 0 ? "greater" : "not greater";
Console.WriteLine(compareResultOrdinal); // Output: not greater

// StringComparison.CurrentCulture: Case-sensitive and culture-sensitive comparison
string compareResultCurrentCulture = string.Compare("Café", "cafe", StringComparison.CurrentCulture) > 0 ? "greater" : "not greater";
Console.WriteLine(compareResultCurrentCulture); // Output: greater

// StringComparison.OrdinalIgnoreCase: Case-insensitive and culture-insensitive comparison
bool equalsResultOrdinal = string.Equals("Café", "CAFE", StringComparison.OrdinalIgnoreCase);
Console.WriteLine(equalsResultOrdinal); // Output: True

// StringComparison.CurrentCultureIgnoreCase: Case-insensitive and culture-sensitive comparison
bool equalsResultCurrentCulture = string.Equals("Café", "CAFE", StringComparison.CurrentCultureIgnoreCase);
Console.WriteLine(equalsResultCurrentCulture); // Output: True

In these examples, we can see how StringComparison options affect the outcomes of string comparison operations, demonstrating the importance of selecting the appropriate option for your specific use case.

We hope that this comprehensive collection of C# string manipulation interview questions has armed you with the knowledge and confidence to ace your next C# interview or to discern the right candidate for a job opportunity.

Demonstrating a strong grasp of the wide range of topics, from basic string operations to advanced Unicode handling and string programming techniques, will undoubtedly set you apart in the world of C# development.

Keep exploring, practicing, and challenging yourself with more C# string programs for interview to sharpen your skills and achieve success in your professional endeavors.

You May Also Like