Character Handling and Escape Sequences

In C#, the char type represents a single Unicode character. You can analyze and transform characters using static methods provided by the Char class. Additional, hnadling special characters in strings requires escape sequences or verbatim string literals.

using System;

public class CharExample
{
    public static void Run()
    {
        char letter = 'B';
        char digit = '7';

        // Character analysis
        Console.WriteLine($"Is '{letter}' a letter? {char.IsLetter(letter)}");
        Console.WriteLine($"Is '{digit}' a digit? {char.IsDigit(digit)}");
        
        // Case transformation
        Console.WriteLine($"Lowercase of '{letter}': {char.ToLower(letter)}");

        // Escape sequences vs Verbatim strings
        string regularPath = "C:\\Program Files\\MSBuild\\v15.0";
        string verbatimPath = @"C:\Program Files\MSBuild\v15.0";
        
        Console.WriteLine("NewLine Example:\nLine One\nLine Two");
        Console.WriteLine($"Path comparison: {regularPath == verbatimPath}");
    }
}

String Case Sensitivity and Comparisons

Strings are immutable sequences of characters. Comparing strings often requires handling case sensitivity, which can be achieved via the String.Compare method or specific equality methods.

using System;

public class StringComparison
{
    public static void Run()
    {
        string input = "Administrator";
        string target = "administrator";

        // Equality check (Case-sensitive)
        bool isEqual = input.Equals(target); 
        
        // Comparison with options (Case-insensitive)
        int compareResult = string.Compare(input, target, StringComparison.OrdinalIgnoreCase);

        Console.WriteLine($"Exact Match: {isEqual}"); // False
        Console.WriteLine($"Case-Insensitive Match: {compareResult == 0}"); // True
    }
}

Advanced String Formattnig

The string.Format method and string interpolation allow for precise control over how data is displayed, including currency, decimal precision, and padding.

using System;

public class FormattingExample
{
    public static void Run()
    {
        double price = 1250.75;
        int id = 42;

        // Currency and numeric formatting
        string formattedPrice = string.Format("Total: {0:C2}", price);
        string paddedId = string.Format("ID: {0:D5}", id);

        Console.WriteLine(formattedPrice); // e.g., $1,250.75
        Console.WriteLine(paddedId);       // ID: 00042

        // Percentage and Hexadecimal
        Console.WriteLine($"{0.85:P1}");   // 85.0%
        Console.WriteLine($"{255:X}");     // FF
    }
}

Extraction and Modification

C# provides robust methods for extracting parts of a string (Substring), splitting content based on delimiters (Split), and joining arrays into a single string (Join).

using System;

public class ManipulationExample
{
    public static void Run()
    {
        string rawData = "Development;C#;Expert;2023";
        
        // Splitting string into an array
        string[] parts = rawData.Split(';');
        
        // Substring and Case manipulation
        string category = parts[0].ToUpper();
        string year = parts[3];

        // Joining elements with a custom separator
        string summary = string.Join(" | ", parts);

        Console.WriteLine($"Category: {category}");
        Console.WriteLine($"Summary: {summary}");
    }
}

Trimming, Padding, and Search

Cleaning user input or formatting fixed-width text is common in data processing. Methods like Trim, PadLeft, and IndexOf are essential for these tasks.

using System;

public class SearchAndClean
{
    public static void Run()
    {
        string untrustedInput = "   user_profile_data   ";
        
        // Removing whitespace
        string cleanInput = untrustedInput.Trim();

        // Padding for alignment
        string padded = cleanInput.PadLeft(25, '*').PadRight(30, '*');

        // Searching for patterns
        int index = cleanInput.IndexOf("profile");
        bool containsData = cleanInput.Contains("data");

        Console.WriteLine($"Result: [{padded}]");
        Console.WriteLine($"'profile' starts at index: {index}");
    }
}

Type Conversion Techniques

Converting between numeric types and strings can be done via ToString(), Convert.ToInt32(), or the safer int.TryParse() method.

using System;

public class ConversionExample
{
    public static void Run()
    {
        string numericString = "1024";
        double piValue = 3.14159;

        // String to Int
        int count = int.Parse(numericString);

        // Int to String
        string s1 = count.ToString();

        // Rounding via Convert
        int roundedPi = Convert.ToInt32(piValue); // Results in 3

        // Safe conversion
        if (int.TryParse("not_a_number", out int result))
        {
            Console.WriteLine(result);
        }
        else
        {
            Console.WriteLine("Conversion failed.");
        }
    }
}

Efficient Building with StringBuilder

When performing multiple modifications to a string within a loop or complex logic, the StringBuilder class is preferred over standard string concatenation to save memory and improve performance.

using System;
using System.Text;

public class BuilderExample
{
    public static void Run()
    {
        StringBuilder sb = new StringBuilder("Initial Report");
        
        sb.AppendLine();
        sb.Append('-', 20);
        sb.AppendFormat("\nGenerated on: {0:d}", DateTime.Now);
        sb.Replace("Initial", "System");
        sb.Insert(0, "CONFIDENTIAL: ");

        Console.WriteLine(sb.ToString());
    }
}