String type and immutability in C Sharp (C#) - Step-by-Step Execution

Concept Flow - String type and immutability

Create string s = "hello"

↓

Strings stored in memory

↓

Modify s by s = s + " world"

↓

New string created: "hello world"

↓

s points to new string

↓

Old string "hello" unchanged

Strings in C# are stored in memory and cannot be changed after creation. When you modify a string, a new string is created and the variable points to it.

Execution Sample

C Sharp (C#)

string s = "hello";
s = s + " world";
Console.WriteLine(s);

This code creates a string, then modifies it by adding more text, showing that a new string is created.

Execution Table

Step	Variable	Value	Action	Note
1	s	"hello"	Assign string literal	s points to "hello"
2	s	"hello world"	Concatenate and assign	New string created, s updated
3	Output	"hello world"	Print s	Outputs the new string

💡 Program ends after printing the new string; original string "hello" remains unchanged in memory

Variable Tracker

Variable	Start	After 1	After 2	Final
s	null	"hello"	"hello world"	"hello world"

Key Moments - 2 Insights

Why does modifying the string create a new string instead of changing the original?

Because strings in C# are immutable, any change creates a new string object. See execution_table step 2 where s points to a new string after concatenation.

Does the original string "hello" get deleted after concatenation?

No, the original string stays in memory unchanged. The variable s just points to the new string. This is shown in the concept_flow where the old string remains.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of s after step 1?

A null

B "hello"

C "hello world"

D "world"

💡 Hint

Check the 'Value' column in execution_table row with Step 1

At which step does s point to the new string "hello world"?

A Step 2

B Step 1

C Step 3

D Never

💡 Hint

Look at the 'Action' and 'Value' columns in execution_table row Step 2

If strings were mutable, what would change in the execution_table?

A Step 1 would create two strings

B Step 3 would print null

C Step 2 would modify the existing string instead of creating a new one

D There would be no output

💡 Hint

Think about the meaning of immutability shown in concept_flow and execution_table step 2

Concept Snapshot

C# strings are immutable.
Any change creates a new string object.
Variables point to string objects.
Original strings remain unchanged.
Use + to concatenate creates new strings.
This helps with safety and performance.

Full Transcript

In C#, strings are special because once created, they cannot be changed. This is called immutability. When you write code like string s = "hello"; you create a string object with the text hello. If you then do s = s + " world";, you are not changing the original string. Instead, a new string object with the text "hello world" is created, and s now points to this new string. The old string "hello" stays in memory unchanged. This behavior helps avoid accidental changes and makes programs safer. The execution table shows each step: first s points to "hello", then after concatenation s points to "hello world", and finally the program prints the new string. Understanding this helps you write better code with strings in C#.

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