Syntax and Semantic Errors

Vaibhav • September 11, 2025

In Chapter 1, you learned how to write simple C# programs using input, output, variables, and basic structure. You also saw how Visual Studio helps you compile and run your code. Now, it’s time to understand what happens when things go wrong - and how to fix them. In this article, we’ll explore two types of errors you’ll encounter early in your programming journey: syntax errors and semantic errors. These are the first bugs you’ll learn to debug, and understanding them is the foundation of becoming a confident programmer.

What Is a Syntax Error

A syntax error occurs when your code breaks the rules of the C# language. Just like a sentence in English needs proper grammar and punctuation, a line of code in C# must follow specific rules. If it doesn’t, the compiler won’t understand it - and it will stop your program from running.

Syntax errors are usually easy to spot because Visual Studio highlights them immediately. You’ll see red squiggly lines under the problem, and the Error List will show a message explaining what went wrong.

Console.WriteLine("Hello" // Missing closing parenthesis and semicolon

In this example, the closing parenthesis and semicolon are missing. The compiler expects every Console.WriteLine statement to end with );. Without it, the code is incomplete - and that’s a syntax error.

Here’s the corrected version:

Console.WriteLine("Hello");

Now the statement is complete, and the compiler can understand it.

Common Syntax Errors

Beginners often make the same kinds of syntax mistakes. Here are a few you might encounter:

// 1. Missing semicolon
int age = 25 // Error: expected ';'

// 2. Misspelled keyword
strng name = "Vaibhav"; // Error: 'strng' is not recognized

// 3. Unmatched quotes
Console.WriteLine("Welcome); // Error: missing closing quote

// 4. Using undeclared variables
Console.WriteLine(score); // Error: 'score' does not exist

Each of these errors breaks the rules of the language. The compiler will stop and show you exactly where the problem is. Your job is to read the message, understand what it means, and fix the code.

What Is a Semantic Error

A semantic error is different. Your code follows the rules of the language - so it compiles and runs - but it doesn’t do what you intended. These errors are harder to spot because there’s no red squiggly line. The program runs, but the output is wrong.

Console.Write("Enter your age: ");
string input = Console.ReadLine();
int age = int.Parse(input);

int nextYear = age + 2; // You meant to add 1, not 2

Console.WriteLine("Next year you will be:");
Console.WriteLine(nextYear);

This program compiles and runs, but it adds 2 instead of 1. That’s a semantic error - the logic is incorrect, even though the syntax is fine.

Common Semantic Errors

Semantic errors often come from misunderstanding how your code behaves. Here are a few examples:

// 1. Wrong calculation
decimal price = 100;
int quantity = 2;
decimal total = price + quantity; // You meant price * quantity

// 2. Incorrect input usage
Console.Write("Enter your name: ");
int name = int.Parse(Console.ReadLine()); // You meant to use string, not int

// 3. Printing the wrong variable
string city = "Pune";
string country = "India";
Console.WriteLine(city); // You meant to print country

These errors don’t stop your program from running, but they produce incorrect results. You’ll need to test your program carefully and think through your logic to catch them.

How Visual Studio Helps

Visual Studio is your best friend when it comes to finding syntax errors. It highlights mistakes as you type and shows helpful messages in the Error List. You can double-click an error to jump to the exact line.

For semantic errors, Visual Studio can’t help as much - because the code is technically correct. That’s where your own thinking and testing come in. Use Console.WriteLine to print values and check if they match your expectations.

int age = 25;
Console.WriteLine("Age:");
Console.WriteLine(age);

This technique - printing variables to check their values - is one of the simplest and most powerful debugging tools you have. You’ll use it often in this chapter.

Fixing Errors Step by Step

When you see an error, don’t panic. Follow these steps:

- Read the error message carefully - Look at the line number and character position - Check for missing punctuation, incorrect types, or undeclared variables - Fix the issue and recompile - Test the output to confirm the fix

For example, if you see:

error CS1002: ; expected

That means you forgot a semicolon. Look at the line above and add it. Then run the program again.

Using Output to Catch Semantic Errors

Since semantic errors don’t show up in the Error List, you’ll need to use output statements to catch them. Print your variables at key points in the program and compare the values to what you expect.

decimal price = 100;
int quantity = 2;
decimal total = price + quantity;

Console.WriteLine("Price:");
Console.WriteLine(price);

Console.WriteLine("Quantity:");
Console.WriteLine(quantity);

Console.WriteLine("Total:");
Console.WriteLine(total);

If the total is 102 instead of 200, you’ll know something is wrong. Then you can go back and fix the logic.

Practice: Spot the Error

Try reading the following code and identifying the error:

Console.Write("Enter your age: ");
int age = Console.ReadLine();

This is a syntax error. Console.ReadLine() returns a string, so you need to convert it to an integer using int.Parse:

int age = int.Parse(Console.ReadLine());

Now the code is correct and will compile.

Practice: Fix the Logic

Here’s a program that runs but gives the wrong result. Can you fix it?

decimal price = 100;
int quantity = 2;
decimal total = price + quantity;

Console.WriteLine("Total:");
Console.WriteLine(total);

This is a semantic error. You meant to multiply, not add:

decimal total = price * quantity;

Now the total will be 200, which is correct.

Best Practices for Avoiding Errors

- Write code slowly and carefully - Use meaningful variable names - Test with different inputs - Use Console.WriteLine to check values - Read error messages and fix one issue at a time - Keep your code clean and organized

The word “bug” in programming comes from a real insect. In 1947, engineers found a moth inside a computer that caused a malfunction. They removed it and called it “debugging.” Today, debugging means finding and fixing errors in your code.

Summary

In this article, you learned the difference between syntax and semantic errors. Syntax errors break the rules of the language and stop your program from compiling. Semantic errors follow the rules but produce incorrect results. You practiced reading error messages, using output to check values, and fixing mistakes step by step. These skills are the foundation of debugging - and you’ll use them throughout your programming journey. In the next article, we’ll explore the debugging process in more detail and learn how to approach errors with confidence and clarity.