Forem: Sabin Sim

36. C#(Lists in C#)

Sabin Sim — Sat, 21 Mar 2026 22:09:48 +0000

Full Runnable Code

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // 1) Create list
        List<string> words = new List<string>();

        Console.WriteLine("Initial Count: " + words.Count); // 0
        Console.WriteLine();

        // 2) Add
        words.Add("one");
        words.Add("two");

        Console.WriteLine("Count after Add: " + words.Count);
        Console.WriteLine();

        // 3) Print with foreach
        Console.WriteLine("Current list:");
        foreach (string word in words)
        {
            Console.WriteLine(word);
        }
        Console.WriteLine();

        // 4) Remove by value
        words.Remove("one");

        Console.WriteLine("After Remove:");
        foreach (string word in words)
        {
            Console.WriteLine(word);
        }
        Console.WriteLine();

        // 5) AddRange
        words.AddRange(new string[] { "three", "four", "five" });

        Console.WriteLine("After AddRange:");
        foreach (string word in words)
        {
            Console.WriteLine(word);
        }
        Console.WriteLine();

        // 6) IndexOf
        Console.WriteLine("IndexOf(\"four\"): " + words.IndexOf("four"));
        Console.WriteLine("IndexOf(\"seven\"): " + words.IndexOf("seven"));
        Console.WriteLine();

        // 7) Contains
        Console.WriteLine("Contains(\"five\"): " + words.Contains("five"));
        Console.WriteLine("Contains(\"seven\"): " + words.Contains("seven"));
        Console.WriteLine();

        // 8) RemoveAt
        words.RemoveAt(0);

        Console.WriteLine("After RemoveAt(0):");
        foreach (string word in words)
        {
            Console.WriteLine(word);
        }
        Console.WriteLine();

        // 9) Clear
        words.Clear();
        Console.WriteLine("Count after Clear: " + words.Count);

        Console.ReadKey();
    }
}

0. The Real Goal of This Lesson

A List<T> is a collection that can grow and shrink while keeping index-based access.

If this is not clear:

arrays and lists feel interchangeable
Add, Remove, and Count feel like random methods
dynamic collections become harder to reason about

This lesson is about understanding why List<T> exists and how it behaves structurally.

1. Why Do We Need List?

The biggest limitation of arrays is this:

Arrays have fixed size.

Example:

int[] numbers = new int[3];

Those 3 slots stay 3 slots.

But real programs often deal with changing amounts of data:

a shopping cart may contain 2 items
or 100 items
or become empty again

That is why List<T> exists.

It gives you:

variable-sized storage with index-based access

2. The Basic Concept of List

List<string> words = new List<string>();

Structure:

List<T> is a class → it needs new
<string> defines the element type
all elements must be of the same type

So this is:

a dynamic collection of strings

Unlike arrays, the number of elements is not fixed at creation.

3. Length vs Count

Arrays use:

numbers.Length

Lists use:

words.Count

Different names.

Same core meaning:

current number of elements

This distinction matters because many beginners try to write:

words.Length

That does not work for List<T>.

4. The Most Important List Methods

Add

words.Add("one");

Adds one element to the end of the list.

Remove

words.Remove("one");

Removes by value.

Behavior:

if the value exists → it is removed
if the value does not exist → nothing happens

RemoveAt

words.RemoveAt(0);

Removes by index.

Important:

invalid index = runtime error

So index rules still matter.

AddRange

words.AddRange(new string[] { "three", "four" });

Adds multiple elements at once.

This is useful when you already have a collection to append.

IndexOf

words.IndexOf("four");

Behavior:

returns the index if found
returns -1 if not found

This is a search result, not a boolean.

Contains

words.Contains("five");

Returns:

true or false

This is a direct membership check.

Clear

words.Clear();

Removes all elements from the list.

After this:

words.Count == 0

5. List vs Array

Array	List
Fixed size	Variable size
`Length`	`Count`
Cannot `Add`	Can `Add`
Cannot `Remove` directly	Can `Remove`

The structural difference is simple:

array = fixed container
list = resizable container

6. Index Rules Are Still the Same

A list is dynamic, but indexing still starts at 0.

If the list has 2 elements, valid indices are:

0, 1

So this:

words.RemoveAt(2);

causes a runtime error.

Dynamic size does not remove index boundaries.

7. Structural Execution Flow of Removal

This is a very important mental model.

When an element is removed from a list:

the remaining elements shift left to fill the gap

Example:

[10, 20, 30]
RemoveAt(0)

Becomes:

[20, 30]

Now:

20 moves to index 0
30 moves to index 1

This is why indices must be reinterpreted after removal.

Final Summary

Arrays have fixed size.
List<T> is a variable-sized collection with index-based access and built-in methods like Add, Remove, and Count.

Learning Check

Explain the execution flow of this code step by step:

List<int> numbers = new List<int>();

numbers.Add(10);
numbers.Add(20);
numbers.Remove(10);

Console.WriteLine(numbers.Count);
Console.WriteLine(numbers[0]);

Answer these precisely:

What remains in the list after Remove(10)?
What is the value of Count?
What does numbers[0] print?
Why does that happen? Explain it in terms of index shifting after removal.

35. C# (foreach Loop in C#)

Sabin Sim — Thu, 19 Mar 2026 17:28:00 +0000

Full Runnable Code

using System;

class Program
{
    static void Main()
    {
        string[] words = { "apple", "banana", "cherry" };

        Console.WriteLine("Using for loop:");
        for (int i = 0; i < words.Length; i++)
        {
            Console.WriteLine(words[i]);
        }

        Console.WriteLine();

        Console.WriteLine("Using foreach loop:");
        foreach (string word in words)
        {
            Console.WriteLine(word);
        }

        Console.ReadKey();
    }
}

0. The Real Goal of This Lesson

foreach lets you iterate over elements directly without managing indices.

If this is not clear:

you overuse for
you write unnecessary index logic
your code becomes less readable

This lesson is about understanding element-based iteration.

1. What the for Loop Is Actually Doing

for (int i = 0; i < words.Length; i++)
{
    Console.WriteLine(words[i]);
}

The role of i is only this:

To access words[i]

We are not using i for logic.

We are using it as a tool to retrieve elements.

So structurally:

for = index-driven access

2. Understanding the foreach Structure

foreach (string word in words)
{
    Console.WriteLine(word);
}

Structure:

foreach (Type variable in Collection)

Meaning:

Take each element from words
Assign it to word
Execute the block

No index is required.

3. Step-by-Step Execution Flow

Array:

["apple", "banana", "cherry"]

First iteration

word = "apple"
print

Second iteration

word = "banana"
print

Third iteration

word = "cherry"
print

Then the loop ends.

Important:

Indexing still happens internally, but it is hidden from you.

4. for vs foreach — Structural Difference

Criteria	for	foreach
Focus	Index	Element
Index access	Yes	No
Readability	Medium	Higher
Use case	When index control is needed	When simple traversal is needed

Mental model:

for → control the iteration
foreach → consume elements

5. When Should You Use foreach?

Use foreach when:

you do not need the index
you process all elements
the operation is read-only
no custom stepping logic is required

In short:

“Do the same operation for every element.”

6. Important Limitation

You cannot directly use an index inside foreach.

This is invalid:

Console.WriteLine(i);

There is no i.

Modification Does Not Affect Original Data

foreach (int number in numbers)
{
    number = number * 2; // does NOT change the array
}

Reason:

number is a copy of the element, not the original reference.

So the original array remains unchanged.

Final Summary

foreach is the simplest way to iterate through a collection when you only need the element, not the index.

Learning Check

Consider this code:

int[] numbers = { 1, 2, 3 };

foreach (int number in numbers)
{
    Console.WriteLine(number);
}

Console.WriteLine("End");

Explain:

What is the output order?
How many times does the loop run?
What determines the number of iterations?

Answer using execution flow, not just results.

34. C# (Arrays in C)

Sabin Sim — Mon, 16 Mar 2026 15:40:34 +0000

using System;

class Program
{
    static void Main()
    {
        // 1) Declare + allocate array (check default values)
        int[] numbers = new int[3];

        Console.WriteLine("Default values:");
        Console.WriteLine(numbers[0]);
        Console.WriteLine(numbers[1]);
        Console.WriteLine(numbers[2]);
        Console.WriteLine();

        // 2) Update values
        numbers[0] = 10;
        numbers[1] = 20;
        numbers[2] = 30;

        Console.WriteLine("After updating values:");
        for (int i = 0; i < numbers.Length; i++)
        {
            Console.WriteLine(numbers[i]);
        }
        Console.WriteLine();

        // 3) Index from End (^)
        int[] numbers2 = { 10, 20, 30, 40, 50 };

        Console.WriteLine("Access from the end:");
        Console.WriteLine(numbers2[^1]); // 50
        Console.WriteLine(numbers2[^2]); // 40
        Console.WriteLine();

        // 4) Calculate sum
        int sum = 0;

        for (int i = 0; i < numbers2.Length; i++)
        {
            sum += numbers2[i];
        }

        Console.WriteLine("Sum:");
        Console.WriteLine(sum);

        Console.ReadKey();
    }
}

0. The Real Goal of This Lesson

An array is an index-based structure that stores multiple values of the same type under one variable name.

If this is not clear:

index errors feel random
Length becomes confusing
for loops with arrays become fragile

This lesson is not about syntax.

It is about understanding the structure of indexed storage.

1. What Is an Array?

A normal variable is one box:

int number = 10;

An array is multiple boxes handled as one structure:

int[] numbers = new int[3];

Meaning:

allocate space for 3 integers
each slot is filled with the default value

For int, the default value is:

So immediately after creation, this array contains:

0, 0, 0

2. Index Starts at 0

If the array size is 3, the valid indices are:

0 1 2

The last valid index is always:

Length - 1

This is one of the most important rules in arrays.

3. Compile-Time Error vs Runtime Error

Compile-Time Error

numbers[0] = "hello";

This fails because the type is wrong.

numbers[0] expects an int
"hello" is a string

The compiler blocks execution before the program runs.

Runtime Error

numbers[3] = 100;

This compiles.

But it crashes during execution because index 3 does not exist in an array of length 3.

Typical message:

Index was outside the bounds of the array

This is a runtime error.

4. The Most Common Mistake

This is wrong:

numbers[numbers.Length]

If Length = 3, valid indices are:

0, 1, 2

So:

numbers[3]

is invalid.

Always remember:

The last valid index is Length - 1.

5. The ^ Operator (Index from End)

This expression:

numbers2[^1]

means:

the first element from the end

Equivalent to:

numbers2[numbers2.Length - 1]

Examples:

^1 → last element
^2 → second-to-last element

It is a shorter way to count backward from the end.

6. The One Rule You Must Not Break in for Loops

Correct condition:

i < numbers.Length

Wrong condition:

i <= numbers.Length

Why is the second one wrong?

Because on the last iteration:

i == numbers.Length

And that means you try to access an index that does not exist.

This is the classic off-by-one mistake.

7. The Biggest Limitation of Arrays

Arrays have fixed size.

Example:

new int[3]

That size stays 3.

You cannot grow it.
You cannot shrink it.

So the structural rule is:

fixed number of elements → use an array
variable number of elements → later use List<T>

Final Summary

An array is an index-based structure that stores a fixed number of values of the same type.

Learning Check

In the following code, explain exactly when the runtime error happens by tracking the value of i step by step.

int[] numbers = { 10, 20, 30 };

for (int i = 0; i <= numbers.Length; i++)
{
    Console.WriteLine(numbers[i]);
}

Explain these points:

How does i change starting from 0?
What is the final value of i?
At which exact moment does the crash happen, and why?

If you can explain that precisely,
you fully understand the relationship between arrays and for loops.

33. C# (Loop Performance)

Sabin Sim — Sat, 14 Mar 2026 12:01:35 +0000

0. The Real Goal of This Lesson

This lesson is not just a warning about slow code.

The key idea is this:

Loops multiply execution time.
Performance problems often come from multiplication, not addition.

Today the goal is to understand the structure of execution time, not just that something “can be slow.”

1. Why This Concept Matters

In real development you will eventually:

build API servers
connect databases
process user requests
traverse collections
process large datasets

The most dangerous combination is:

nested loops + expensive operations
(database queries, file I/O, network calls, external APIs)

A loop is not just a structure that repeats work.

A loop multiplies the cost of the work inside it.

2. What Program Performance Really Means

In simple terms:

Performance describes how quickly a program runs
and how many resources it consumes.

Typical resources include:

CPU computation time
memory usage
disk access
network requests
database calls

But the key mindset shift is this:

Performance is not about asking:

“Is this line of code fast?”

Instead, ask:

“How many times will this code run?”

3. Execution Flow of a Nested Loop

Example:

using System;

class Program
{
    static void Main()
    {
        for (int i = 0; i < 4; i++)
        {
            for (int j = 0; j < 15; j++)
            {
                Console.WriteLine($"i={i}, j={j}");
            }
        }

        Console.ReadKey();
    }
}

Execution sequence:

i = 0 → inner loop runs 15 times
i = 1 → inner loop runs 15 times
i = 2 → inner loop runs 15 times
i = 3 → inner loop runs 15 times

Total executions:

4 × 15 = 60

Because Console.WriteLine is fast, you do not notice the cost.

But the real issue is:

operation cost × execution count

4. What If the Inner Operation Takes 100 ms?

Example:

for (int i = 0; i < 4; i++)
{
    for (int j = 0; j < 15; j++)
    {
        System.Threading.Thread.Sleep(100);
    }
}

Calculation:

1 execution = 100 ms
60 executions = 6000 ms

Total runtime:

6 seconds

From a user's perspective:

“Did the server freeze?”

The key insight:

Loops do not simply add time —
they multiply it.

5. Optimization Strategy 1 — Early Exit with break

If the purpose of the loop is searching, stop when the item is found.

Inefficient version:

int[] numbers = { 1, 2, 3, 4, 5 };

for (int i = 0; i < numbers.Length; i++)
{
    if (numbers[i] == 2)
    {
        Console.WriteLine("Found!");
    }
}

Even after finding the value, the loop continues.

Improved version:

for (int i = 0; i < numbers.Length; i++)
{
    if (numbers[i] == 2)
    {
        Console.WriteLine("Found!");
        break;
    }
}

Execution flow:

1 → check
2 → found
break → loop stops immediately

This avoids unnecessary work.

6. Optimization Strategy 2 — Move Expensive Work Outside the Loop

A common mistake:

for (int i = 0; i < 4; i++)
{
    for (int j = 0; j < 15; j++)
    {
        var data = GetDataFromDatabase();
        Console.WriteLine(data);
    }
}

Database calls:

4 × 15 = 60

Database operations are far slower than CPU operations.

Better structure:

var data = GetDataFromDatabase();

for (int i = 0; i < 4; i++)
{
    for (int j = 0; j < 15; j++)
    {
        Console.WriteLine(data);
    }
}

Now the database call occurs:

1 time instead of 60

The key question developers should ask:

Does this operation need to run every iteration?

Or:

Can it run once outside the loop?

7. How Execution Grows with Nested Loops

Execution growth pattern:

Single loop:

Two nested loops:

n × m

Three nested loops:

n × m × k

Each additional nesting level multiplies the total work.

This is why nested loops are strongly related to algorithmic complexity.

8. Common Performance Mistakes

Mistake	Result
Database calls inside inner loops	Slow response time
No early exit during search	Unnecessary CPU usage
Deep nesting (3+ loops)	Explosive execution count
Repeating identical calculations	Wasted resources

9. Practical Perspective

In real applications you will work with:

.NET APIs
FastAPI or web services
database queries
large collections
data processing pipelines

In those systems the most important question is:

How many times does this code run?

Syntax comes second.

Execution count comes first.

Final Summary

A loop multiplies execution time.
Putting expensive operations inside nested loops can make performance degrade exponentially.

Thinking Question

Suppose an API processes 10,000 records.

Which of the following operations should never be placed inside a loop?

Database queries
External API calls
File I/O operations
Simple variable increments

Explain your reasoning in terms of execution count and cost per operation.

32. C# (Nested Loop)

Sabin Sim — Thu, 12 Mar 2026 19:31:42 +0000

0. The Essence of Nested Loops

Every time the outer loop runs once,
the inner loop runs completely from start to finish.

Core rule:

One outer iteration = one full execution set of the inner loop

If this mental model is not clear, nested loops quickly become confusing.

1. Basic Example — 4 × 3

Full Runnable Code

using System;

class Program
{
    static void Main()
    {
        for (int i = 1; i <= 4; i++)
        {
            for (int j = 1; j <= 3; j++)
            {
                Console.WriteLine($"Outer: {i}, Inner: {j}");
            }
        }

        Console.WriteLine("Finished.");
        Console.ReadKey();
    }
}

Step-by-Step Execution Flow

When `i = 1`

j = 1 → print
j = 2 → print
j = 3 → print

Inner loop ends.

When `i = 2`

j = 1 → print
j = 2 → print
j = 3 → print

Total Execution Count

Outer loop runs 4 times.
Inner loop runs 3 times per outer iteration.

So the total number of executions is:

4 × 3 = 12

Structural Visualization

i=1
  j=1
  j=2
  j=3

i=2
  j=1
  j=2
  j=3

i=3
  j=1
  j=2
  j=3

i=4
  j=1
  j=2
  j=3

Notice an important detail:

The inner loop variable j is reinitialized every time the outer loop starts again.

2. Intuitive Way to Understand 4 × 3

Instead of thinking mathematically, think structurally.

The outer loop represents:

the number of sets

The inner loop represents:

the number of items inside each set

Example analogy:

4 boxes
each box contains 3 objects

Total objects:

4 × 3 = 12

This is exactly how nested loops behave.

3. Deeper Nesting — 4 × 3 × 5

Example Code

using System;

class Program
{
    static void Main()
    {
        for (int i = 1; i <= 4; i++)
        {
            for (int j = 1; j <= 3; j++)
            {
                for (int k = 1; k <= 5; k++)
                {
                    Console.WriteLine($"i:{i}, j:{j}, k:{k}");
                }
            }
        }

        Console.WriteLine("Finished.");
        Console.ReadKey();
    }
}

How Many Times Does It Execute?

Outer loop:

Middle loop:

Inner loop:

Total executions:

4 × 3 × 5 = 60

Why Nested Loops Affect Performance

Every additional nesting level multiplies execution cost.

Growth pattern:

O(n)
O(n²)
O(n³)

Example:

100 × 100 = 10,000 operations
1000 × 1000 = 1,000,000 operations

When the dataset grows large, nested loops can quickly become a performance bottleneck.

This is why developers must use them carefully.

4. Where Nested Loops Are Used in Practice

Common scenarios include:

iterating through 2D arrays
coordinate calculations
generating tables or grids
comparing two datasets
algorithmic problems

Many classic algorithms rely heavily on nested loops.

5. Understanding the Flow Using a Debugger

A very effective way to learn this is debugging.

Steps:

Place a breakpoint on the innermost Console.WriteLine.
Use Step Into (F11) repeatedly.
Observe how i, j, and k change.

You will notice:

The inner loop finishes completely before the outer loop continues.

Seeing this once in a debugger makes the structure very clear.

6. The Most Important Mental Model

Whenever you see nested loops, think like this:

The inner loop runs completely inside a single iteration of the outer loop.

If you misunderstand this, algorithmic reasoning becomes very difficult.

7. Key Points to Remember

At your current stage, you should clearly understand:

Execution count follows a multiplication pattern
The inner loop is reinitialized every time
More nesting increases execution exponentially
Performance is directly affected

Final Summary

A nested loop is a structure where one loop executes completely inside another loop, and the total execution count grows through multiplication.

31. C# (continue)

Sabin Sim — Tue, 10 Mar 2026 18:43:34 +0000

0. The Essence of continue

continue immediately stops the current iteration and moves to the next one.

Important distinction:

❌ It does not terminate the loop
⭕ It only skips the current cycle

Execution jumps directly to the next iteration.

1. Simple Example — Skip Multiples of 3

Goal

Print numbers from 0 to 20, but exclude multiples of 3.

Full Runnable Code

using System;

class Program
{
    static void Main()
    {
        for (int i = 0; i <= 20; i++)
        {
            if (i % 3 == 0)
            {
                continue;
            }

            Console.WriteLine(i);
        }

        Console.WriteLine("Loop finished.");
        Console.ReadKey();
    }
}

Execution Flow

Example when i = 6

6 % 3 == 0 → true
continue executes
Console.WriteLine(i) is skipped
loop proceeds to i++

So 6 is not printed.

The loop continues normally afterward.

Without continue

The same logic can be written like this:

if (i % 3 != 0)
{
    Console.WriteLine(i);
}

Both work.

However, the continue version follows a specific style:

Filter out exceptional cases first,
then let the normal logic run below.

This style is often called a guard clause approach.

2. break vs continue

Keyword	Current iteration	Entire loop
break	Stops	Stops
continue	Stops	Continues

break Example

for (int i = 0; i < 10; i++)
{
    if (i == 5)
    {
        break;
    }

    Console.WriteLine(i);
}

Output:

The loop stops completely.

continue Example

for (int i = 0; i < 10; i++)
{
    if (i == 5)
    {
        continue;
    }

    Console.WriteLine(i);
}

Output:

Only 5 is skipped.

3. Practical Scenario — Protecting User Input

Consider this code:

int number = int.Parse(input);

If the user enters:

abc

The program throws:

FormatException

and crashes.

Goal

We want to:

Ignore invalid input
Ask again
Prevent program crashes

Safe Example Using continue

using System;

class Program
{
    static void Main()
    {
        string input;
        int userNumber = 0;

        do
        {
            Console.WriteLine("Enter number > 10 or type 'stop':");
            input = Console.ReadLine();

            if (input == "stop")
            {
                break;
            }

            bool isNumeric = true;

            foreach (char c in input)
            {
                if (!char.IsDigit(c))
                {
                    isNumeric = false;
                    break;
                }
            }

            if (!isNumeric)
            {
                Console.WriteLine("Invalid input.");
                continue;
            }

            userNumber = int.Parse(input);

        } while (userNumber <= 10);

        Console.WriteLine("Loop ended.");
        Console.ReadKey();
    }
}

Execution Flow Analysis

User enters `"abc"`

isNumeric = false
continue executes
int.Parse is skipped
loop starts next iteration

Result:

The program does not crash.

4. Why break Did Not Cause an Initialization Error

Key idea:

break completely exits the loop.

Example:

if (input == "stop")
{
    break;
}

The code after this inside the loop is never executed.

So the compiler does not require all variables to be assigned.

But continue Is Different

continue jumps back to the loop condition.

Therefore:

All possible paths must still maintain valid variable states.

Otherwise the compiler will report errors.

Structural Difference

From a control-flow perspective:

break

exit loop
continue execution outside

continue

skip current iteration
return to loop condition
start next iteration

5. When continue Is Useful

Use continue when:

many invalid conditions exist
you want to filter early
you want cleaner control flow

Typical pattern:

if (invalidCondition)
{
    continue;
}

// main logic below

This separates:

exception cases
normal execution

Final Summary

break exits the entire loop.
continue skips only the current iteration and moves to the next one.

30. C# (break)

Sabin Sim — Thu, 05 Mar 2026 18:48:34 +0000

0. The Real Goal of This Lesson

break is a control statement that immediately terminates the current loop.

Even if the loop condition is still true,
execution jumps outside the loop instantly.

This makes break a manual exit mechanism inside iterative structures.

1. The Simplest Example — for Loop + break

Full Runnable Code

using System;

class Program
{
    static void Main()
    {
        for (int i = 0; i < 100; i++)
        {
            if (i > 25)
            {
                break;
            }

            Console.WriteLine(i);
        }

        Console.WriteLine("Loop finished.");
        Console.ReadKey();
    }
}

Execution Flow

Originally the loop would run:

0 → 99

But the program checks:

if (i > 25)

When this becomes true:

break executes
the loop stops immediately
control moves to the next statement after the loop

Output:

0
1
...
25
Loop finished.

Why Not Just Change the Condition?

You could write:

for (int i = 0; i < 26; i++)

That would work.

However, break becomes important when:

an unexpected condition occurs during iteration.

In other words:

The loop cannot know the stopping condition in advance.

2. Real Scenario — Repeated User Input

Goal

Ask the user for a number
If the number is greater than 10 → stop
Otherwise keep asking

Runnable Example (do-while + break)

using System;

class Program
{
    static void Main()
    {
        string input;
        int number;

        do
        {
            Console.WriteLine("Enter a number greater than 10 (or type 'stop'):");

            input = Console.ReadLine();

            if (input == "stop")
            {
                break;
            }

            number = int.Parse(input);

        } while (number <= 10);

        Console.WriteLine("Loop ended.");
        Console.ReadKey();
    }
}

Execution Scenarios

Case 1 — User enters `5`

Condition:

5 ≤ 10 → true

Loop continues.

Case 2 — User enters `20`

Condition:

20 ≤ 10 → false

Loop ends naturally.

Case 3 — User enters `"stop"`

Program executes:

break;

Loop terminates immediately without checking the condition.

Why break Is Useful

Without break, the loop condition becomes more complex:

while (number <= 10 && input != "stop")

As conditions grow, readability suffers.

break allows you to say clearly:

“Under this situation, exit immediately.”

3. Two Ways a Loop Can End

Natural termination

The loop condition becomes false.

Example:

while (number <= 10)

Forced termination

The loop exits because of break.

This is a manual interruption of the iteration flow.

Where break Actually Stops

break only stops the closest loop.

Example:

for (...)
{
    while (...)
    {
        break;
    }
}

Result:

while stops
for continues running

This is a very common misunderstanding.

Caution When Using break

Overusing break can create problems:

unpredictable flow
harder debugging
weaker structure

General rule:

Use break only when an early exit is logically necessary.

Practical Example — Searching an Array

int[] numbers = { 1, 3, 5, 7, 9 };

for (int i = 0; i < numbers.Length; i++)
{
    if (numbers[i] == 5)
    {
        Console.WriteLine("Found 5!");
        break;
    }
}

Once the value is found:

further iterations are unnecessary
the loop stops immediately

This is an efficient use of break.

Final Summary

break allows a loop to terminate immediately,
even if the loop condition is still true.

It provides manual control over the execution flow of loops.

29. C# (foreach Loop)

Sabin Sim — Wed, 04 Mar 2026 20:37:31 +0000

in C# — Full Code First

using System;

class Program
{
    static void Main()
    {
        string[] words = { "apple", "banana", "cherry" };

        Console.WriteLine("Using for loop:");
        for (int i = 0; i < words.Length; i++)
        {
            Console.WriteLine(words[i]);
        }

        Console.WriteLine();

        Console.WriteLine("Using foreach loop:");
        foreach (string word in words)
        {
            Console.WriteLine(word);
        }

        Console.ReadKey();
    }
}

0. The Real Goal of This Lesson

foreach removes index management
and lets you focus directly on the element.

If you misunderstand this:

You overuse for
You write unnecessary index logic
Your intent becomes less readable

This lesson is about execution model clarity.

1. What the for Loop Is Actually Doing

for (int i = 0; i < words.Length; i++)
{
    Console.WriteLine(words[i]);
}

The only purpose of i here is:

To access words[i]

We are not using i for logic.

We are using it just to retrieve elements.

The index is a middleman.

2. Understanding the foreach Structure

foreach (string word in words)
{
    Console.WriteLine(word);
}

Structure:

foreach (Type variable in Collection)

Meaning:

Take each element inside words
Assign it to word
Execute the block

No index required.

3. Step-by-Step Execution Flow

Array:

["apple", "banana", "cherry"]

First iteration

word = "apple"
Print

Second iteration

word = "banana"
Print

Third iteration

word = "cherry"
Print

Then stop.

Internally, indexing still happens.
But it is abstracted away.

4. for vs foreach — Structural Difference

Criteria	for	foreach
Focus	Index	Element
Index access	Yes	No
Readability	Medium	Higher
Use case	When index control is needed	When simple traversal is needed

Mental shift:

for = index-driven loop
foreach = element-driven loop

5. When Should You Use foreach?

Use foreach when:

You do not need the index
You simply process each element
The operation is read-only
The order does not need custom control

In other words:

“Perform the same action for every element.”

6. Important Limitation

You cannot directly access the index inside foreach.

This is invalid:

Console.WriteLine(i); // no index variable

Also:

foreach (int number in numbers)
{
    number = number * 2; // does NOT modify original array
}

The variable number is a copy.

The original array remains unchanged.

This is a critical distinction.

Final Summary

foreach is the simplest way to iterate over a collection
when you only need the element, not the index.

Learning Check (One Question)

What is the output of this code?

int[] numbers = { 1, 2, 3 };

foreach (int number in numbers)
{
    Console.WriteLine(number);
}

Console.WriteLine("End");

Answer precisely:

What is the output order?
How many iterations occur?
What determines the number of iterations?

If you can explain this in terms of execution flow,
you understand foreach structurally.

28. C# (Multidimensional Arrays)

Sabin Sim — Tue, 03 Mar 2026 20:36:39 +0000

using System;

class Program
{
    static void Main()
    {
        char[,] board =
        {
            { 'A', 'B', 'C' },
            { 'D', 'E', 'F' }
        };

        Console.WriteLine("Row count: " + board.GetLength(0));
        Console.WriteLine("Column count: " + board.GetLength(1));
        Console.WriteLine("Total elements (Length): " + board.Length);
        Console.WriteLine();

        for (int i = 0; i < board.GetLength(0); i++)
        {
            for (int j = 0; j < board.GetLength(1); j++)
            {
                Console.WriteLine($"i={i}, j={j}, value={board[i, j]}");
            }
        }

        Console.ReadKey();
    }
}

0. The Real Goal of This Lesson

A multidimensional array is one structure with multiple dimensions.
Each dimension has its own size.

If you misunderstand this:

You misuse Length
You write incorrect loops
You trigger runtime index errors

This lesson is about structural clarity.

1. Understanding the Array Structure

char[,] board =
{
    { 'A', 'B', 'C' },
    { 'D', 'E', 'F' }
};

This is a 2D array with:

2 rows
3 columns

Visual representation:

(0,0) (0,1) (0,2)
(1,0) (1,1) (1,2)

Important distinction:

board.Length → 6 (total elements)
board.GetLength(0) → 2 (rows)
board.GetLength(1) → 3 (columns)

Length is not the row count.

2. Why Two Loops Are Required

A 1D array uses one index:

numbers[i]

A 2D array requires two:

board[i, j]

Meaning:

i moves across rows
j moves across columns

Execution pattern:

Outer loop = row set
Inner loop = full column traversal per row

Nested loops are not optional.
They are structurally required.

3. Step-by-Step Execution Flow

First row (i = 0)

j = 0 → A
j = 1 → B
j = 2 → C

Inner loop ends.

Second row (i = 1)

j = 0 → D
j = 1 → E
j = 2 → F

Termination

i becomes 2 → outer condition fails → traversal stops.

Execution count:

rows × columns = 2 × 3 = 6

4. Why Using Length Alone Is Dangerous

Incorrect loop:

for (int i = 0; i < board.Length; i++)

board.Length = 6

But valid row indices:

0 and 1 only.

When i = 2, you effectively access:

board[2, 0]

Runtime error.

Length represents total elements, not row range.

Learning Check (One Question)

Given:

int[,] matrix = new int[3, 4];

Answer all of these:

What is matrix.Length?
What is matrix.GetLength(0)?
What is matrix.GetLength(1)?
How many total iterations will the nested loops run?

Compute the execution count precisely.

Final Summary

When dimension count increases, index count increases.
Loop structure must expand accordingly.

27. C# (Arrays)

Sabin Sim — Sun, 01 Mar 2026 17:45:17 +0000

using System;

class Program
{
    static void Main()
    {
        // 1) Declare + allocate (check default values)
        int[] numbers = new int[3];

        Console.WriteLine("Default values:");
        Console.WriteLine(numbers[0]);
        Console.WriteLine(numbers[1]);
        Console.WriteLine(numbers[2]);
        Console.WriteLine();

        // 2) Update values
        numbers[0] = 10;
        numbers[1] = 20;
        numbers[2] = 30;

        Console.WriteLine("After updates:");
        for (int i = 0; i < numbers.Length; i++)
        {
            Console.WriteLine(numbers[i]);
        }
        Console.WriteLine();

        // 3) Index from End (^)
        int[] numbers2 = { 10, 20, 30, 40, 50 };

        Console.WriteLine("Access from the end:");
        Console.WriteLine(numbers2[^1]); // 50
        Console.WriteLine(numbers2[^2]); // 40
        Console.WriteLine();

        // 4) Sum all values
        int sum = 0;

        for (int i = 0; i < numbers2.Length; i++)
        {
            sum += numbers2[i];
        }

        Console.WriteLine("Sum:");
        Console.WriteLine(sum);

        Console.ReadKey();
    }
}

0. The Real Goal of This Lesson

An array is not “multiple variables.”
It is one structure that stores many values of the same type under a single reference.

If you miss this:

Index logic feels random
Off-by-one bugs keep happening
Runtime errors feel “mysterious”

This lesson is about understanding the execution model.

1. What Is an Array?

A variable is one box:

int number = 10;

An array is multiple boxes as one structure:

int[] numbers = new int[3];

Meaning:

Allocate space for 3 int values
Each element is filled with the default value (0)

2. Index Starts at 0

If the array size is 3:

index: 0 1 2

The last valid index is always:

Length - 1

This is non-negotiable.

3. Compile-Time Error vs Runtime Error

Compile-Time Error (Type Mismatch)

numbers[0] = "hello"; // invalid type

The compiler blocks execution.

The program cannot run.

Runtime Error (Index Out of Range)

numbers[3] = 100; // index out of range

Compilation succeeds.

The program starts.

Then it crashes during execution.

Typical error:

Index was outside the bounds of the array

This is the exact difference:

Type mistakes fail early (compile-time)
Index mistakes fail late (runtime)

4. The Most Common Beginner Mistake

numbers[numbers.Length]

If Length = 3, valid indices are:

0, 1, 2

So numbers[3] is invalid.

Rule:

Last index = Length - 1

5. The ^ Operator (Index from End)

numbers2[^1]

Meaning:

Last element

Equivalent to:

numbers2[numbers2.Length - 1]

So:

^1 → last
^2 → second last

It is a convenience feature.

The indexing rules are still the same.

6. The One Rule You Must Not Break in for Loops

Correct:

i < numbers.Length

Incorrect:

i <= numbers.Length

Why?

Because the final iteration will produce:

i == Length

And numbers[Length] is out of range.

This is the classic off-by-one error.

7. The Biggest Limitation of Arrays

Arrays have fixed size.

new int[3]

Those 3 slots stay 3 slots.

You cannot grow or shrink the array.

So:

Fixed count → array
Variable count → later use List<T>

Final Summary

An array is an index-based structure that stores a fixed number of same-type values.

Learning Check (One Question)

Explain exactly when the runtime error occurs, step by step, tracking i:

int[] numbers = { 10, 20, 30 };

for (int i = 0; i <= numbers.Length; i++)
{
    Console.WriteLine(numbers[i]);
}

You must answer:

How does i change starting from 0?
What is numbers.Length here?
What is the final value of i?
At which exact moment does the crash happen, and why?

26. C# (Loop Performance)

Sabin Sim — Fri, 27 Feb 2026 15:58:01 +0000

0. The Real Goal of This Lesson

Loops do not increase execution time additively.
They increase it multiplicatively.

This is not a warning.

It is structural analysis.

If you misunderstand this:

Your API becomes slow
Your database melts
Your server “mysteriously” stalls

Performance degradation is not linear.

It compounds.

1. Why This Concept Is Necessary

As you build:

API servers
Database integrations
Request handlers
Collection processors
Large-scale data pipelines

The most dangerous combination is:

Nested loops + heavy operations (DB, file I/O, network, external API)

A loop does not “add time.”

It multiplies time.

2. What Is Program Performance?

Definition:

How fast a program runs
How many resources it consumes

Resources include:

CPU time
Memory
Disk access
Network calls
Database queries

The key shift:

Performance is not about:

“Is this code fast?”

It is about:

“How many times does this code execute?”

Execution count defines cost.

3. Dissecting Nested Loop Execution

Example:

using System;

class Program
{
    static void Main()
    {
        for (int i = 0; i < 4; i++)
        {
            for (int j = 0; j < 15; j++)
            {
                Console.WriteLine($"i={i}, j={j}");
            }
        }

        Console.ReadKey();
    }
}

Execution Timeline

i = 0 → inner loop runs 15 times
i = 1 → inner loop runs 15 times
i = 2 → inner loop runs 15 times
i = 3 → inner loop runs 15 times

Total executions:

4 × 15 = 60

Console.WriteLine is lightweight.

So you don’t feel the cost.

But performance is:

Cost per execution × number of executions

4. What If Each Inner Operation Takes 100ms?

for (int i = 0; i < 4; i++)
{
    for (int j = 0; j < 15; j++)
    {
        System.Threading.Thread.Sleep(100);
    }
}

Calculation:

1 execution = 100ms
60 executions = 6000ms

6 seconds.

From the user’s perspective:

“Is the server frozen?”

Key insight:

Loops multiply time.

They do not merely add time.

5. Optimization Strategy 1 — Early Termination with break

If the loop’s purpose is searching:

Stop when found.

Bad version:

int[] numbers = { 1, 2, 3, 4, 5 };

for (int i = 0; i < numbers.Length; i++)
{
    if (numbers[i] == 2)
    {
        Console.WriteLine("Found!");
    }
}

Problem:

Even after finding the value, the loop continues.

Improved version:

for (int i = 0; i < numbers.Length; i++)
{
    if (numbers[i] == 2)
    {
        Console.WriteLine("Found!");
        break;
    }
}

Execution stops immediately.

Unnecessary iterations are eliminated.

6. Optimization Strategy 2 — Move Heavy Operations Outside the Loop

Common mistake:

for (int i = 0; i < 4; i++)
{
    for (int j = 0; j < 15; j++)
    {
        var data = GetDataFromDatabase();
        Console.WriteLine(data);
    }
}

Database call count:

4 × 15 = 60 DB calls

Database operations are expensive.

Improved structure:

var data = GetDataFromDatabase();

for (int i = 0; i < 4; i++)
{
    for (int j = 0; j < 15; j++)
    {
        Console.WriteLine(data);
    }
}

Now:

1 DB call

Critical question:

Does this operation need to run every iteration?
Or only once?

This question defines performance maturity.

7. Growth Pattern of Nested Loops

One loop:

Two loops:

n × m

Three loops:

n × m × k

Each level multiplies execution count.

This is exponential growth in practical terms.

In complexity notation:

O(n)
O(n²)
O(n³)

Nested loops scale aggressively.

8. Common Performance Mistakes

Mistake	Result
DB call inside inner loop	Severe latency
No early exit	Unnecessary CPU usage
Deep nesting (3+)	Explosive execution count
Recomputing identical values	Resource waste

Performance bugs are often structural.

Not algorithmic.

9. Long-Term Perspective

As you move toward:

FastAPI / .NET APIs
Database integrations
AI data processing
Large collection filtering

The most important question is:

How many times does this execute?

Not:

Is the syntax correct?

Execution count determines scalability.

10. Final Summary

A loop multiplies execution time.
Placing heavy operations inside nested loops causes exponential performance degradation.

Final Question

If your API processes 10,000 records,

Which of the following should never be placed inside the loop?

Database call
External API request
File I/O
Simple variable increment

The answer reveals whether you think additively or multiplicatively.

25. C# (Nested Loop)

Sabin Sim — Wed, 25 Feb 2026 21:46:08 +0000

0. The Real Goal of This Lesson

In a nested loop,
every single outer iteration triggers a full execution of the inner loop.

Core principle:

One outer cycle = one complete inner cycle.

If you misunderstand this:

You miscalculate execution counts
You underestimate performance cost
You struggle with algorithm complexity

This is not about memorizing syntax.

It is about understanding multiplicative execution flow.

1. The Basic Example — 4 × 3

Full Runnable Code

using System;

class Program
{
    static void Main()
    {
        for (int i = 1; i <= 4; i++)
        {
            for (int j = 1; j <= 3; j++)
            {
                Console.WriteLine($"Outer: {i}, Inner: {j}");
            }
        }

        Console.WriteLine("Finished.");
        Console.ReadKey();
    }
}

Execution Flow — Step by Step

When i = 1

j = 1 → print
j = 2 → print
j = 3 → print

Inner loop completes.

When i = 2

j = 1 → print
j = 2 → print
j = 3 → print

And so on.

Total executions:

4 outer × 3 inner = 12 executions

Structural Visualization

i = 1
  j = 1
  j = 2
  j = 3

i = 2
  j = 1
  j = 2
  j = 3

Important:

j resets for every new i.

The inner loop starts from its initial state every time.

2. Understanding 4 × 3 Structurally

Mathematically, this is simple.

Structurally, it is clearer:

Outer loop = number of sets
Inner loop = repetitions inside each set

Example:

4 boxes
3 items per box

Total items:

4 × 3 = 12

This is multiplicative repetition.

3. Deeper Nesting — 4 × 3 × 5

Runnable Example

using System;

class Program
{
    static void Main()
    {
        for (int i = 1; i <= 4; i++)
        {
            for (int j = 1; j <= 3; j++)
            {
                for (int k = 1; k <= 5; k++)
                {
                    Console.WriteLine($"i:{i}, j:{j}, k:{k}");
                }
            }
        }

        Console.WriteLine("Finished.");
        Console.ReadKey();
    }
}

How Many Executions?

Outer: 4
Middle: 3
Inner: 5

Total:

4 × 3 × 5 = 60 executions

Each additional level multiplies the total count.

4. Why Performance Becomes a Concern

Each added nested loop increases complexity.

Example:

100 × 100 → 10,000 iterations
1,000 × 1,000 → 1,000,000 iterations

With three nested loops:

100 × 100 × 100 → 1,000,000 iterations

This growth is exponential.

In complexity terms:

O(n)
O(n²)
O(n³)

Nested loops are powerful.

But they scale aggressively.

5. Where Nested Loops Are Used in Practice

Common scenarios:

Two-dimensional arrays
Coordinate systems
Grid processing
Table generation
Pairwise comparisons
Algorithm problems

Whenever combinations of elements are involved, nested loops appear.

6. Observing the Flow in Rider

To fully understand:

Place a breakpoint inside the innermost loop
Use Step Into (F11)
Observe how k completes
Then j increments
Only after j finishes does i increment

Key observation:

The inner loop must fully finish before the outer loop continues.

This is hierarchical execution.

7. The Critical Thinking Habit

When reading nested loops, always ask:

How many total executions occur?

And think in multiplication:

outer_count × inner_count × ...

Never think linearly.

Nested loops are multiplicative by nature.

8. What You Must Understand at This Level

At your current level, you must clearly grasp:

Execution count grows by multiplication
Inner loop resets every outer iteration
More depth means exponential growth
Performance impact increases rapidly

These are structural truths.

Not implementation details.

Final Summary

A nested loop executes the entire inner loop for each iteration of the outer loop,
and total execution count increases multiplicatively.