C# Strings

Strings are one of the most fundamental and widely used data types in C#. They represent sequences of characters and are essential for handling text-based data in applications. Understanding how strings work in C# is crucial for effective programming, as they are used in everything from simple text output to complex data processing and manipulation.

1. Introduction to Strings

In C#, a string is an object of the `System.String` class. Strings are immutable, meaning once a string is created, it cannot be changed. Any operation that appears to modify a string actually creates a new string.

Key Characteristics:
- Immutable: Once created, the value of a string cannot be altered.

- Reference Type: Strings are reference types, but they behave like value types in some aspects.

- Unicode Support: C# strings support Unicode, allowing for a wide range of characters from different languages.

2. Declaring and Initializing Strings

Strings can be declared and initialized in several ways:

Using String Literals:

using System;

class Program
{
    static void Main()
    {
        string greeting = "Hello, World!";
        Console.WriteLine(greeting); // Output: Hello, World!
    }
}

Output:
Hello, World!

Explanation:
- The variable `greeting` is declared as a `string` and initialized with the value `"Hello, World!"`.
- `Console.WriteLine` prints the string to the console.

Using the `String` Class:

using System;

class Program
{
    static void Main()
    {
        String farewell = String.Empty;
        farewell = "Goodbye!";
        Console.WriteLine(farewell); // Output: Goodbye!
    }
}

Output:
Goodbye!

Explanation:
- The `String.Empty` property initializes `farewell` as an empty string.
- It is later assigned the value `"Goodbye!"`.
- `Console.WriteLine` prints the farewell message.

Using Verbatim Strings:
Verbatim strings are prefixed with `@` and are useful for multi-line strings and paths.

using System;

class Program
{
    static void Main()
    {
        string filePath = @"C:\Users\JohnDoe\Documents\File.txt";
        Console.WriteLine(filePath); // Output: C:\Users\JohnDoe\Documents\File.txt
    }
}

Output:
C:\Users\JohnDoe\Documents\File.txt

Explanation:
- The `@` symbol before the string literal allows the use of backslashes without escaping.
- Useful for file paths and multi-line strings.

3. String Immutability

Strings in C# are immutable. Any modification creates a new string instance.

Example:

using System;

class Program
{
    static void Main()
    {
        string original = "Hello";
        string modified = original.Replace("H", "J");
        Console.WriteLine($"Original: {original}");   // Output: Original: Hello
        Console.WriteLine($"Modified: {modified}");   // Output: Modified: Jello
    }
}

Output:
Original: Hello
Modified: Jello

Explanation:
- The `Replace` method creates a new string `modified` with the replaced character.
- The original string `original` remains unchanged.

4. String Concatenation

Combining strings can be done using several methods:

Using the `+` Operator:

using System;

class Program
{
    static void Main()
    {
        string firstName = "John";
        string lastName = "Doe";
        string fullName = firstName + " " + lastName;
        Console.WriteLine(fullName); // Output: John Doe
    }
}

Output:
John Doe

Explanation:
- The `+` operator concatenates `firstName`, a space, and `lastName` into `fullName`.

Using `String.Concat` Method:

using System;

class Program
{
    static void Main()
    {
        string part1 = "Hello, ";
        string part2 = "World!";
        string message = String.Concat(part1, part2);
        Console.WriteLine(message); // Output: Hello, World!
    }
}

Output:
Hello, World!

Explanation:
- `String.Concat` combines `part1` and `part2` into `message`.

Using `String.Join` Method:

using System;

class Program
{
    static void Main()
    {
        string[] words = { "C#", "is", "fun" };
        string sentence = String.Join(" ", words);
        Console.WriteLine(sentence); // Output: C# is fun
    }
}

Output:
C# is fun

Explanation:
- `String.Join` concatenates the array elements separated by a space into `sentence`.

5. String Interpolation

String interpolation provides a readable and convenient syntax to include variables or expressions inside string literals.

Example:

using System;

class Program
{
    static void Main()
    {
        string name = "Alice";
        int age = 30;
        string greeting = $"Hello, {name}. You are {age} years old.";
        Console.WriteLine(greeting); // Output: Hello, Alice. You are 30 years old.
    }
}

Output:
Hello, Alice. You are 30 years old.

Explanation:
- The `$` symbol before the string allows embedding expressions within `{}`.
- Variables `name` and `age` are inserted into the string.

6. Escape Characters and Verbatim Strings

Escape characters allow inclusion of special characters in strings.

Common Escape Characters:
- `\\` : Backslash
- `\"` : Double quote
- `\n` : New line
- `\t` : Tab

Example with Escape Characters:

using System;

class Program
{
    static void Main()
    {
        string path = "C:\\Program Files\\CSharpApp\\app.exe";
        string message = "He said, \"Hello!\"\nWelcome to the application.";
        Console.WriteLine(path);
        Console.WriteLine(message);
    }
}

Output:
C:\Program Files\CSharpApp\app.exe
He said, "Hello!" Welcome to the application.

Explanation:
- `\\` is used to include backslashes in the file path.
- `\"` includes double quotes within the string.
- `\n` adds a new line.

Using Verbatim Strings:

using System;

class Program
{
    static void Main()
    {
        string path = @"C:\Program Files\CSharpApp\app.exe";
        string message = @"He said, ""Hello!""
Welcome to the application.";
        Console.WriteLine(path);
        Console.WriteLine(message);
    }
}

Output:
C:\Program Files\CSharpApp\app.exe
He said, "Hello!" Welcome to the application.

Explanation:
- The `@` symbol before the string allows for easier inclusion of backslashes and multi-line text without needing escape characters.
- Double quotes within verbatim strings are represented by doubling them (`""`).

7. Common String Methods

C# provides a rich set of methods for string manipulation. Below are some of the most commonly used string methods:

7.1 `Length` Property Gets the number of characters in the string.

using System;

class Program
{
    static void Main()
    {
        string text = "Hello, World!";
        Console.WriteLine($"Length: {text.Length}"); // Output: Length: 13
    }
}

Output:
Length: 13

Explanation:
- The `Length` property returns the total number of characters in `text`.

7.2 `ToUpper` and `ToLower` Methods
Converts the string to uppercase or lowercase.

using System;

class Program
{
    static void Main()
    {
        string original = "C# Programming";
        string upper = original.ToUpper();
        string lower = original.ToLower();
        Console.WriteLine($"Original: {original}"); // Output: C# Programming
        Console.WriteLine($"Upper: {upper}");       // Output: C# PROGRAMMING
        Console.WriteLine($"Lower: {lower}");       // Output: c# programming
    }
}

Output:
Original: C# Programming
Upper: C# PROGRAMMING
Lower: c# programming

Explanation:
- `ToUpper` converts all characters to uppercase.
- `ToLower` converts all characters to lowercase.

7.3 `Substring` Method
Retrieves a substring from the string starting at a specified index.

using System;

class Program
{
    static void Main()
    {
        string text = "Hello, World!";
        string sub = text.Substring(7, 5);
        Console.WriteLine(sub); // Output: World
    }
}

Output:
World

Explanation:
- `Substring(7, 5)` extracts 5 characters starting from index 7, resulting in "World".

7.4 `Replace` Method
Replaces all occurrences of a specified character or substring with another.

using System;

class Program
{
    static void Main()
    {
        string original = "banana";
        string replaced = original.Replace('a', 'o');
        Console.WriteLine(replaced); // Output: bonono
    }
}

Output:
bonono

Explanation:
- `Replace('a', 'o')` replaces all instances of 'a' with 'o', resulting in "bonono".

7.5 `Split` Method
Splits the string into an array based on a specified delimiter.

using System;

class Program
{
    static void Main()
    {
        string data = "apple,banana,cherry";
        string[] fruits = data.Split(',');
        foreach (var fruit in fruits)
        {
            Console.WriteLine(fruit);
        }
        // Output:
        // apple
        // banana
        // cherry
    }
}

Output:
apple
banana
cherry

Explanation:
- `Split(',')` divides the string at each comma, creating an array of fruits.
- The `foreach` loop iterates over the array, printing each fruit.

7.6 `Trim`, `TrimStart`, and `TrimEnd` Methods Removes whitespace or specified characters from the beginning and/or end of the string.

using System;

class Program
{
    static void Main()
    {
        string text = "   Hello, World!   ";
        string trimmed = text.Trim();
        Console.WriteLine($"'{trimmed}'"); // Output: 'Hello, World!'
    }
}

Output:
'Hello, World!'

Explanation:
- `Trim()` removes leading and trailing whitespace from the string.

7.7 `IndexOf` and `LastIndexOf` Methods
Finds the index of the first or last occurrence of a specified character or substring.

using System;

class Program
{
    static void Main()
    {
        string text = "Hello, World!";
        int first = text.IndexOf('o');      // Output: 4
        int last = text.LastIndexOf('o');  // Output: 8
        Console.WriteLine($"First 'o' at: {first}");
        Console.WriteLine($"Last 'o' at: {last}");
    }
}

Output:
First 'o' at: 4
Last 'o' at: 8

Explanation:
- `IndexOf('o')` returns the index of the first 'o'.
- `LastIndexOf('o')` returns the index of the last 'o'.

7.8 `Contains` Method
Determines whether a specified substring occurs within the string.

using System;

class Program
{
    static void Main()
    {
        string sentence = "The quick brown fox jumps over the lazy dog.";
        bool hasFox = sentence.Contains("fox");
        Console.WriteLine(hasFox ? "Contains 'fox'." : "Does not contain 'fox'."); // Output: Contains 'fox'.
    }
}

Output:
Contains 'fox'.

Explanation:
- `Contains("fox")` checks if "fox" is present in `sentence`.

7.9 `StartsWith` and `EndsWith` Methods
Checks if the string starts or ends with a specified substring.

using System;

class Program
{
    static void Main()
    {
        string word = "Programming";
        bool startsWithPro = word.StartsWith("Pro");
        bool endsWithIng = word.EndsWith("ing");
        Console.WriteLine($"Starts with 'Pro': {startsWithPro}"); // Output: Starts with 'Pro': True
        Console.WriteLine($"Ends with 'ing': {endsWithIng}");     // Output: Ends with 'ing': True
    }
}

Output:
Starts with 'Pro': True
Ends with 'ing': True

Explanation:
- `StartsWith("Pro")` checks if `word` begins with "Pro".
- `EndsWith("ing")` checks if `word` ends with "ing".

7.10 `Equals` Method and `==` Operator
Compares two strings for equality.

using System;

class Program
{
    static void Main()
    {
        string s1 = "C#";
        string s2 = "C#";
        string s3 = "Java";
        
        Console.WriteLine(s1.Equals(s2)); // Output: True
        Console.WriteLine(s1 == s3);      // Output: False
    }
}

Output:
True
False

Explanation:
- `s1.Equals(s2)` returns `True` because both strings have the same value.
- `s1 == s3` returns `False` because "C#" is not equal to "Java".

8. String Formatting

String formatting allows embedding variables or expressions within strings in a structured manner.

Using `String.Format`:

using System;

class Program
{
    static void Main()
    {
        string name = "Alice";
        int age = 25;
        string formatted = String.Format("Name: {0}, Age: {1}", name, age);
        Console.WriteLine(formatted); // Output: Name: Alice, Age: 25
    }
}

Output:
Name: Alice, Age: 25

Explanation:
- `String.Format` replaces placeholders `{0}` and `{1}` with `name` and `age` respectively.

Using `Console.WriteLine` with Placeholders:

using System;

class Program
{
    static void Main()
    {
        string city = "New York";
        int population = 8419000;
        Console.WriteLine("City: {0}, Population: {1}", city, population); // Output: City: New York, Population: 8419000
    }
}

Output:
City: New York, Population: 8419000

Explanation:
- `Console.WriteLine` can directly take a format string with placeholders.

Using String Interpolation (Recommended):

using System;

class Program
{
    static void Main()
    {
        string product = "Laptop";
        double price = 999.99;
        string message = $"Product: {product}, Price: {price:C}";
        Console.WriteLine(message); // Output: Product: Laptop, Price: $999.99
    }
}

Output:
Product: Laptop, Price: $999.99

Explanation:
- String interpolation (`$"..."`) allows embedding expressions directly within strings.
- `{price:C}` formats the price as currency.

9. StringBuilder for Efficient String Manipulation

Since strings are immutable, repeated modifications can lead to performance issues. `StringBuilder` provides a mutable alternative for efficient string manipulation.

Example:

using System;
using System.Text;

class Program
{
    static void Main()
    {
        StringBuilder sb = new StringBuilder();
        for(int i = 1; i <= 5; i++)
        {
            sb.Append($"Line {i}\n");
        }
        string result = sb.ToString();
        Console.WriteLine(result);
    }
}

Output:
Line 1
Line 2
Line 3
Line 4
Line 5

Explanation:
- `StringBuilder` efficiently appends multiple strings without creating new string instances each time.
- `ToString()` converts the `StringBuilder` content back to a regular string.

10. String Comparison

Comparing strings can be case-sensitive or case-insensitive.

Case-Sensitive Comparison:

using System;

class Program
{
    static void Main()
    {
        string a = "apple";
        string b = "Apple";
        bool areEqual = a.Equals(b);
        Console.WriteLine($"Are equal: {areEqual}"); // Output: Are equal: False
    }
}

Output:
Are equal: False

Explanation:
- `a.Equals(b)` returns `False` because the comparison is case-sensitive.

Case-Insensitive Comparison:

using System;

class Program
{
    static void Main()
    {
        string a = "apple";
        string b = "Apple";
        bool areEqual = a.Equals(b, StringComparison.OrdinalIgnoreCase);
        Console.WriteLine($"Are equal (ignore case): {areEqual}"); // Output: Are equal (ignore case): True
    }
}

Output:
Are equal (ignore case): True

Explanation:
- Using `StringComparison.OrdinalIgnoreCase` makes the comparison case-insensitive.

11. String Interning

String interning is a memory optimization where identical string literals share the same memory reference. This reduces memory usage for identical strings.

Example:

using System;

class Program
{
    static void Main()
    {
        string s1 = "interned";
        string s2 = "interned";
        string s3 = new string(new char[] { 'i', 'n', 't', 'e', 'r', 'n', 'e', 'd' });
        
        Console.WriteLine(Object.ReferenceEquals(s1, s2)); // Output: True
        Console.WriteLine(Object.ReferenceEquals(s1, s3)); // Output: False
    }
}

Output:
True
False

Explanation:
- `s1` and `s2` reference the same interned string.
- `s3` is created at runtime and does not reference the interned string, hence `False`.

Forcing String Interning:

using System;

class Program
{
    static void Main()
    {
        string s1 = "interned";
        string s2 = new string(new char[] { 'i', 'n', 't', 'e', 'r', 'n', 'e', 'd' });
        string s3 = String.Intern(s2);
        
        Console.WriteLine(Object.ReferenceEquals(s1, s3)); // Output: True
    }
}

Output:
True

Explanation:
- `String.Intern(s2)` returns the interned string reference, making it equal to `s1`.

12. Encoding and Unicode Support

C# strings support Unicode, allowing representation of a wide range of characters from different languages and symbols.

Example:

using System;

class Program
{
    static void Main()
    {
        string unicodeString = "こんにちは世界"; // "Hello, World" in Japanese
        Console.WriteLine(unicodeString); // Output: こんにちは世界
    }
}

Output:
こんにちは世界

Explanation:
- The string contains Japanese characters, demonstrating Unicode support.

13. Regular Expressions with Strings

Regular expressions (Regex) are powerful for pattern matching and string manipulation.

Example of Using Regex:

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string input = "The price is $100.";
        string pattern = @"\$\d+";
        string replacement = "FREE";
        
        string result = Regex.Replace(input, pattern, replacement);
        Console.WriteLine(result); // Output: The price is FREE.
    }
}

Output:
The price is FREE.

Explanation:
- The Regex pattern `\$\d+` matches a dollar sign followed by one or more digits.
- `Regex.Replace` replaces the matched pattern with "FREE".

14. Advanced String Manipulation

C# offers advanced methods and features for complex string operations.

14.1 `StringBuilder` for High-Performance Scenarios:
For scenarios involving frequent modifications to strings, `StringBuilder` is more efficient than using regular string concatenation.

using System;
using System.Text;

class Program
{
    static void Main()
    {
        StringBuilder sb = new StringBuilder();
        for(int i = 1; i <= 5; i++)
        {
            sb.Append($"Line {i}\n");
        }
        string result = sb.ToString();
        Console.WriteLine(result);
    }
}

Output:
Line 1
Line 2
Line 3
Line 4
Line 5

Explanation:
- `StringBuilder` efficiently appends multiple lines without creating new string instances each time.
- `ToString()` converts the accumulated content back to a regular string.

14.2 `Span<T>` and `ReadOnlySpan<T>` for Memory-Efficient Operations: Introduced in C# 7.2, `Span<T>` provides a type-safe and memory-efficient way to handle contiguous regions of memory.

using System;

class Program
{
    static void Main()
    {
        string text = "Hello, World!";
        ReadOnlySpan<char> span = text.AsSpan().Slice(7, 5);
        Console.WriteLine(span.ToString()); // Output: World
    }
}

Output:
World

Explanation:
- `AsSpan()` creates a span over the string.
- `Slice(7, 5)` extracts a span representing "World".
- `ToString()` converts the span back to a string.

14.3 `string.Join` with LINQ:
Combining `string.Join` with LINQ methods for more complex operations.

using System;
using System.Linq;

class Program
{
    static void Main()
    {
        int[] numbers = { 1, 2, 3, 4, 5 };
        string evenNumbers = string.Join(", ", numbers.Where(n => n % 2 == 0));
        Console.WriteLine($"Even Numbers: {evenNumbers}"); // Output: Even Numbers: 2, 4
    }
}

Output:
Even Numbers: 2, 4

Explanation:
- `numbers.Where(n => n % 2 == 0)` filters the array for even numbers.
- `string.Join` concatenates the filtered numbers with a comma and space.

15. Best Practices for Working with Strings

- Use `StringBuilder` for Frequent Modifications: When performing multiple modifications, prefer `StringBuilder` to improve performance.

- Prefer String Interpolation: For readability and maintainability, use string interpolation (`$"..."`) over concatenation or `String.Format`.

- Be Mindful of Immutability: Understand that strings are immutable to avoid unintended performance penalties.

- Use Appropriate Comparison Methods: Utilize case-insensitive comparisons when necessary to ensure accurate results.

- Leverage LINQ for Collection Operations: Combine LINQ with string methods for powerful and concise code.

- Handle `null` and Empty Strings Gracefully: Use methods like `String.IsNullOrEmpty` or `String.IsNullOrWhiteSpace` to prevent runtime errors.

- Avoid Unnecessary String Operations: Minimize the number of string manipulations to enhance performance.

- Utilize Verbatim Strings for Readability: Use `@` for multi-line strings and paths to improve code clarity.

- Employ `Span<T>` for High-Performance Scenarios: Use `Span<T>` and `ReadOnlySpan<T>` for memory-efficient string operations.

16. Common Mistakes and How to Avoid Them

- Ignoring String Immutability:
Mistake:

string s = "Hello";
s += " World"; // Creates a new string

Solution: Use `StringBuilder` for multiple concatenations.

- Case-Sensitive Comparisons When Unintended:
Mistake:

string a = "Test";
string b = "test";
bool isEqual = a.Equals(b); // False

Solution: Use `StringComparison.OrdinalIgnoreCase` for case-insensitive comparisons.

- Overusing `String.Replace` in Loops:
Mistake:

string s = "a";
for(int i = 0; i < 1000; i++)
{
  s = s.Replace("a", "aa");
}

Solution: Use `StringBuilder` for iterative modifications.

- Not Handling `null` Strings:
Mistake:

string s = null;
Console.WriteLine(s.Length); // Throws NullReferenceException

Solution: Check for `null` using `String.IsNullOrEmpty` or `String.IsNullOrWhiteSpace` before accessing properties.

- Incorrect Use of Escape Characters: Mistake:

string path = "C:\newfolder\file.txt"; // Invalid escape sequence

Solution: Use verbatim strings or properly escape backslashes:

string path = @"C:\newfolder\file.txt";
// or
string path = "C:\\newfolder\\file.txt";

- Assuming Strings are Mutable: Mistake:

string s = "Hello";
s[0] = 'J'; // Compile-time error

Solution: Use methods like `Replace` or `Substring` to create modified strings.

17. Real-World Example: Building Dynamic SQL Queries

Building dynamic SQL queries often involves string manipulation. However, it's crucial to handle strings securely to prevent SQL injection attacks.

Example:

using System;
using System.Text;

class Program
{
    static void Main()
    {
        string table = "Users";
        string column = "Name";
        string value = "Alice";

        // Unsafe concatenation (vulnerable to SQL injection)
        string queryUnsafe = "SELECT * FROM " + table + " WHERE " + column + " = '" + value + "'";
        Console.WriteLine("Unsafe Query: " + queryUnsafe);
        // Output: SELECT * FROM Users WHERE Name = 'Alice'

        // Safe concatenation using parameterized queries (recommended)
        string querySafe = $"SELECT * FROM {table} WHERE {column} = @value";
        Console.WriteLine("Safe Query: " + querySafe);
        // Output: SELECT * FROM Users WHERE Name = @value
    }
}

Output:
Unsafe Query: SELECT * FROM Users WHERE Name = 'Alice'
Safe Query: SELECT * FROM Users WHERE Name = @value

Explanation:
- Unsafe Query: Directly concatenates user input into the SQL statement, making it vulnerable to SQL injection.

- Safe Query: Uses parameterized queries to safely include user input, preventing SQL injection.

18. Advanced Topics

- Span<T> and Memory<T>: Provide low-level memory access and manipulation without additional allocations.

Example Using Span<T>:

using System;

class Program
{
  static void Main()
  {
      string text = "Hello, World!";
      Span<char> span = text.AsSpan();
      span[0] = 'h'; // Not allowed since strings are immutable
      // This will cause a compile-time error
  }
}

Explanation:
- Attempting to modify a string via `Span<char>` results in a compile-time error due to string immutability.

- `Span<T>` is useful with mutable memory types like arrays or `StringBuilder`.

- Interpolated Verbatim Strings: Combine both verbatim strings and interpolation for complex string literals.

Example:

using System;

class Program
{
  static void Main()
  {
      string folder = "Documents";
      string file = "report.txt";
      string path = @$"C:\Users\JohnDoe\{folder}\{file}";
      Console.WriteLine(path); // Output: C:\Users\JohnDoe\Documents\report.txt
  }
}

Explanation:
- `@$` combines verbatim and interpolated string features, allowing both easy path formatting and variable embedding.

- String Pooling: C# maintains a pool of string literals to optimize memory usage.

Example:

using System;

class Program
{
  static void Main()
  {
      string s1 = "pool";
      string s2 = "pool";
      string s3 = new string(new char[] { 'p', 'o', 'o', 'l' });

      Console.WriteLine(Object.ReferenceEquals(s1, s2)); // Output: True
      Console.WriteLine(Object.ReferenceEquals(s1, s3)); // Output: False

      string s4 = String.Intern(s3);
      Console.WriteLine(Object.ReferenceEquals(s1, s4)); // Output: True
  }
}

Output:
True
False
True

Explanation:
- `s1` and `s2` reference the same interned string.

- `s3` is created at runtime and does not reference the interned string.

- `String.Intern(s3)` returns the interned reference, making it equal to `s1`.

- Using `Contains`, `StartsWith`, and `EndsWith` with `StringComparison`: Control case sensitivity.

Example:

using System;

class Program
{
  static void Main()
  {
      string text = "Hello, World!";
      bool contains = text.Contains("world", StringComparison.OrdinalIgnoreCase);
      Console.WriteLine($"Contains 'world' (ignore case): {contains}"); // Output: True
  }
}

Output:
Contains 'world' (ignore case): True

Explanation:
- `StringComparison.OrdinalIgnoreCase` makes the `Contains` method case-insensitive.

19. Performance Considerations

- String Concatenation in Loops: Repeated string concatenation in loops can lead to performance issues due to the creation of multiple string instances.

Solution:
Use `StringBuilder` for efficient concatenation.

using System;
using System.Text;

class Program
{
  static void Main()
  {
      StringBuilder sb = new StringBuilder();
      for(int i = 0; i < 1000; i++)
      {
          sb.Append("a");
      }
      string result = sb.ToString();
      Console.WriteLine($"Length: {result.Length}"); // Output: Length: 1000
  }
}

Output:
Length: 1000

- Avoid Unnecessary String Operations: Minimize the number of string manipulations to reduce memory overhead and improve performance.

20. Real-World Example: Parsing CSV Data

Parsing CSV (Comma-Separated Values) data involves splitting strings and processing each field.

Example:

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        string csv = "Name,Age,Location\nAlice,30,New York\nBob,25,Los Angeles\nCharlie,35,Chicago";
        string[] lines = csv.Split('\n');
        List<Person> people = new List<Person>();

        foreach (var line in lines)
        {
            string[] fields = line.Split(',');
            if(fields.Length == 3)
            {
                people.Add(new Person
                {
                    Name = fields[0],
                    Age = int.Parse(fields[1]),
                    Location = fields[2]
                });
            }
        }

        foreach(var person in people)
        {
            Console.WriteLine($"{person.Name} is {person.Age} years old and lives in {person.Location}.");
        }
        // Output:
        // Alice is 30 years old and lives in New York.
        // Bob is 25 years old and lives in Los Angeles.
        // Charlie is 35 years old and lives in Chicago.
    }
}

class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
    public string Location { get; set; }
}

Output:
Alice is 30 years old and lives in New York.
Bob is 25 years old and lives in Los Angeles.
Charlie is 35 years old and lives in Chicago.

Explanation:
- The CSV string is split into lines using `Split('\n')`.
- Each line is further split into fields using `Split(',')`.
- A `Person` object is created for each valid line and added to the `people` list.
- The final `foreach` loop prints the details of each person.

21. Summary

Strings in C# are powerful and versatile, providing numerous methods and features for text manipulation and processing. Understanding string immutability, efficient concatenation techniques, various string methods, and best practices ensures that developers can handle text data effectively while maintaining optimal performance and memory usage. Leveraging advanced features like `StringBuilder`, LINQ, and `Span<T>` further enhances the capability to work with strings in complex and high-performance scenarios.

Key points

- Strings are immutable reference types.

- Use appropriate methods (`Replace`, `Substring`, `Split`, etc.) for string manipulation.

- Prefer string interpolation for readability.

- Use `StringBuilder` for frequent modifications to avoid performance penalties.

- Leverage LINQ for advanced and concise string operations.

- Handle `null` and empty strings to prevent runtime errors.

- Understand string interning and pooling for memory optimization.

- Utilize regular expressions for complex pattern matching and manipulation.

- Follow best practices to write clean, efficient, and maintainable code.

Mastering string handling in C# is essential for developing robust applications that efficiently process and manage text data.