C# Syntax and Program Structure: Read, Trace, and Repair Code

What you will understand

• Explain a using directive, a method call, an argument and a semicolon.
• Distinguish a statement from a physical line of text.
• Trace the order in which simple statements execute.
• Recognize identifiers, keywords and quoted text.
• Use braces to identify a block and its local names.
• Compare top-level code with an explicit Main entry point.
• Diagnose syntax, name, runtime and logic problems separately.

Start with meaning, then inspect the symbols

In the previous lesson you made the tools work. Now focus on the instructions those tools accept. Syntax describes how tokens—names, keywords, operators and punctuation—can be arranged. You already use this idea in written language: punctuation helps a reader identify which words belong together. In source code, these boundaries must follow the language's rules.

Before running a program, answer two questions: what should it do, and where does that work happen? In the first example, the intended work is printing one message. The executable work is the WriteLine call; the using directive only helps resolve names. This separation keeps you from treating every source line as an instruction that produces output.

Each runnable editor below is a complete, separate Program.cs. Replace one program with another when practising locally; do not combine all the lesson examples in one project file. Shell commands such as dotnet run belong in the terminal, not inside a C# program.

using System;

Console.WriteLine("Ready to learn C#.");

Select Run code to compile and execute this program.

Ready to learn C#.

Read the first program from left to right

using System;

A directive that lets the compiler resolve types from the System namespace by short names. It is not a print instruction or a package download. System.Console.WriteLine would name the type fully.

Console

The type that provides console operations. Treat its spelling as exact: console is a different identifier.

.WriteLine

The dot selects a member; WriteLine names the method being called. A method is an operation you ask the program to perform.

("Ready to learn C#.")

Parentheses contain the supplied argument. Double quotes mark this argument as a string, so its words and punctuation are treated as text.

;

The semicolon terminates this statement. It sits outside the closing quote and parenthesis because it belongs to the source structure, not the message.

A statement is a unit of work, not a line

A call such as Console.WriteLine("First"); is an expression statement: evaluating the call performs an operation. A declaration such as int pageCount = 24; introduces a local variable and gives it an initial value. Both forms here end with semicolons. The examples use a small set of statement forms; do not turn that observation into a rule that every source line needs a semicolon.

A long statement can continue across several lines. Conversely, several statements can fit on one line. The compiler uses tokens and delimiters to read these boundaries. A newline is helpful layout, but it does not replace the missing semicolon after a declaration or method call.

Read the next example as three calls, not four output lines just because of its layout. Run it, then place each call on one source line. The output should remain unchanged. Later, class and method declarations will use brace-delimited bodies without the same trailing statement terminator.

using System;

Console.WriteLine(
    "First message"
);
Console.WriteLine("Second message"); Console.WriteLine("Third message");

Select Run code to compile and execute this program.

First message
Second message
Third message

Names refer to things; quoted words are data

An identifier names something in your program, such as pageCount. A keyword has a meaning defined by the language: int names a built-in whole-number type, while class introduces a class declaration. Choose simple, meaningful local names such as totalPages and pagesRead rather than abbreviations that hide their purpose.

For the ordinary names in this lesson, start with a letter or underscore and use letters, digits or underscores afterward; a name cannot start with a digit or contain a space. C# supports a wider set of Unicode identifiers and escaped keyword identifiers, but you do not need those for these exercises. camelCase for local variables is a convention for readers, not a requirement that every valid name must follow.

Spelling and capitalization are language rules, not optional formatting. pageCount and PageCount are different names. Quotation marks change the role entirely: "pageCount" is text, not a request to look up the variable. In an interpolated string introduced by $, the expression inside braces is evaluated before its result becomes part of the message.

using System;

int pageCount = 24;
Console.WriteLine(pageCount);
Console.WriteLine("pageCount");
Console.WriteLine($"Pages: {pageCount}");

Select Run code to compile and execute this program.

24
pageCount
Pages: 24

Trace the value at each statement

For the straight-line examples in this lesson, begin at the first executable statement and move downward. A declaration establishes a value before later statements use it. Printing that value reads it at the moment of the call; a subsequent assignment does not retroactively update the terminal.

In completedPages = completedPages + 3, first evaluate the right-hand expression using the current value. Then store the result in the name on the left. This is assignment, not a mathematical claim that one fixed number equals itself plus three. You will study assignments in detail in the variables lesson; here, use the line to practise tracing changes.

Predict Before: 4 and After: 7 before selecting Run. Then move the assignment above the first call. Both calls should now see 7. Describe the reason as a change in execution order, rather than assuming that the editor or compiler has remembered an earlier answer.

using System;

int completedPages = 4;
Console.WriteLine($"Before: {completedPages}");
completedPages = completedPages + 3;
Console.WriteLine($"After: {completedPages}");

Select Run code to compile and execute this program.

Before: 4
After: 7

Braces group statements and limit local names

An opening brace starts a block and its matching closing brace ends that block. Indentation makes the boundary easier for a person to follow. The braces in the example below are source structure, while braces inside an interpolated string mark expressions; the same visible symbol can have a different role depending on its context.

The inner block uses totalPages from the surrounding block and declares pagesRead for its own work. After the closing brace, the outer code can still use totalPages, but it cannot refer to that inner pagesRead name. This boundary is called scope. You are learning where a name is usable; you do not need to infer object lifetime or memory cleanup from this example.

Try adding Console.WriteLine(pagesRead); after the block. Expect a name diagnostic, then remove that extra call to restore the working program. Moving a closing brace changes structure and can change which names are visible; changing indentation alone does not move a name into another scope.

using System;

int totalPages = 20;
{
    int pagesRead = 6;
    Console.WriteLine($"Inside: {totalPages - pagesRead}");
}
Console.WriteLine($"Outside total: {totalPages}");

Select Run code to compile and execute this program.

Inside: 14
Outside total: 20

Two program shapes, one starting point

Our short examples use top-level statements: the compiler provides an entry-point method around the executable code. Existing projects may instead declare a Program class with a static Main method explicitly. The next example is an alternative complete program, not a wrapper you should paste below the first one.

Read its nesting from outside inward: a class contains Main, and Main contains the call that prints the message. The class name is not itself a call, and defining a method does not mean every method in a project runs automatically. Here, the runtime begins with the chosen entry point and follows its statements.

Use one style at a time while learning. A project can have only one source file containing top-level statements; helper files can contain types without becoming extra starting points. If top-level code is present alongside an explicit Main, the top-level code supplies the entry point rather than running both bodies in sequence. You do not need to convert working older code just to make its layout resemble the short form.

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("Ready to learn C#.");
    }
}

Select Run code to compile and execute this program.

Ready to learn C#.

Readable layout helps you see the real structure

Use one statement per line, a consistent indentation level within each block, and blank lines between related steps. These choices make missing punctuation and misplaced braces easier to notice. They are habits for readers; adding a blank line does not introduce a new execution step.

Whitespace is not universally disposable. It separates tokens that would otherwise merge, and spaces inside an ordinary string are part of its value. You cannot turn int pageCount into intpageCount and expect the same declaration. Likewise, do not split an ordinary quoted string across physical lines as if it were a multiline call.

Comments let you explain a decision without printing the explanation. A // comment continues to the end of its source line. The following intentionally awkward formatting is legal; reformat the calls and preserve their text exactly. The next lesson focuses on output, and the later comments lesson will develop these readability habits further.

using System;

// Extra spacing between tokens can be changed.
Console . WriteLine ( "A  B" ) ;
Console.WriteLine("A B");

Select Run code to compile and execute this program.

A  B
A B

Identify the kind of failure before choosing a repair

A missing semicolon prevents the compiler from reading the required statement boundary. A misspelled name can also prevent compilation even when the punctuation is valid. Read the first useful diagnostic, locate its source line, and inspect nearby context. Fix one underlying cause before interpreting every later message as a separate problem.

A runtime failure happens after compilation when an operation cannot complete with the current values. A logic error is different again: the program finishes but gives a result that does not match your intended rule. The examples below show a punctuation error, a name error, and integer division by zero. The repair exercise then adds an incorrect calculation that the compiler can legally accept.

Use the runner's compiler diagnostics and terminal output as different kinds of evidence. No application output is expected from these compilation failures. In the division example, an earlier message can appear before the operation fails. A green completion result alone never proves that your business calculation is correct; compare it with an independently predicted answer.

using System;

Console.WriteLine("First")
Console.WriteLine("Second");

Select Run code to compile and execute this program.

Compilation fails; no application lines run.

using System;

int pageCount = 24;
Console.WriteLine(PageCount);

Select Run code to compile and execute this program.

Compilation fails because PageCount is not the declared pageCount name.

using System;

int pageCount = 24;
int groupCount = 0;
Console.WriteLine("Starting calculation");
Console.WriteLine(pageCount / groupCount);

Select Run code to compile and execute this program.

Starting calculation
Then execution fails with DivideByZeroException.

Guided repair: fix compilation, then check meaning

This report should subtract eight read pages from thirty total pages. Predict 22 first. Repair the program in stages: punctuation, consistent naming, then the calculation. Explain which stages are required for compilation and which are required for the intended answer.

using System;

int totalPages = 30
int pagesRead = 8;
Console.WriteLine($"Pages left: {TotalPages + pagesRead}");

Select Run code to compile and execute this program.

Compilation fails first. After compilation is repaired, verify the calculation separately.

Work through these checkpoints

1. The original source must fail compilation.
2. After fixing the semicolon and identifier, addition produces 38: legal source, wrong rule.
3. After replacing addition with subtraction, expect 22.
4. Change pagesRead to 0 and then 30; expect 30 and 0.
5. Do not replace the expression with the literal answer 22; the result must respond to changed inputs.

using System;

int totalPages = 30;
int pagesRead = 8;
Console.WriteLine($"Pages left: {totalPages - pagesRead}");

Select Run code to compile and execute this program.

Pages left: 22

Independent lab: a reading report you can explain

Finish a reading report without looking at the reference solution first. Use the same simple syntax you have traced: declarations, calls, expressions and strings. After the report works, explain its statement order aloud or in your own notes.

Acceptance checklist

• Keep totalPages = 40 and pagesRead = 12 for the first run.
• Print exactly three lines: Reading report, Remaining: 28, and Read: 12.
• Calculate remaining pages from the two stored values.
• Print the value of pagesRead rather than its identifier as quoted text.
• Format one statement per line and keep identifiers consistently spelled.
• Recognize that the exercise assumes valid counts; it does not validate or save progress.

using System;

int totalPages = 40;
int pagesRead = 12;
Console.WriteLine("Reading report");
Console.WriteLine($"Remaining: {totalPages + pagesRead}");
Console.WriteLine("pagesRead");

Select Run code to compile and execute this program.

Reading report
Remaining: 52
pagesRead

using System;

int totalPages = 40;
int pagesRead = 12;
Console.WriteLine("Reading report");
Console.WriteLine($"Remaining: {totalPages - pagesRead}");
Console.WriteLine($"Read: {pagesRead}");

Select Run code to compile and execute this program.

Reading report
Remaining: 28
Read: 12

Changed-input checks and a stretch exercise

• pagesRead = 0 should produce Remaining: 40 and Read: 0.
• pagesRead = 40 should produce Remaining: 0 and Read: 40.
• pagesRead = 45 produces Remaining: -5; explain that validation is not yet implemented.
• Change totalPages to 60 and pagesRead to 15; expect Remaining: 45.
• Stretch: put the same three calls inside an explicit Main method and compare output. Use the explicit example as a structural reference, not as extra code appended after top-level statements.

Questions beginners ask

Recap: a useful way to read any small program

Identify the entry point, then read one statement at a time. Separate names from text, identify each block, and track values as execution reaches them. Use punctuation and name diagnostics to repair compilation; use predicted answers and changed inputs to check the program’s purpose.

You do not need to memorize every future keyword. You should be able to explain this lesson’s calls, declarations, assignments and block boundaries in your own words. Next is C# Console Output, where you will practise making the results easier for a reader to understand.

References and further reading

Original SovranCode scenarios and exercises, with language rules checked against the official references below.

• Microsoft Learn: C# program overview
• Microsoft Learn: Top-level statements
• Microsoft Learn: Identifier rules and conventions

Last updated: 25 October 2026.