C Basics: Syntax, Data Types, Operators & Control Flow

TAKEAWAYS

• C# is statically typed, requiring explicit variable declarations (e.g., int, string) and enforcing type safety at compile time.
• Operators (arithmetic, logical, bitwise) and control flow (if-else, switch, for, while) enable decision-making and iteration in programs.
• Input/Output (Console.ReadLine(), Console.WriteLine()) is the foundation for user interaction in console applications.
• Memory management in C# relies on value types (stack-allocated) vs. reference types (heap-allocated), affecting performance and garbage collection.
• Common pitfalls: implicit conversions, off-by-one errors in loops, and incorrect operator precedence can lead to runtime errors.
• Real-world tie: C# powers Khalti’s transaction validation (data types for amounts), Daraz’s order processing (loops for inventory checks), and Ncell’s billing systems (control flow for plan selections).

1. C# Syntax and Structure

C# is a case-sensitive, compiled language that runs on the .NET Framework. Every executable program starts with a Main method, the entry point.

using System;  // Required for basic I/O and other libraries

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("Hello, .NET!");  // Output to console
    }
}

Key Rules:

• Naming conventions: Classes start with uppercase (Program), methods with PascalCase (Main), variables with camelCase (userName).
• Semicolons (;) terminate statements.
• Braces {} enclose blocks of code (methods, loops, etc.).

2. Data Types in C#

C# supports primitive (built-in) and complex (user-defined) data types. They are categorized as:

• Value Types (stored directly in memory, stack-allocated):
  • Numeric: int, float, double, decimal, byte, short, long
  • Boolean: bool (true/false)
  • Character: char (16-bit Unicode)
  • Structs (e.g., DateTime, Point)
• Reference Types (stored as pointers to heap memory):
  • Classes (e.g., string, List<T>)
  • Arrays, delegates, interfaces

Example: Variable Declaration

int age = 25;               // Value type (stack)
string name = "Alice";      // Reference type (heap)
double salary = 35000.50;   // 64-bit floating-point
bool isEmployed = true;     // Boolean flag

Visual: Memory Allocation

graph LR
    A["Stack"] --> B["int age = 25\n(4 bytes)"]
    A --> C["bool isEmployed = true\n(1 byte)"]
    D["Heap"] --> E["string name = \"Alice\"\n(pointer to heap)"]
    E --> F["Heap Memory\n\"Alice\" (object)"]

Real-World Use:

• Khalti uses decimal for transaction amounts to avoid floating-point precision errors.
• Ncell’s billing system stores customer IDs as int (value type) for fast comparisons.

3. Operators in C#

Operators perform operations on variables and values. They are classified as:

Example: Operator Precedence

int result = 10 + 5 * 2;  // Multiplication first → 10 + 10 = 20

Trace Table:

Real-World Use:

• Daraz’s discount calculator uses * for percentage reductions:

  decimal finalPrice = originalPrice * (1 - discountPercentage);
  

4. Control Flow Statements

Control flow determines the order of execution. Key constructs:

A. Conditional Statements

1. if-else

   int age = 20;
   if (age >= 18)
   {
       Console.WriteLine("Eligible to vote.");
   }
   else
   {
       Console.WriteLine("Too young to vote.");
   }
   

   Visual: Decision Tree

2. switch-case (for multiple conditions)

   char grade = 'B';
   switch (grade)
   {
       case 'A': Console.WriteLine("Excellent"); break;
       case 'B': Console.WriteLine("Good"); break;
       default: Console.WriteLine("Invalid grade");
   }
   

Real-World Use:

• NTC’s speed limit enforcement uses if-else to classify vehicles:

  if (speed > 60) Console.WriteLine("Over speed limit!");
  

B. Loops

1. for loop (known iterations)

   for (int i = 1; i <= 5; i++)
   {
       Console.WriteLine($"Iteration {i}");
   }
   

   Trace Table:

   Iteration	i Value	Condition i <= 5	Action
   1	1	True	Print "Iteration 1"
   2	2	True	Print "Iteration 2"
   ...	...	...	...
   5	5	True	Print "Iteration 5"
   6	6	False	Exit loop

2. while loop (unknown iterations)

   int count = 0;
   while (count < 3)
   {
       Console.WriteLine($"Count: {count}");
       count++;
   }
   

3. do-while loop (executes at least once)

   int num;
   do
   {
       Console.Write("Enter a positive number: ");
       num = Convert.ToInt32(Console.ReadLine());
   } while (num <= 0);
   

Real-World Use:

• Pathao’s ride allocation uses a while loop to find the nearest available driver:

  while (driversAvailable.Count > 0 && !foundDriver)
  {
      // Check each driver's location
  }
  

5. Input and Output

C# uses Console class for basic I/O:

• Input: Console.ReadLine() (returns string), Convert.ToInt32() (parses strings to numbers).
• Output: Console.WriteLine(), Console.Write().

Example: User Interaction

Console.Write("Enter your name: ");
string name = Console.ReadLine();
Console.WriteLine($"Hello, {name}!");

Trace:

Real-World Use:

• eSewa’s login system uses Console.ReadLine() to capture user credentials (in real apps, this is replaced with secure input methods).

6. Common Pitfalls and Best Practices

In the Real World

1. Khalti’s Transaction System

   • Idea Used: Data Types and Operators
   • How: Transactions use decimal to store amounts (e.g., decimal amount = 500.75m;) to avoid floating-point rounding errors. Operators like + and - handle deductions and refunds.
   • Code Snippet:

     decimal balance = 1000.50m;
     decimal deduction = 200.25m;
     balance -= deduction;  // Updates balance to 800.25m
     

2. Daraz’s Order Processing

   • Idea Used: Loops and Control Flow
   • How: A for loop iterates through inventory to check stock availability before confirming an order.
   • Example:

     foreach (var item in order.Items)
     {
         if (warehouse.CheckStock(item.ProductId, item.Quantity))
         {
             Console.WriteLine($"Processing {item.Name}...");
         }
         else
         {
             Console.WriteLine($"Out of stock: {item.Name}");
         }
     }
     

3. Ncell’s Billing Plan Selector

   • Idea Used: switch-case for Menu-Driven Logic
   • How: Customers select plans (e.g., 'A', 'B', 'C') using a switch statement to apply different rates.
   • Example:

     Console.Write("Select plan (A/B/C): ");
     char plan = Console.ReadLine()[0];
     switch (plan)
     {
         case 'A': Console.WriteLine("1000 calls/month"); break;
         case 'B': Console.WriteLine("Unlimited calls"); break;
         default: Console.WriteLine("Invalid plan");
     }
     

Exam Tip

1. Syntax is Critical: Memorize keywords (int, for, if, Console.WriteLine) and their exact usage. Partial credit is rare for syntax errors.
2. Trace Tables: For loops and conditions, always show initialization, condition check, and update steps in your answer.
3. Data Type Questions: Expect questions on:
   • When to use int vs. double (e.g., int for counts, double for measurements).
   • The difference between value and reference types (e.g., int vs. string).
4. Operator Precedence: Always parenthesize expressions to avoid mistakes (e.g., (a + b) * c vs. a + b * c).
5. Real-World Scenarios: Relate control flow to systems like:
   • Bank loan approval (if-else for eligibility checks).
   • Traffic light system (switch-case for light changes).
6. Common Exam Patterns:
   • Debugging: Given a broken loop, identify the off-by-one error.
   • Output Prediction: Trace a for loop to predict console output.
   • Type Conversion: Convert between string and numeric types (e.g., int.Parse() vs. Convert.ToInt32()).

Pro Tip: Practice writing small programs (e.g., a calculator, grade checker) to reinforce syntax and logic. Use Visual Studio or VS Code with the C# extension for real-time error checking.