Why String type and immutability in C Sharp (C#)? - Purpose & Use Cases

The Big Idea

What if changing a word could accidentally rewrite your entire story without you knowing?

The Scenario

Imagine you have a long list of names written on paper. Every time you want to change a name, you erase it and write a new one. This takes time and can smudge the paper, making it messy and confusing.

The Problem

Manually changing strings by rewriting them can be slow and error-prone. If you try to change a string directly, you might accidentally change parts you didn't want to, or cause unexpected bugs because the original text was shared in many places.

The Solution

The string type in C# is immutable, meaning once created, it cannot be changed. Instead, when you modify a string, a new string is created. This keeps your original text safe and avoids accidental changes, making your program more reliable and easier to understand.

Before vs After

✗ Before

string name = "Alice";
// name[0] = 'E'; // Not allowed, causes error

✓ After

string name = "Alice";
string newName = "E" + name.Substring(1);

What It Enables

This immutability allows safe sharing of strings across your program without unexpected changes, making your code more predictable and easier to debug.

Real Life Example

Think of a contract document shared among many people. If one person changes the original text, it could cause confusion. Instead, everyone works with copies, so the original stays safe and unchanged.

Key Takeaways

Strings cannot be changed once created (immutable).

Changing a string creates a new copy, keeping the original safe.

This prevents bugs and makes programs more reliable.

Practice

1. What does it mean that strings in C# are immutable?

easy

A. Once created, the string cannot be changed; any modification creates a new string.

B. Strings can be changed directly without creating a new string.

C. Strings are stored as numbers internally.

D. Strings can only contain letters and no numbers.

Solution

1. Step 1: Understand immutability concept

   Immutability means the value cannot be changed after creation.

2. Step 2: Apply to strings in C#

   In C#, strings cannot be changed once created; any change makes a new string.

3. Final Answer:

   Once created, the string cannot be changed; any modification creates a new string. -> Option A

4. Quick Check:

   String immutability = cannot change original string [OK]

Hint: Remember: strings never change, they create new copies [OK]

Common Mistakes:

• Thinking strings can be changed in place
• Confusing immutability with read-only variables
• Assuming strings only hold letters

2. Which of the following is the correct way to declare a string variable in C#?

easy

A. string name = "Alice";

B. String name = 'Alice';

C. string name = Alice;

D. String name = Alice;

Solution

1. Step 1: Check string declaration syntax

   In C#, strings use double quotes and the lowercase keyword 'string'.

2. Step 2: Identify correct syntax

   string name = "Alice"; uses lowercase 'string' and double quotes correctly.

3. Final Answer:

   string name = "Alice"; -> Option A

4. Quick Check:

   Use double quotes and string keyword [OK]

Hint: Use double quotes for strings and lowercase 'string' keyword [OK]

Common Mistakes:

• Using single quotes for strings
• Omitting quotes around text
• Confusing 'string' with 'String' casing

3. What will be the output of this C# code?

string s = "hello";
s = s.ToUpper();
Console.WriteLine(s);

medium

A. hello

B. HELLO

C. Hello

D. Error

Solution

1. Step 1: Understand ToUpper() method

   ToUpper() returns a new string with all letters uppercase.

2. Step 2: Assign new string to s and print

   Variable s is updated to the uppercase string, so printing s shows "HELLO".

3. Final Answer:

   HELLO -> Option B

4. Quick Check:

   ToUpper() creates uppercase string [OK]

Hint: ToUpper() returns new uppercase string; assign it to variable [OK]

Common Mistakes:

• Assuming original string changes without assignment
• Expecting lowercase output
• Thinking ToUpper() modifies string in place

4. Identify the error in this code snippet:

string s = "test";
s[0] = 'T';
Console.WriteLine(s);

medium

A. Strings cannot be indexed in C#.

B. Console.WriteLine requires parentheses.

C. Cannot assign to string index because strings are immutable.

D. Missing semicolon after string declaration.

Solution

1. Step 1: Check string indexing and assignment

   Strings can be indexed to read characters but cannot assign to indexes.

2. Step 2: Understand immutability prevents changing characters

   Because strings are immutable, s[0] = 'T' causes a compile error.

3. Final Answer:

   Cannot assign to string index because strings are immutable. -> Option C

4. Quick Check:

   Strings immutable = no character assignment [OK]

Hint: You can read chars by index but cannot assign to them [OK]

Common Mistakes:

• Trying to change string characters by index
• Confusing indexing with arrays
• Ignoring immutability rules

5. Given this code, what will be the output?

string original = "cat";
string changed = original.Replace('c', 'b');
Console.WriteLine(original);
Console.WriteLine(changed);

hard

A. Error at Replace method

B. bat
bat

C. cat
cat

D. cat
bat

Solution

1. Step 1: Understand Replace method on strings

   Replace returns a new string with specified characters replaced; original string stays unchanged.

2. Step 2: Analyze output of both Console.WriteLine calls

   original prints "cat" unchanged; changed prints "bat" with 'c' replaced by 'b'.

3. Final Answer:

   cat bat -> Option D

4. Quick Check:

   Replace returns new string, original unchanged [OK]

Hint: Replace returns new string; original string stays same [OK]

Common Mistakes:

• Assuming original string changes after Replace
• Expecting both outputs to be same
• Thinking Replace modifies string in place